Abstrakte Klassen und Interfaces

Abstrakte Klassen und Interfaces
Abstrakte Klassen
■ Abstrakte Klassen
■ Interfaces (Schnittstelle)
■ Mehrfachvererbung mit Interfaces
■ Interfaces vs. abstrakte Klassen
■ Innere Klassen
■ Anonyme Klassen
■ Adapterklassen
School of Engineering
Abstrakte Klassen und Methoden
School of Engineering
■Einige Methode können in der Oberklasse implementiert werden:
Figure
■ Beispiel:
Klassenhierarchie für verschiedene
geometrische Figuren wie Rechteck,
Kreis, Dreieck
■ Methoden, die alle Unterklassen haben
müssen, werden in der Oberklasse
deklariert
Æ Polymorphismus ruft die richtige
Methode auf
2 von 50
Abstrakte Klassen und Methoden
Problemstellung
■ Die Klassen für die einzelnen Figuren
sollen alle die gleiche Funktionalität
haben
© A. Meier/M. Braschler/J. Zeman/K. Rege
setSize(int w, int h)
setPos(int x, int y)
int x,y,w,h
■Andere Methoden können hingegen nicht sinnvoll implementiert werden:
void draw()
getArea()
...
Rectangle
public void draw (Graphics g)
public double getArea()
Problem: Wie stellt man sicher, dass auch zukünftige Unterklassen der
Klasse Figur, die gemeinsamen Methoden draw und
getArea implementieren?
Circle
int mx,my
void draw()
Æ Abstrakte Methoden und Klassen (abstract class)
void draw()
public abstract void draw(Graphics g);
public abstract double getArea();
Mögliche Klassenhierarchie für
Klasse Figur
© A. Meier/M. Braschler/J. Zeman/K. Rege
■Abstrakte Methoden zwingen den Programmierer, eigene Implementationen für
alle abstrakten Methoden zu schreiben
3 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
4 von 50
Abstrakte Klassen
Abstrakte Methoden
■haben nur einen Methodenkopf (Signatur), keinen Methodenkörper
■haben den Modifikator abstract im Methodenkopf
■Eine abstrakte Klasse hat mindestens eine abstrakte Methode und/oder ist als
abstract deklariert
■haben einen Strichpunkt (;) nach der Signatur
■Sie kann nicht instanziert werden!
■ Unterklassen von abstrakten Klassen müssen die abstrakten Methoden implementieren,
sonst müssen sie ebenfalls als abstract deklariert sein
Folge für die Klasse Figur:
■Sobald eine Methode der Klasse Figur abstract ist, muss auch die Klasse
selbst als abstract deklariert sein:
Figure
Figure
int x,y,w,h
public abstract class Figur{
public abstract void draw(Graphics g);
public abstract double getArea();
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
void draw()
getArea()
...
5 von 50
School of Engineering
int x,y,w,h
void draw()
getArea()
...
© A. Meier/M. Braschler/J. Zeman/K. Rege
6 von 50
Abstrakte Klassen
Kontrollfrage
■ Worin unterscheiden sich abstrakte Methoden von Methoden mit leerer
Implementation
■ Beispiel: Klasse Rechteck :
© A. Meier/M. Braschler/J. Zeman/K. Rege
Figure
int x,y,w,h
class Rectangle extends Figur{
public void draw(Graphics g){
g.drawRect(x, y, w, h);
}
public double getArea(){
return (double) w*h;
}
public class Figur{
public void draw(Graphics g) {
// leere Methode
}
public double getArea(){
// leere Methode
return 0 // dummy return
}
}
School of Engineering
oder
<<abstract>>
Rectangle
}
Aufgabe: Leiten Sie die Klasse Circle
von der abstrakten Klasse Figur ab
7 von 50
School of Engineering
void draw()
getArea()
...
Circle
int mx,my
void draw()
© A. Meier/M. Braschler/J. Zeman/K. Rege
void draw()
8 von 50
Vorteile von abstrakten Klassen
Teil-Abstrakte Klassen
■ Bei einer Klasse kann ein gemeinsame Teil implementiert sein.
■Ein bestimmtes Klassendesign kann erzwungen werden!
public abstract class Figur{
protected int x,y,w,h;
■Sie erlaubt die Klassenbeschreibung in höheren Abstraktionsebenen:
Figure(int x, int y, int w, int h) {
this.x = x; this.y = y;this.w = w; this.w = w;
}
■
Von der Klasse Figur können keine Objekte (Instanzen) erzeugt werden.
■
Sie fasst alle Objekte mit bestimmten Eigenschaften unter einem neuen Namen zusammen
Analogie in der Biologie:
void setPos(int x, int y) {
this.x = x; this.y = y;
}
void setSize(int w, int h) {
this.w = w; this.h = h;
}
■Ein Säugetier existiert selbst nicht (als Spezies), sondern ist ein Sammelbegriff
(Abstraktion) von real existierenden Tieren
Alles in allem:
Æ Abstrakte Klassen erleichtern die Planung und den Aufbau von
public abstract void draw(Graphics g);
public abstract double getArea();
Klassenhierarchien
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
9 von 50
Klassifizierung in Klassenhierarchien
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
10 von 50
Übung
■ Geben Sie je zwei Methoden an, die Sie in der gemeinsamen Oberklasse
Fahrzeuge
■Zusammenfassen von gleichartigen Objekten zu abstrakten Klassen
■Konzentrieren von gemeinsamen Eigenschaften und Methoden in der
abstrakten Oberklasse
■
■
■Vorschreiben von weiteren Methoden, die in den Unterklassen implementiert
werden müssen
a) als abstrakt deklarieren würden
b) deklarieren und implementieren würden
■ Was wäre eine mögliche Oberklasse von Fahrzeug
Zweiräder
PKWs
Transportfahrzeuge
Erdbewegungsfahrzeuge
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
11 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
12 von 50
Interfaces = reinabstrakten Klassen
Ein Interface definiert eine Schnittstelle zwischen Klassen:
■Ein Interface ist eine "Klasse", die nur aus Methodenköpfen besteht:
public interface Displayable {
public void draw(Graphics g);
}
Interfaces
■Ein Interface ist im Prinzip eine reinabstrakte Klasse, in welcher sämtliche
Methoden abstrakt deklariert sind Æ Bezeichnung interface anstatt class
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
13 von 50
Interfaces werden implementiert: implements
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
14 von 50
Merkmale eines Interfaces
■Klassen erben (extends) nicht von Interfaces sondern implementieren diese
(implements)
■Sie haben Interfaces schon verwendet:
■Entspricht einer (abstrakten) Klasse, die nur aus Methodeköpfen besteht
■
Methoden sind per Default public (Î public kann auch weglassen werden)
■
Ein Interface ist immer abstract (abstract kann weggelassen werden)
Æ Es können deshalb keine Objekte aus einem Interface erzeugt werden
public interface ActionListener {
public void actionPerformed(ActionEvent event);
}
java.awt.event
■Interfaces definieren wie Klassen einen neuen Datentyp
Æ Es können Variablen dieses Datentyps deklariert werden:
Displayable dsp;
public class MyApplet extends Applet implements ActionListener {
public void actionPerformed(ActionEvent event) {
……………………………
}
Ein Interface beschreibt nur die Schnittstelle (Klasse, Methoden,
Parameter) einer Klasse, nicht deren Implementierung
}
■sämtliche Methoden eines Interfaces müssen von der Klasse implementiert
werden Æ sonst Klasse abstrakt, d.h. kann nicht instanziert werden
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
15 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
16 von 50
…Merkmale eines Interfaces
…Merkmale eines Interfaces
■Methoden dürfen nicht static sein
■Interfaces können wie Klassen an Unter-Interfaces weitervererbt werden
extends wird in diesem Fall ebenfalls verwendet
■Hingegen müssen alle Variablen eines Interfaces static final
(d.h. Konstanten) sein
public interface Verkehrsmittel {
}
■Interfaces können übersetzt, aber nicht instanziert werden
public interface Fahrzeug extends Verkehrsmittel {
}
■ Das Compilieren erlaubt Typenprüfung bei der Verwendung eines Interfaces
■es können mehrere Interfaces von einer Klasse implementiert werden
if (obj instanceof Displayable) {...
■ Interface Typen können in der Parameterliste von Methoden stehen
class MyApplet extends Applet
implements ActionListener, MouseListener {
void foo (Displayable d) {...
-> erzwingt, dass nur Objekte übergeben werden können, deren Klasse ein
bestimmtes Interface implementiert z.B. addActionListener(ActionListener l)
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
17 von 50
Deklaration von Interfaces
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
18 von 50
Graphische Darstellung von Interfaces
■Ein Interface beschreibt die Methoden die alle Klassen mindestens
implementieren.
■ Im Klassenbaum werden Interfaces
gekennzeichnet
■Für Figuren könnten das z.B.
■ Das "implementiert" Symbol ist etwas
schlanker als das "erbt" Symbol
Displayable <<interface>>
void draw()
implementiert
implementiert
Figure
<<abstract>>
int x,y,w,h
void draw()
getArea()
...
public interface Displayable {
void draw(Graphics g);
}
implementieren
implementieren
ebenfalls Displayable
ebenfalls Displayable
(weil von Figure erben)
(weil von Figure erben)
Rectangle
int mx,my
void draw()
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
19 von 50
School of Engineering
Circle
© A. Meier/M. Braschler/J. Zeman/K. Rege
void draw()
20 von 50
Verwendung von Interfaces
Implementieren von Interfaces
■Ein Interface wird durch eine Klasse implementiert.
■Interfaces stellen sicher, dass eine Klasse gewisse Eigenschaften hat bzw.
bestimmte Methoden zur Verfügung stellt (implementiert hat)..
■Deklaration einer Klasse, die ein Interface implementiert:
■Es können Variablen von einem Interface Typ erstellt werden
class MeineKlasse implements Interfacename {...}
■Die Klasse muss alle Methoden des Interfaces implementieren Æ implements
verpflichtet dazu !
Displayable dsp = new Rectange(…);
■Alle im Interface definierten Methoden müssen von Rectangle implementiert
werden Æ können deshalb "sicher" aufgerufen werden.
Æ wird vom Compiler überprüft!
dsp.draw(g);
■Klassen, die ein Unter-Interface implementieren, müssen auch alle Methoden
der Ober-Interfaces implementieren
■Rectangle kann noch zusätzliche (nicht im Interface deklarierte) Methoden
implementieren z.B. getArea(…)
■Eine Klasse kann gleichzeitig mehrere Interfaces implementieren:
■Frage: wie kann ich diese aufrufen?
class MeineKlasse implements Interface1, Interface2,... {...}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
21 von 50
Regel: Der statische Typ (Typ von dem die Variable deklariert wurde) bestimmt,
welche Methoden und Attribute bekannt sind.
dsp.getArea();
© A. Meier/M. Braschler/J. Zeman/K. Rege
22 von 50
Interfaces: …Beispiel
Sichtbarkeit von Methoden
Displayable dsp = new Rectange(…);
School of Engineering
implements
implementsDisplayable
Displayable
import java.awt.*;
class Rechteck extends Figure {
public void draw(Graphics g){
g.drawRect(xPos, yPos, breite, hoehe);
}
gilt
giltauch
auchfür
für
abstrakte
abstrakteund
und
reguläre
Klassen
reguläre Klassen
public double getArea(){
return (double) breite*hoehe;
}
■ Lösung
■ zuerst in Variable mit richtigem statischen Typ zuweisen
Rectange rect = (Rectange)dsp;
...
Rechteck (int x, int y, int w, int h) {
super(x, y, w, h);
}
double d = rect.getArea();
■ oder Cast und Aufruf kombiniert
wegen
wegenDisplayable
Displayable
Implementierung der
Implementierung der
abstrakten Methoden der
abstrakten Methoden der
Klasse Figure
Klasse Figure
Konstruktor
Konstruktor
}
double d = ((Rectangle)dsp).getArea();
■ Kontrollfrage: funktioniert das auch wenn ich zu Figure caste
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
23 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
24 von 50
Interfaces: …Beispiel
Vorteil von Interfaces
public class FigurTest extends Applet {
Displayable [] dsp = new Displayable[2];
public void init() {
dsp [0] = new Rechteck(10, 20, 100, 60);
dsp [1] = new Kreis(10,100,30);
}
Array
Arrayvom
vomInterface-Typ
Interface-Typ(Displayable)
(Displayable)
ÆÆKennt
die
Kennt dieMethoden
Methodendraw
draw
■ Es kann etwas dargestellt werden, sobald das Displayable Interface
implementiert wird; man muss grundsätzlich
nicht von Figure erben.
Displayable <<interface>>
void draw()
implementiert
implementiert
public double getArea(int dx){
double totArea= 0;
for (int i=0; i<dsp.length; i++){
totArea+= ((Figure)dsp[i]).getArea();
}
return totArea;
}
Displayable kennt nicht die Methode
Displayable kennt nicht die Methode
public void paint(Graphics g) {
getArea (von Klasse Figure)
getArea (von Klasse Figure)
for (int i=0; i<dsp.length; i++){
Î Type-Cast notwendig
Î Type-Cast notwendig
dsp[i].draw(g);
}
}
<<abstract>>
Fahrzeug
Figure
<<abstract>>
int x,y,w,h
int getAchsen()
...
void draw()
getArea()
...
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
25 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
26 von 50
Kontrollfragen
■ was ist in folgendem Interface falsch
public interface SomethingIsWrong {
public void aMethod(int aValue){
System.out.println("Hi Mom"); }
}
■ was ist in folgendem Interface falsch
Mehrfachvererbung von Interfaces
public interface Marker { }
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
27 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
28 von 50
Probleme der Mehrfachvererbung von Klassen
Mehrfachvererbung von Klassen (z.B C++)
■Durch Mehrfachvererbung könnten auch komplexe Vererbungsbeziehungen
ausgedrückt werden, Bsp:
Schiff
Flugzeug
schwimmen
fliegen
links
links
rechts
rechts
1) Aufruf von super nicht mehr
3) Mehrfach geteilte Oberklassen:
Diamant Struktur
eindeutig, z.B.
super.links();
■
2)
■
mögliche Lösung: Spezifikation welche
Oberklasse gemeint
(Motorschiff)super.links();
Mehrere Oberklassen: welcher
Konstruktor wird aufgerufen?
■
mögliche Lösung beide:
■ (Motorschiff)super();
■ (Motorfahrzeug)super();
zusätzliche Probleme: welcher
Konstruktor über welches
Verkehrsmittel wird aufgerufen
(Reihenfolge?, wie oft?)
Verkehrsmittel
Schiff
Flugzeug
Wasserflugzeug
Wasserflugzeug
schwimmen
fliegen
Entscheidung der Java Sprachentwerfer: Mehrfachvererbung
von Klassen in Java nicht unterstützen
links
rechts
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
29 von 50
in der Praxis üblich:
interface
interface Schwimmen{
Schwimmen{
void
void schwimmen();
schwimmen();
}}
Interface B
Hauptlinie der
Vererbung
© A. Meier/M. Braschler/J. Zeman/K. Rege
30 von 50
Lösung mit Interfaces
Mehrfachvererbung: „Lösung“ mit Interfaces
Klasse A
School of Engineering
abstract
abstract class
class Verkehrsmittel{
Verkehrsmittel{
void
void links();
links();
void
rechts();
void rechts();
}}
Interface C
Schwimmen <<interface>>
Verkehrsmittel
Seiteneinflüsse
(Verhaltensvorschriften)
Schiff
Flugzeug
Klasse D
interface
interface Fliegen
Fliegen {{
void
void fliegen();
fliegen();
}}
Fliegen
<<interface>>
implementiert
implementiertInterface
Interfaceweil
weil
von
vonOberklasse
Oberklassegeerbt
geerbt
Wasserflugzeug
Java beschränkt sich auf Einfachvererbung, bietet dafür Interfaces
(Signaturen von Methoden),welche dann „implementiert“ werden müssen.
Mehrfachvererbung
Mehrfachvererbungvon
vonInterfaces
InterfacesininJava
Javaunterstützt
unterstützt
class Wasserflugzeug extends Flugzeug implements Schwimmen {
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
31 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
32 von 50
Vorteile von Interface-Mehrfachvererbung
Mehrfachvererbung von Interfaces im GUI
■ Java erlaubt nur einfache Vererbung! Æ Verwechslungs-Problematik von
Methoden bei Mehrfachvererbung wird vermieden
■ Eine Klasse, die ein Interface implementiert „erbt“ nur die Pflicht die Interface-
■ Mehrfachvererbung ist aber nachbildbar mit Interfaces,
da eine Klasse mehrere Interfaces implementieren kann
■ Im Gegensatz zur (mehrfach) Klassenvererbung keine Einsparung der
Methoden selber zu Programmieren
Programmierarbeit!
■ Beispiel:
Das Applet MeinSpiel ist abgeleitet von der
Klasse Applet (Vererbung). Zusätzlich soll es die Interfaces
ActionListener und MouseListener implementieren:
■ Vorteile
■
Eine zweite Interfacehierarchie, unabhängig von "Klassen-Stammbaum"
■
Man kann überall anstelle einer Klasse auch ein Interface verwenden Æ eine Variable vom
Schnittstellentyp Æ von jedem Objekt, auf welches sich die Variable bezieht, angenommen
public class MeinSpiel extends Applet
implements ActionListener, MouseListener{
...
}
wird, es habe diese Schnittstelle implementiert
■
Man kann ein Objekt, dass ein Interface Z implementiert mit einer Variable vom Typ interface Z
referenzieren und dort eine dazugehörige Interface-Methode (meth1) aufrufen
■
Das erlaubt Applikationen zu schreiben, die unbekannte Klassen benutzen können
(solange diese eine vereinbarte Schnittstelle implementieren)
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
33 von 50
Klassenbibliothek Beispiel: ActionListener
MyApplet Implements ActionListener
ActionListener
<<interface>>
■
void actionPerformed(…)
…….
■
Button
ButtonBBbekommt
bekommtbeim
beim
„AddActionListener(this)“
„AddActionListener(this)“die
dieReferenz
Referenz
auf
aufein
einbeliebiges
beliebigesObjekt
Objekt(MyApplet).
(MyApplet).
Button
ActionListener listener:
34 von 50
■ Interfaces und abstrakte Klassen werden leicht verwechselt. Es bestehen
folgende Unterschiede:
■
Beliebige
BeliebigeKlasse
KlasseXY
XY
Implements
ImplementsActionListener
ActionListener
Button B = new Button();
B.addActionListener(this);
© A. Meier/M. Braschler/J. Zeman/K. Rege
Interfaces vs.
vs. Abstract Classes
actionPerformed(..)
……
School of Engineering
■
// Anmeldung von Listener
addActionListener (ActionListener l)
listener = l;
Eine abstrakte Klasse kann eine Implementierung von einer oder mehreren Methoden zur
Verfügung stellen. Ein Interfaces stellt nie eine Implementierung zur Verfügung.
Eine Klasse kann mehrere Interfaces implementieren, aber nur eine abstrakte Klasse
erweitern.
Ein Interface wir vom Compiler für Überprüfungen benutzt. Im Gegensatz dazu hat eine
abstrakte Klasse Vererbung zur Folge, die das Einbinden der entsprechenden Methoden
während der Laufzeit nach sich zieht.
Eine abstrakte Klasse hat zur Folge, dass ihre abstrakten Methoden in der Subklasse
implementiert werden Æ Vererbung wird angenommen. Aber ein Interface stellt einfach ein
Skelett für eine Klasse dar, ohne jegliche Andeutung, dass sie zur Vererbung benutzt wird
(Jedoch kann ein Interface Vererbung festlegen)
//Eventbehandlung B (Component)
listener.actionPerformed(e);
Es kann dort aber (unabhängig von Typ des
Es kann dort aber (unabhängig von Typ des
Objekts) die Methode „ActionPerformed“ aufrufen
Objekts) die Methode „ActionPerformed“ aufrufen
Æ weil für die Referenzierung (interne Variable)
Æ weil für die Referenzierung (interne Variable)
der Interface- und nicht der Objekt-Typ verwendet
der Interface- und nicht der Objekt-Typ verwendet
wird.
wird.
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
35 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
36 von 50
Objekt, Klasse, abstrakte Klasse, Interface
■■ Objekt
Objektrepräsentiert
repräsentiert
Gegenstand/Konzept
Gegenstand/KonzeptininSW:
SW:
■
■
■
■
■
■
extends
■■ abstrakte
abstrakteKlasse
Klasseist
isthalbfertiger
halbfertiger
Bauplan:
Bauplan:abstact
abstactclass
class
■
■
■
■
Zustand
Zustand
Verhalten (Objekt-Methoden)
Verhalten (Objekt-Methoden)
Identität
Identität
kann
kannnicht
nichtinstanziiert
instanziiertwerden
werden
mindestens
mindestenseine
eineMethode
Methodeals
alsabstrakt
abstrakt
deklariert
deklariert
new
■■Klasse
Klasseist
istder
derBauplan
Bauplaneines
einesObjekts:
Objekts:
class
class
■ Datentypen der Attribute
■ Datentypen der Attribute
■ Beschreibung der Objektmethoden
■ Beschreibung der Objektmethoden
■ Beschreibung der Klassenmethoden
■ Beschreibung der Klassenmethoden
■ es kann nur von einer Klasse geerbt werden:
■ es kann nur von einer Klasse geerbt werden:
extends
■■ Interface
Interfaceist
istdie
dieBeschreibung
Beschreibungder
der
Schnittstelle:
Schnittstelle:Interface
Interface
implements
extends
extends
School of Engineering
kann
kannnicht
nichtinstanziiert
instanziiertwerden
werden
Interfaces
Interfaceswerden
werdenvon
vonKlassen
Klassen
implementiert:
implementiert:implements
implements
■
es
können
mehrere
Interfaces
■
es können mehrere Interfacesgleichzeitig
gleichzeitig
implementiert
implementiertwerden
werden
■
■
■
■
© A. Meier/M. Braschler/J. Zeman/K. Rege
37 von 50
Innere Klassen Beispiel
38 von 50
class Außen {
….
class Innen {
}
}
Der
DerRückgabewert
Rückgabewertvon
von
new()
new()wird
wirddirekt
direktals
als
Referenz
");
Referenzauf
aufdas
das
Listener-Objekt
Listener-Objekt
verwendet
verwendet
■Sie sind für alle anderen Klassen nicht sichtbar.
Æ keine Probleme mit Namenskonflikte
public void init() {
add(helloButton);
add(textfeld);
helloButton.addActionListener(new Bearbeiter());
}
public void paint(Graphics g) {
innere
}
innereKlasse
KlasseBearbeiter
Bearbeiter
class Bearbeiter implements ActionListener {
public void actionPerformed(ActionEvent e){
textfeld.setText("Hallo Welt");
}
}
Bearbeiter hat Zugriff auf die
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
■Innere Klassen werden innerhalb einer Klasse definiert:
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class InnerDemo extends Applet {
Button helloButton = new Button("Hello");
TextField textfeld = new TextField("
School of Engineering
Innere Klassen
Innere Klassen: Beispiel1: ActionListener
}
Innerer Klassen
implements
extends
extends
■sie können auf Methoden und Variablen im Gültigkeitsbereich der
übergeordneten Klasse zugreifen, auf die sie sonst von einer eigenständigen
Klasse nicht zugreifen könnten !!!
■Meist kleine Klassen, die nur für eine sehr eingeschränkte Aufgabe
zuständig sind.
■Anwendungsbeispiel: u.a. Implementierung des Listener Interface wenn
der Listener als separate Klasse realisiert wird
Bearbeiter hat Zugriff auf die
Variablen der umgebenden Klasse
Variablen der umgebenden Klasse
© A. Meier/M. Braschler/J. Zeman/K. Rege
39 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
40 von 50
Anonyme (innere) Klasse als ActionListener
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class AnonymDemo extends Applet {
Button helloButton = new Button("Hello");
TextField textfeld = new TextField(10);
Kein
KeinKlassenname
Klassennamedefiniert
definiert! !
ÆÆanonyme
anonymeKlasse
Klasse
Die
DieKlasse
Klassewird
wirdbei
beider
derErzeugung
Erzeugung
direkt
direktausprogrammiert.
ausprogrammiert.
public void init() {
add(helloButton);
add(textfeld);
helloButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e){
textfeld.setText("Hallo Welt");
}
}
);
}
public void paint(Graphics g) {
}
Anonyme Klassen
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
41 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
42 von 50
Anonyme Klasse: Zusammenfassung
■Sind lokale Klassen ohne Namen,
■Werden in genau einer Anweisung deklariert, instanziert und benutzt.
■Anonyme Klassen sind die schnellste Möglichkeit, kleinere
Ereignisbehandlungen durchzuführen
Adapter Klassen
■Anonyme Klassen machen nur dann Sinn, wenn sie nur einmal im
Programm benutzt (instanziert) werden.
Æ z.B. Pro GUI-Komponente eine (anonyme) Event-Listener-Klasse
■
Bei erfolgreicher Übersetzung erscheinen anonyme Klassen unter der Bezeichnung der
umgebenden Klasse mit klasse$1.class, klasse$2.class, ... für
jede anonyme Klasse im Dateiverzeichnis.
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
43 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
44 von 50
Adapter-Klassen
… Adapter-Klassen
import java.awt.event.*;
■Implementieren dazugehörige Schnittstelle (mit leeren Methoden)
■Vorteil: weniger Schreibarbeit, man überschreibt nur diejenige Methoden, die
nicht leer sein sollen.
■Es gibt u.a. MouseListener-Interface und MouseAdapter-Klassen
class MoveBalloons extends Applet implements MouseListener
{
Balloon balloon = new Balloon();
public init {
addMouseListener(this);
Balloon balloon = new Balloon();
}
// Implementiere MouseListener
public void mouseClicked(MouseEvent event ) {
balloon.setPos(event.getX(), event.getY());
repaint();
}
public void mouseEntered(MouseEvent event ) {}
public void mouseExited(MouseEvent event ) {}
public void mousePressed(MouseEvent event ) {}
public void mouseReleased(MouseEvent event ) {}
■Beispiel: eigenständige Java-Applikation mit MouseListener-Adapter
public class MoveBalloons extends Applet {
Balloon balloon;
Alle
AlleMethoden
Methodeneiner
einer
Schnittstelle
Schnittstellemüssen
müssen
implementiert
implementiertwerden
werden
(auch
(auchwenn
wennsie
sieleer
leersind)
sind)
public init {
this.addMouseListener(new BalloonMover ());
Balloon balloon = new Balloon();
}
class BalloonMover extends MouseAdapter {
innere
innereKlasse
KlasseBalloonMover
BalloonMover
public void mouseClicked(MouseEvent e) {
balloon.setPos(event.getX(), event.getY());
repaint();
....
}
}
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
45 von 50
… Adapter als innere Anonyme Klasse
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
46 von 50
Adapterklassen im JDK
■In Java sind sogenannte Adapterklassen für die meisten EventListener
Interfaces vordefiniert:
class MoveBalloons extends Applet
Balloon balloon;
Adapterklassen sind abstrakte Klassen, die das entsprechende Interface
implementieren
public init {
Balloon balloon = new Balloon();
this.addMouseListener(new MouseAdapter (){
public void mouseClicked(MouseEvent e) {
■Vorteil: Falls man nur eine Methode braucht, erweitert man einfacher die
Adapterklasse, anstatt das ganze Interface zu implementieren
balloon.setPos(event.getX(), event.getY());
repaint();
}
});
■Beispiel: MouseListener Interface schreibt vor, dass die 5 Methoden
mouseClicked, mouseEntered, mouseExited, mousePressed,
mouseReleased implementiert werden müssen
}
...
}
Æ Auch wenn man z.B. nur mouseClicked braucht, müssen die anderen
trotzdem geschrieben werden
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
47 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
48 von 50
Anhang: Interface-Beispiele aus der JavaKlassenbibliothek
Zusammenfassung
■
Abstrakte Klassen
■Interface-Beispiele aus der Java-Klassenbibliothek
■
Interfaces (Schnittstelle)
■
Mehrfachvererbung mit Interfaces
■Die Java-Klassenbibliothek definiert und implementiert selbst eine ganze Reihe
von Interfaces. Beispiele:
■
Interfaces vs. abstrakte Klassen
■
Innere Klassen
■
Anonyme Klassen
■
Adapterklassen
■Listeners
■
Erlauben, dass Objekte (wie z.B. Button) in einem (von Aufbau und Typ her unbekannten Objekt)
die Listener-Methode (wir zB. actionPerformed) aufrufen können.
■Runnable
■
■
wird zur Implementierung von Threads verwendet, und zwar insbesondere dann, wenn die
betreffende Klasse selbst nicht direkt aus Thread abgeleitet werden kann.
deklariert lediglich die Methode run, deren Rumpf den ausführbaren Code des Threads enthält.
Der Umgang mit Threads wird in einer späteren Lektion erklärt.
■Comparable
■
■
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
49 von 50
Deklariert die Methode compareTo(Object o)
Erlaubt u.a. dass Arrays von Objekten, die Comparable implementieren automatisch sortiert
werden können (mit Arrays.sort)
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
50 von 50