Vererbung - zhaw radar

INE2
OOP mit Java 3
Abstrakte Klassen und Interfaces
■ Abstrakte Klassen
■ Interfaces (Schnittstelle)
■ Mehrfachvererbung mit Interfaces
■ Interfaces vs. abstrakte Klassen
■ Innere Klassen
■ Anonyme Klassen
■ Adapterklassen
Abstrakte Klassen
School of Engineering
© G. Burkert, K. Rege, ZHAW
2 von 51
Abstrakte Klassen und Methoden
■ Problemstellung
Figure
■ Beispiel:
Klassenhierarchie für verschiedene
geometrische Figuren wie Rechteck,
Kreis, Dreieck
int x,y,w,h
void draw()
getArea()
...
■ Die Klassen für die einzelnen Figuren
sollen alle die gleiche Funktionalität
haben
■ Methoden, die alle Unterklassen haben
müssen, werden in der Oberklasse
deklariert
Æ Polymorphismus ruft die richtige
Methode auf
School of Engineering
Rectangle
Circle
int mx,my
void draw()
void draw()
Mögliche Klassenhierarchie für
Klasse Figur
© G. Burkert, K. Rege, ZHAW
3 von 51
Abstrakte Klassen und Methoden
■ Einige Methode können in der Oberklasse implementiert werden:
setSize(int w, int h)
setPos(int x, int y)
■ Andere Methoden können hingegen nicht sinnvoll implementiert werden:
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?
Æ Abstrakte Methoden und Klassen (abstract class)
public abstract void draw(Graphics g);
public abstract double getArea();
■ Abstrakte Methoden zwingen den Programmierer, eigene Implementationen für
alle abstrakten Methoden zu schreiben
School of Engineering
© G. Burkert, K. Rege, ZHAW
4 von 51
Abstrakte Methoden
■ haben nur einen Methodenkopf (Signatur), keinen Methodenkörper
■ haben den Modifikator abstract im Methodenkopf
■ haben einen Strichpunkt (;) nach der Signatur
■ Folge für die Klasse Figur:
■ Sobald eine Methode der Klasse Figur abstract ist, muss auch die Klasse selbst
als abstract deklariert sein:
public abstract class Figur {
public abstract void draw(Graphics g);
public abstract double getArea();
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
5 von 51
Abstrakte Klassen
■ Eine abstrakte Klasse hat mindestens eine abstrakte Methode und/oder ist als
abstract deklariert
■ Sie kann nicht instanziert werden!
■ Unterklassen von abstrakten Klassen müssen die abstrakten Methoden
implementieren, sonst müssen sie ebenfalls als abstract deklariert sein
Figure
int x,y,w,h
void draw()
getArea()
...
School of Engineering
Figure
oder
<<abstract>>
int x,y,w,h
void draw()
getArea()
...
© G. Burkert, K. Rege, ZHAW
6 von 51
Kontrollfrage
■ Worin unterscheiden sich abstrakte Methoden von Methoden mit leerer
Implementation
public class Figur{
public void draw(Graphics g) {
// leere Methode
}
public double getArea(){
// leere Methode
return 0 // dummy return
}
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
7 von 51
Abstrakte Klassen
■ Beispiel: Klasse Rechteck :
public class Rectangle extends Figur{
public void draw(Graphics g){
g.drawRect(x, y, w, h);
}
public double getArea(){
return (double) w*h;
}
int x,y,w,h
void draw()
getArea()
...
Rectangle
}
Aufgabe: Leiten Sie die Klasse Circle
von der abstrakten Klasse Figur ab
School of Engineering
Figure
© G. Burkert, K. Rege, ZHAW
Circle
int mx,my
void draw()
void draw()
8 von 51
Teil-Abstrakte Klassen
■ Bei einer Klasse kann ein gemeinsame Teil implementiert sein.
public abstract class Figur{
protected int x,y,w,h;
public Figure(int x, int y, int w, int h) {
this.x = x; this.y = y;this.w = w; this.w = w;
}
public void
this.x
}
public void
this.w
}
setPos(int x, int y) {
= x; this.y = y;
setSize(int w, int h) {
= w; this.h = h;
public abstract void draw(Graphics g);
public abstract double getArea();
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
9 von 51
Vorteile von abstrakten Klassen
■ Ein bestimmtes Klassendesign kann erzwungen werden!
■ Sie erlaubt die Klassenbeschreibung in höheren Abstraktionsebenen:
■
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:
■ 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
Klassenhierarchien
School of Engineering
© G. Burkert, K. Rege, ZHAW
10 von 51
Klassifizierung in (abstrakten) Klassen
■ Zusammenfassen von Eigenschaften gleichartiger Klassen 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
PKWs
School of Engineering
Zweiräder
Nutzfahrzeuge
© G. Burkert, K. Rege, ZHAW
11 von 51
Übung
■ Geben Sie je zwei Methoden an, die Sie in der gemeinsamen Oberklasse
Fahrzeuge
■
■
a) als abstrakt deklarieren würden
b) deklarieren und implementieren würden
■ Was wäre eine mögliche Oberklasse von Fahrzeug
School of Engineering
© G. Burkert, K. Rege, ZHAW
12 von 51
Interfaces
School of Engineering
© G. Burkert, K. Rege, ZHAW
13 von 51
Interfaces = reinabstrakten Klassen
Ein Interface definiert eine Schnittstelle zwischen Klassen:
■ Ein Interface ist eine "Klasse", die nur aus Methodenköpfen besteht:
public interface Displayable {
void draw(Graphics g);
}
■ Ein Interface ist im Prinzip eine reinabstrakte Klasse, in welcher sämtliche
Methoden abstrakt deklariert sind Æ Bezeichnung interface anstatt class
School of Engineering
© G. Burkert, K. Rege, ZHAW
14 von 51
Interfaces werden implementiert: implements
■ Klassen erben (extends) nicht von Interfaces sondern implementieren diese
(implements)
■ Sie haben Interfaces schon verwendet:
public interface ActionListener {
public void actionPerformed(ActionEvent event);
}
java.awt.event
public class MyFrame extends Frame implements ActionListener {
public void actionPerformed(ActionEvent event) {
……………………………
}
}
■ sämtliche Methoden eines Interfaces müssen von der Klasse implementiert
werden Æ sonst Klasse abstrakt, d.h. kann nicht instanziert werden
School of Engineering
© G. Burkert, K. Rege, ZHAW
15 von 51
Merkmale eines Interfaces
■ 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
■ Interfaces definieren wie Klassen einen neuen Datentyp
Æ Es können Variablen dieses Datentyps deklariert werden:
Displayable dsp;
Ein Interface beschreibt nur die Schnittstelle (Klasse, Methoden,
Parameter) einer Klasse, nicht deren Implementierung
School of Engineering
© G. Burkert, K. Rege, ZHAW
16 von 51
…Merkmale eines Interfaces
■ Methoden dürfen nicht static sein
■ Hingegen müssen alle Variablen eines Interfaces static final
(d.h. Konstanten) sein
■ Interfaces können übersetzt, aber nicht instanziert werden
■ Das Compilieren erlaubt Typenprüfung bei der Verwendung eines Interfaces
if (obj instanceof Displayable) {...
■ Interface Typen können in der Parameterliste von Methoden stehen
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
© G. Burkert, K. Rege, ZHAW
17 von 51
…Merkmale eines Interfaces
■ Interfaces können wie Klassen an Unter-Interfaces weitervererbt werden
extends wird in diesem Fall ebenfalls verwendet
public interface Verkehrsmittel {
}
public interface Fahrzeug extends Verkehrsmittel {
}
■ es können mehrere Interfaces von einer Klasse implementiert werden
class MyFrame extends Frame
implements ActionListener, MouseListener {
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
18 von 51
Deklaration von Interfaces
■ Ein Interface beschreibt die Methoden die alle Klassen mindestens
implementieren.
■ Für Figuren könnten das z.B.
public interface Displayable {
void draw(Graphics g);
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
19 von 51
Graphische Darstellung von Interfaces
■ Im Klassenbaum werden Interfaces
gekennzeichnet
Displayable <<interface>>
void draw()
■ Das "implementiert" Symbol ist etwas
schlanker als das "erbt" Symbol
implementiert
implementiert
Figure
<<abstract>>
int x,y,w,h
void draw()
getArea()
...
implementieren
implementieren
ebenfalls
ebenfallsDisplayable
Displayable
(weil von Figure erben)
(weil von Figure erben)
Rectangle
int mx,my
void draw()
School of Engineering
Circle
© G. Burkert, K. Rege, ZHAW
void draw()
20 von 51
Implementieren von Interfaces
■ Ein Interface wird durch eine Klasse implementiert.
■ Deklaration einer Klasse, die ein Interface implementiert:
class MeineKlasse implements Interfacename {...}
■ Die Klasse muss alle Methoden des Interfaces implementieren Æ implements
verpflichtet dazu !
Æ wird vom Compiler überprüft!
■ Klassen, die ein Unter-Interface implementieren, müssen auch alle Methoden
der Ober-Interfaces implementieren
■ Eine Klasse kann gleichzeitig mehrere Interfaces implementieren:
class MeineKlasse implements Interface1, Interface2,... {...}
School of Engineering
© G. Burkert, K. Rege, ZHAW
21 von 51
Verwendung von Interfaces
■ Interfaces stellen sicher, dass eine Klasse gewisse Eigenschaften hat bzw.
bestimmte Methoden zur Verfügung stellt (implementiert hat)..
■ Es können Variablen von einem Interface Typ erstellt werden
Displayable dsp = new Rectange(…);
■ Alle im Interface definierten Methoden müssen von Rectangle implementiert
werden Æ können deshalb "sicher" aufgerufen werden.
dsp.draw(g);
■ Rectangle kann noch zusätzliche (nicht im Interface deklarierte) Methoden
implementieren z.B. getArea(…)
■ Frage: wie kann ich diese aufrufen?
School of Engineering
© G. Burkert, K. Rege, ZHAW
22 von 51
Sichtbarkeit von Methoden
Regel: Der statische Typ (Typ von dem die Variable deklariert wurde) bestimmt,
welche Methoden und Attribute bekannt sind.
■ Displayable dsp = new Rectange(…);
■ dsp.getArea();
gilt
giltauch
auchfür
für
abstrakte
abstrakteund
und
reguläre
Klassen
reguläre Klassen
■ Lösung
■
■
■
■
■
zuerst in Variable mit richtigem statischen Typ zuweisen
Rectange rect = (Rectange)dsp;
double d = rect.getArea();
oder Cast und Aufruf kombiniert
double d = ((Rectangle)dsp).getArea();
■ Kontrollfrage: funktioniert das auch wenn ich zu Figure caste
School of Engineering
© G. Burkert, K. Rege, ZHAW
23 von 51
Interfaces: …Beispiel
implements
implementsDisplayable
Displayable
import java.awt.*;
class Rechteck extends Figure {
public void draw(Graphics g){
g.drawRect(xPos, yPos, breite, hoehe);
}
public double getArea(){
return (double) breite*hoehe;
}
...
Rechteck (int x, int y, int w, int h) {
super(x, y, w, h);
}
wegen
wegenDisplayable
Displayable
Implementierung der
Implementierung der
abstrakten
abstraktenMethoden
Methodender
der
Klasse Figure
Klasse Figure
Konstruktor
Konstruktor
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
24 von 51
Interfaces: …Beispiel
public class FigurTest extends Frame {
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
Kenntdie
dieMethoden
Methodendraw
draw
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);
}
}
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
25 von 51
Vorteil von Interfaces
■ 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
<<abstract>>
Fahrzeug
Figure
<<abstract>>
int x,y,w,h
int getAchsen()
...
School of Engineering
© G. Burkert, K. Rege, ZHAW
void draw()
getArea()
...
26 von 51
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
public interface Marker { }
School of Engineering
© G. Burkert, K. Rege, ZHAW
27 von 51
Mehrfachvererbung von Interfaces
School of Engineering
© G. Burkert, K. Rege, ZHAW
28 von 51
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
Wasserflugzeug
schwimmen
fliegen
links
rechts
School of Engineering
© G. Burkert, K. Rege, ZHAW
29 von 51
Probleme der Mehrfachvererbung von Klassen
1) Aufruf von super nicht mehr
eindeutig, z.B.
super.links();
■
2)
3) Mehrfach geteilte Oberklassen:
Diamant Struktur
■
mögliche Lösung: Spezifikation welche
Oberklasse gemeint
(Motorschiff)super.links();
Verkehrsmittel
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?)
Schiff
Flugzeug
Wasserflugzeug
Entscheidung der Java Sprachentwerfer: Mehrfachvererbung
von Klassen in Java nicht unterstützen
School of Engineering
© G. Burkert, K. Rege, ZHAW
30 von 51
Mehrfachvererbung: „Lösung“ mit Interfaces
in der Praxis üblich:
Interface B
Klasse A
Hauptlinie der
Vererbung
Interface C
Seiteneinflüsse
(Verhaltensvorschriften)
Klasse D
Java beschränkt sich auf Einfachvererbung, bietet dafür Interfaces
(Signaturen von Methoden),welche dann „implementiert“ werden müssen.
School of Engineering
© G. Burkert, K. Rege, ZHAW
31 von 51
Lösung mit Interfaces
interface
interface Schwimmen{
Schwimmen{
void
schwimmen();
void schwimmen();
}}
abstract
abstract class
class Verkehrsmittel{
Verkehrsmittel{
void
links();
void links();
void
void rechts();
rechts();
}}
Schwimmen <<interface>>
Schiff
Verkehrsmittel
Flugzeug
interface
interface Fliegen
Fliegen {{
void
void fliegen();
fliegen();
}}
Fliegen
<<interface>>
implementiert
implementiertInterface
Interfaceweil
weil
von
Oberklasse
geerbt
von Oberklasse geerbt
Wasserflugzeug
Mehrfachvererbung
Mehrfachvererbungvon
vonInterfaces
InterfacesininJava
Javaunterstützt
unterstützt
class Wasserflugzeug extends Flugzeug implements Schwimmen {
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
32 von 51
Mehrfachvererbung von Interfaces im GUI
■ Java erlaubt nur einfache Vererbung! Æ Verwechslungs-Problematik von
Methoden bei Mehrfachvererbung wird vermieden
■ Mehrfachvererbung ist aber nachbildbar mit Interfaces,
da eine Klasse mehrere Interfaces implementieren kann
■ Beispiel:
Das Frame MeinSpiel ist abgeleitet von der
Klasse Frame (Vererbung). Zusätzlich
soll es die Interfaces ActionListener
und MouseListener implementieren:
public class MeinSpiel extends Frame
implements ActionListener, MouseListener{
...
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
33 von 51
Vorteile von Interface-Mehrfachvererbung
■ Eine Klasse, die ein Interface implementiert „erbt“ nur die Pflicht die InterfaceMethoden selber zu Programmieren
■ Im Gegensatz zur (mehrfach) Klassenvererbung keine Einsparung der
Programmierarbeit!
■ 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
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
© G. Burkert, K. Rege, ZHAW
34 von 51
Klassenbibliothek Beispiel: ActionListener
MyFrame Implements ActionListener
ActionListener
<<interface>>
actionPerformed(..)
……
Beliebige
BeliebigeKlasse
KlasseXY
XY
Implements
ImplementsActionListener
ActionListener
Button B = new Button();
B.addActionListener(this);
void actionPerformed(…)
…….
Button
ButtonBBbekommt
bekommtbeim
beim
„AddActionListener(this)“
„AddActionListener(this)“die
dieReferenz
Referenz
auf
aufein
einbeliebiges
beliebigesObjekt
Objekt(MyFrame).
(MyFrame).
Button
ActionListener listener:
// Anmeldung von Listener
addActionListener (ActionListener l)
listener = l;
//Eventbehandlung B (Component)
listener.actionPerformed(e);
Es
Eskann
kanndort
dortaber
aber(unabhängig
(unabhängigvon
vonTyp
Typdes
des
Objekts)
Objekts)die
dieMethode
Methode„ActionPerformed“
„ActionPerformed“aufrufen
aufrufen
ÆÆweil
für
die
Referenzierung
(interne
Variable)
weil für die Referenzierung (interne Variable)
der
derInterfaceInterface-und
undnicht
nichtder
derObjekt-Typ
Objekt-Typverwendet
verwendet
wird.
wird.
School of Engineering
© G. Burkert, K. Rege, ZHAW
35 von 51
Interfaces vs. Abstract Classes
■ Interfaces und abstrakte Klassen werden leicht verwechselt. Es bestehen
folgende Unterschiede:
■
■
■
■
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 Unterklasse
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)
School of Engineering
© G. Burkert, K. Rege, ZHAW
36 von 51
Objekt, Klasse, abstrakte Klasse, Interface
■■ Objekt
Objektrepräsentiert
repräsentiert
Gegenstand/Konzept
Gegenstand/KonzeptininSW:
SW:
■
■
■
■
■
■
extends
Zustand
Zustand
Verhalten
Verhalten(Objekt-Methoden)
(Objekt-Methoden)
Identität
Identität
■■ abstrakte
abstrakteKlasse
Klasseist
isthalbfertiger
halbfertiger
Bauplan:
abstact
class
Bauplan: abstact class
■
■
■
■
kann
kannnicht
nichtinstanziiert
instanziiertwerden
werden
mindestens
eine
Methode
mindestens eine Methodeals
alsabstrakt
abstrakt
deklariert
deklariert
new
implements
extends
extends
■■Klasse
Klasseist
istder
derBauplan
Bauplaneines
eines
Objekts:
Objekts:class
class
extends
■■ Interface
Interfaceist
istdie
dieBeschreibung
Beschreibungder
der
Schnittstelle:
Interface
Schnittstelle: Interface
implements
■ 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
■ es kann nur von einer Klasse geerbt
werden:
werden:extends
extends
School of Engineering
© G. Burkert, K. Rege, ZHAW
kann
kannnicht
nichtinstanziiert
instanziiertwerden
werden
Interfaces
werden
von
Klassen
Interfaces werden von Klassen
implementiert:
implementiert:implements
implements
■
es
können
mehrere
■
es können mehrereInterfaces
Interfacesgleichzeitig
gleichzeitig
implementiert
werden
implementiert werden
■
■
■
■
37 von 51
Innerer Klassen
School of Engineering
© G. Burkert, K. Rege, ZHAW
38 von 51
Innere Klassen Beispiel
Innere Klassen: Beispiel1: ActionListener
import java.Frame.Frame;
import java.awt.*;
import java.awt.event.*;
public class InnerDemo extends JFrame {
Button helloButton = new Button("Hello");
TextField textfeld = new TextField("
");
Der
DerRückgabewert
Rückgabewertvon
von
new()
new()wird
wirddirekt
direktals
als
Referenz
Referenzauf
aufdas
das
Listener-Objekt
Listener-Objekt
verwendet
verwendet
public void init() {
add(helloButton);
add(textfeld);
helloButton.addActionListener(new Bearbeiter());
}
public void paint(Graphics g) {
innere Klasse Bearbeiter
}
innere Klasse Bearbeiter
class Bearbeiter implements ActionListener {
public void actionPerformed(ActionEvent e){
textfeld.setText("Hallo Welt");
}
}
Bearbeiter hat Zugriff auf die
}
School of Engineering
Bearbeiter hat Zugriff auf die
Variablen
Variablender
derumgebenden
umgebendenKlasse
Klasse
© G. Burkert, K. Rege, ZHAW
39 von 51
Innere Klassen
■ Innere Klassen werden innerhalb einer Klasse definiert:
class Außen {
….
class Innen {
}
}
■ Sie sind für alle anderen Klassen nicht sichtbar.
Æ keine Probleme mit Namenskonflikten
■ 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
School of Engineering
© G. Burkert, K. Rege, ZHAW
40 von 51
Anonyme Klassen
School of Engineering
© G. Burkert, K. Rege, ZHAW
41 von 51
Anonyme (innere) Klasse als ActionListener
import java.Frame.Frame;
import java.awt.*;
import java.awt.event.*;
public class AnonymDemo extends Frame {
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) {
}
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
42 von 51
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
■ 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
© G. Burkert, K. Rege, ZHAW
43 von 51
Adapter Klassen
School of Engineering
© G. Burkert, K. Rege, ZHAW
44 von 51
Adapter-Klassen
import java.awt.event.*;
class MoveBalloons extends Frame 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 ) {}
Alle
AlleMethoden
Methodeneiner
einer
Schnittstelle
Schnittstellemüssen
müssen
implementiert
implementiertwerden
werden
(auch
(auchwenn
wennsie
sieleer
leersind)
sind)
....
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
45 von 51
… Adapter-Klassen
■ 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
■ Beispiel: eigenständige Java-Applikation mit MouseListener-Adapter
public class MoveBalloons extends Frame {
Balloon balloon;
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
© G. Burkert, K. Rege, ZHAW
46 von 51
… Adapter als innere Anonyme Klasse
class MoveBalloons extends Frame
Balloon balloon;
public init {
Balloon balloon = new Balloon();
this.addMouseListener(new MouseAdapter (){
public void mouseClicked(MouseEvent e) {
balloon.setPos(event.getX(), event.getY());
repaint();
}
});
}
...
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
47 von 51
Adapterklassen im JDK
■ In Java sind sogenannte Adapterklassen für die meisten EventListener
Interfaces vordefiniert:
Adapterklassen sind abstrakte Klassen, die das entsprechende Interface
implementieren
■ Vorteil: Falls man nur eine Methode braucht, erweitert man einfacher die
Adapterklasse, anstatt das ganze Interface zu implementieren
■ 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
© G. Burkert, K. Rege, ZHAW
48 von 51
Zusammenfassung
■ Abstrakte Klassen
■ Interfaces (Schnittstelle)
■ Mehrfachvererbung mit Interfaces
■ Interfaces vs. abstrakte Klassen
■ Innere Klassen
■ Anonyme Klassen
■ Adapterklassen
School of Engineering
© G. Burkert, K. Rege, ZHAW
49 von 51
Noch Fragen?
Gemälde und sein Modell
School of Engineering
© G. Burkert, K. Rege, ZHAW
50 von 51
Anhang: Interface-Beispiele aus der JavaKlassenbibliothek
■ Interface-Beispiele aus der Java-Klassenbibliothek
■ Die Java-Klassenbibliothek definiert und implementiert selbst eine ganze Reihe
von Interfaces. Beispiele:
■ 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
■
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
© G. Burkert, K. Rege, ZHAW
51 von 51