View
12
Download
0
Category
Preview:
Citation preview
STRUKTURIERTES PROGRAMMIEREN
Vorlesung im Wintersemester 2019
Prof. E.G. Schukat-Talamazzini
Stand: 26. August 2019
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Teil VIII
Objektorientiertes Programmieren inJava
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Objektorientierte Softwareentwicklung
Abgeleitete Klassen
Verdecken & Überschreiben
Abstrakte Methoden und Klassen
Schnittstellen — Kontrakt und Implementierung
Generisches Programmieren & Typparameter
Geschachtelte Klassen & Lambda-Ausdrücke
Zusammenfassung
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Objektorientierte SoftwareentwicklungAufgabenstellung 1:1 Programmstruktur
Funktionale Zerlegung
• SpezifikationE/A-Verhalten
• Hierarch. ZerlegungModularisierung:U-ProgrammRekursion
• KodierungAusprogrammieren derelementaren Funktionen
Objektorientierter Ansatz
• OO-Analyse RealweltObjekteObjektbeziehungen
• OO-Entwurf PrinzipSoftware-ArchitekturUnified Modeling Language
• OO-Programmierung DetailDatenstrukturenAlgorithmen
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Systeme und Objekte
Objektorientiertes Systemmodelliert Ausschnitt der
{gedachtenrealen
}Welt
• zahlreiche Teilsysteme
• kommunizierende Komponenten
• elementare Komponenten: Objekte
Objektverhaltenaktiv:erteilt Aufträge anandere Teilsystemepassiv:bietet Dienste an zurAnforderung vonaußen
Nachricht
Auftraggeber Empfänger
NachrichtGerichteteKommunikation einesObjekts mit einemanderen, bei dem einAuftrag erteilt wird.
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Nachricht und Kommunikation
Asynchrone Kommunikation{AbsendenEmpfangen
}ist entkoppelt
räumlich getrennte Systeme
Nachrichtenformat
StandardbriefEmpfängerAuftrag
Synchrone KommunikationAuftraggeber („client“)wartet auf Erledigung durchDienstleister („server“)
Nachrichtenformat
MethodenaufrufEmpfängerMethodennameArgumente
(gekoppeltes Nachrichtenpaar)
QuittungRückmeldung des Empfängers durch Antwortnachricht
• Ergebnisauslieferung · Fertigmeldung · Fehleranzeige
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Vom Objekt zur Klasse
AbstraktionKonzentration auf ausgewählte MerkmaleVernachlässigen aller anderen Eigenschaften
TypÄquivalenzklasse bezüglich der ObjektabstraktionUnterschiedl. Fokus unterschiedl. Typsysteme
KlasseKonkrete prog.tech. Ausgestaltung eines Typs(1 : n)-Beziehung zwischen Typ und Klasse
FokusAnzahl d. Beine
Äquivalent8 Spinnen6 Käfer4 Säugetiere3 Barhocker2 Primaten1 Pilze...
...64 Intelchips
FaktTypen/Klassen sind Objektmengen.
• Spezialisierung/Verallgemeinerung Spinnen ⊆ Insekten
• Einschluß/Teil-Ganzes Räder ∈ Automobile
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Spezialisierung und Dependenz
Generalisierung—Spezialisierungmengentheoretische Halbordnung
Untertyp ⊆ Obertyp
Untertyp hat alle Eigenschaften des Obertyps
Menge
Reihung Liste
lineare Liste
2x verkettet1x verkettet
Baum
Verallgemeinerungshierarchie• Baum eindeutiger Basistyp
• Graph Mehrfachvererbung
Mensch
SportlerGeschäftsmann Student
Rennfahrer Sportstudent BioinformatikerKaufmann
Bäcker Weinhändler
Teil—Ganzes (Einschluß, Enthaltensein)Komposition ist mehr als Mengenbildung!„Schiffskonvoi“ ← (Flottenverbrauch, Kampfkraft)
SchiffskonvoiSchiff1Schiff2· · · · · · · · ·SchiffN
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Ableitung und VererbungProgrammtechnische Realisierung
• EinschlußBestandteile eines Objekts werden als Attribute realisiert
• SpezialisierungObjekte der Unterklasse besitzen alle Eigenschaften der Oberklasse
Ableitung: Basisklasse Unterklasse
1 ERBENAttribute und Methoden von „oben“
2 ERWEITERNDeklaration zusätzlicher Merkmale
3 VERÄNDERNVerdecken von MerkmalenÜberschreiben virtueller Methoden
VerdeckenGleichnamiges Merkmalwird ungültig, aberüberlebt.
Überschreibengleicher Namegleiche Signaturneuer Code
Virtuell =̂ LuxusJava: final C++: virtual ⊕
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Bindung und Polymorphie
Polymorphie
• Eine Referenzvariable kann aufObjekte aller Untertypen verweisen.
• Ein Objekt kann durch Variablen allerObertypen referenziert werden.
Statischer Typ Übersetzungszeit
Wie ist Variable x deklariert?
Dynamischer Typ Laufzeit
Wer erzeugte das Objekt „in“ x?
InstanzmethodenMethodenaufruf x.fun(...) wird stetsdurch dynamische Bindung aufgelöst
Object
...
Tafelobst String
Banane Apfel Melone
Boskop CoxOrange
Methodenaufruf„virtual method table“
Apfel x;x = new CoxOrange();x.abwaschen();
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Abstrakte KlassenWarum man Obst pflücken & essen, aber nicht pflanzen & kaufen kann
Tafelobst essenGut zu wissen, daß jedes Objekt eine Verzehrmethode besitzt!
Apfelvoid essen(){
abwischen();abbeißen();
}
Bananevoid essen(){
schälen();abbeißen();
}
Melonevoid essen(){
zerlegen();plusParma();
}
Tafelobstabstract void
essen(){}
Es gibt Äpfel, Bananen, Melonen — aber keine „Obsten“!
Abstrakte Klassenkeine Instanzenkeine Konstruktoren
• Attribute,Methoden,Funktionsprototypen
Abstrakte Methodenvererbt eine Signaturkein Code im Rumpf
• garantiert aber eine„Implementierung“ in denkonkreten Unterklassen
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
UML — Unified Modelling LanguageBooch, Rumbaugh, Jacobson (1999)
Statisches ModellStruktur des Systemaufbaus• Verallgemeinerung · Teil/Ganzes
Funktionales ModellZusammenwirken der Teilsysteme• Nachrichten · Methoden
Dynamisches ModellLogische & zeitliche Kooperation• Endliche Automaten Zustände
• Petri-Netze Resourcenkonflikte
Klassenbeschreibung
MotorEinAus z;Seriennummer s;Vorwärtslauf v;Rückwärtslauf r;Drehzahl d;ein ();aus ();vorwärts ();rückwärts ();getDrehzahl ();setDrehzahl ();
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Generalisierung/Spezialisierung
Person Fahrzeug
besitzt1 1..*Objektrelationallgemeiner Fall
Anzahlangaben inbeiden Richtungen
AbleitungsbeziehungKlasse undBasisklasse(n)Baum oderzyklenfreier Graph
Gerät
Radio Fernseher
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Teil/Ganzes-Relation
Einschluß als AggregationZusammensetzung aus Teilobjekten:
hat1 1...* 1
3..4
Person Auto Rad
besitzt
Einschluß als KompositionTeilobjekte vom Aggregat existenzabhängig
Position
1..*hat1
Rechnung
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
A/synchrone Nachrichten
Nachricht senden
HändlerKunde
Lieferung
Bestellung
Rechnung
Methode aufrufen
RadRoboter
besitzt1
1..8
vorwärts()Rad[] r;
ein();
...
vorwärts();
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Objektorientierte Softwareentwicklung
Abgeleitete Klassen
Verdecken & Überschreiben
Abstrakte Methoden und Klassen
Schnittstellen — Kontrakt und Implementierung
Generisches Programmieren & Typparameter
Geschachtelte Klassen & Lambda-Ausdrücke
Zusammenfassung
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Ableitung in Java
Einfachvererbung — AbleitungsbaumJede in Java deklarierte Klasse — außer Object — besitzt eineeindeutig festgelegte Basisklasse.
Syntax einer Klassendeklaration
class Kabl extends Kbase { S }
class Kabl extends Object { S }
Klasse Kabl wird deklariert; Basisklasse Kbase muß bereits existieren.
• Die Erweiterungsklausel (Schlüsselwort extends) kann auch fehlen.
• Variablen & Methoden werden von der Basisklasse Kbase geerbt.
• Konstruktoren werden nicht vererbt! super(...)
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Beispiel — Vererbung und ErweiterungBasisklasseclass Point {
int x, y; // x/y-Koordinatenstatic final int X=1024, Y=768 // Nokia-TFT
Point (int xk, int yk) { x = xk; y = yk; }Point () { this (X/2, Y/2); }void moveAbs (int xk, int yk) { x = xk; y = yk; }void moveRel (int xk, int yk) { x += xk; y += yk; }
}
Abgeleitete Klasseclass Square extends Point {
int a; // SeitenlängeSquare (int xk, int yk, int a) {
super (xk, yk); // Point-Konstruktorthis.a = a; // lokale/Objekt-V.
}Square (int a) { this.a = a; }int area () { return a*a; }void resize (int a) { this.a = a; }
}
KonstruktorenI. explizitII. Bildmitte
ErbstückeKlassenvariableX,YInstanzvariablex,yVerschiebemetoden(abs/rel)
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Gekapselter ZugriffSichtbarkeitsbereich private — ausschließlich innerhalb der aktuellen Klasse
package A;
public class One {
}
class Two extends One {
}
class Three {
}
package B;
import A.One;
class Four extends One {
}
class Five {
}
private int a;
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Paketgebundener ZugriffStandardsichtbarkeitsbereich default — für alle Klassen des Pakets
package A;
public class One {
}
class Two extends One {
}
class Three {
}
package B;
import A.One;
class Four extends One {
}
class Five {
}
default int a; default
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Dynastischer ZugriffSichtbarkeitsbereich protected — für alle (in/direkt) abgeleiteten Klassen
package A;
public class One {
}
class Two extends One {
}
class Three {
}
package B;
import A.One;
class Four extends One {
}
class Five {
}
protected int a;
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Öffentlicher ZugriffSichtbarkeitsbereich public — für alle anderen Klassen
package A;
public class One {
public int a;
}
class Two extends One {
}
class Three {
}
package B;
import A.One;
class Four extends One {
}
class Five {
}
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Objektorientierte Softwareentwicklung
Abgeleitete Klassen
Verdecken & Überschreiben
Abstrakte Methoden und Klassen
Schnittstellen — Kontrakt und Implementierung
Generisches Programmieren & Typparameter
Geschachtelte Klassen & Lambda-Ausdrücke
Zusammenfassung
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Verändern der Basisklassemerkmale
Überdeklarierengleicher Name (Attribut)gleiche Signatur (Methode)Nicht verwechseln mit Überladen !
VerdeckenBasisklassemerkmal wird ungültigUnterklassemerkmal wird gültigBasisklassemerkmal bleibt lebendig(... und abrufbar/veränderbar)
ÜberschreibenBasisklassemerkmal wird von derUnterklasse aus unzugänglich
DEKLARATION gleichen Namens
MERKMAL überdeklarieren
KONSTRUKTOR (unmöglich)
ATTRIBUT verdecken
METHODE
INSTANZ-M.KLASSEN-M.
verdecken
VIRTUELL überschreiben
FINAL (verboten)
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Redeklaration von AttributenKlassen/Instanz - Variablen/Konstanten
Überdeklarieren =̂ VerdeckenAttributname erhält neue Bindung
änderbar:
Datentyp
Klasse/InstanzKonstante/VariableSichtbarkeitsbereich
Attributzugriffdurch statische Bindung(Übersetzer)Referenztyp NamensraumObjekttyp Attributwert
Ganzzahlkoordinaten → Gleitkommankoordinatenclass RealPoint extends Point { // Gleitkommageometrie
float x, y; // reelle Kordinaten... ... ...
}
RealPoint rp = new RealPoint (); // RealPoint-Objektfloat rx = rp.x; // gültig: reelle x/yPoint p = rp; // Typaufweitungint ix = p.x; // lebendig: ganzzahlige x/y
Point
↓RealPoint
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Selektion verdeckter Attribute
Wie adressieren wir verdeckte Basisklassemerkmale?Nach der Deklaration
Kabl obj = new Kabl(...);
bezeichnet Ausdruck obj.var das Klasse-Kabl-Merkmaldes Objekts.
Kbase
↓Kabl
Syntaxschema zur Selektion
in Kabl-Methodenrümpfen außerhalb Unterklasse Kabl
Klassenvariable super.var Kbase.varKbase.var „explizite Qualifikation“
Instanzvariable super.var ((Kbase) obj).var((Kbase) this).var „explizite Aufweitung“
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Redeklaration von MethodenGleicher Name · gleiche Parameterzahl · gleiche Parametertypen
Klassenmethoden Verdeckungstatic-Methoden der Basisklasse dürfen durch eine static-Methodeder abgeleiteten Klasse überlagert werden. statische Bindung
Instanzmethoden ÜberschreibungMethode der Basisklasse darf durch eine Instanzmethode der abgeleitetenKlasse überlagert werden.
• Objekttyp {AttributwertNamensraum
}dynamische Bindung
Welche Methodeneigenschaften sind änderbar?Klasse/InstanzRückgabetypSichtbarkeitfinal/virtuell
nein (!)Typ abwärts (Untertyp)Scope aufwärts (weiter)
virtuell beliebig (final=endgültig)
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Instanzmethodenselektion„Ist das Obst ein Apfel oder ist es eine Birne?“
〈Algorithmus〉
1 ÜBERSETZUNGSZEITWelches ist der deklarierte Typ Ko von obj ?
2 ÜBERSETZUNGSZEITGibt es eine Methode Ko.fun() passender Signatur ?
3 LAUFZEITWelchen Typ Ku hat das obj-Datenobjekt ?
4 VIRTUELLE METHODENTABELLEAusführen des Ku.fun()-Rumpfcodes
〈Algorithmus〉
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Beispiel — statisches/dynamisches Bindenbeim Aufruf von Klassenmethoden und Instanzmethoden
Ableitung mit Veränderung von Methodenclass Rectangle {
int x, y, width, height;void draw () { ... }void move (int i, int j) { ... }static int xmax () { ... }
}class ColoredRectangle extends Rectangle {
Color color;void draw () { ... }void setColor (Color c) { color = c; }static int xmax () { ... }
}
Rectangle
↓
ColoredRectangle
ColoredRectangle cr = new ColoredRectangle ();cr.draw (); // ruft ColoredRectangle.drawRectangle r = cr;r.draw (); // ruft ColoredRectangle.drawfinal int XUB = r.xmax (); // ruft Rectangle.xmax
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Kovarianter RückgabetypÜberschreiben von Instanzmethoden — identische Signatur & Rückgabe =̂ Untertyp
Rückgabewertim Methodenrumpf:
Number area () {...; return 47.11;}
Object
Number
Double
Rückgabetypnach Überdeklarieren:
Double area () {...}
Beispielprogrammclass Covariant {
public static void main (String[] args) {Covariant cov = new Covariant();System.out.println (cov.sayhello());System.out.println (cov.saybyebye());cov = new Subversive();System.out.println (cov.sayhello());System.out.println (cov.saybyebye());
}String sayhello () {
return "Covariant says ’hello’!";}Object saybyebye () {
return "Covariant says ’bye-bye’!";}
}class Subversive extends Covariant {
String saybyebye () {return "Subversive says ’bye-bye’!";
}}
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Objektorientierte Softwareentwicklung
Abgeleitete Klassen
Verdecken & Überschreiben
Abstrakte Methoden und Klassen
Schnittstellen — Kontrakt und Implementierung
Generisches Programmieren & Typparameter
Geschachtelte Klassen & Lambda-Ausdrücke
Zusammenfassung
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Beispiel — Vererben, Überschreiben, Delegieren
Ventil
Stellung s;
toString ();
ein ();
Motor
Drehzahl d;
toString ();
ein ();
Gerät
int serienNummer;
toString ();
setNummer ();
Motivation: das große Indianerehrenwort
Gerät g = new Ventil (); // Objekt=Ventil & Referenz=Gerät
g.setNummer (4711); // Vererbt: ruft Gerät-Methodeg.toString (); // Überschrieben: ruft Ventil-Methodeg.ein (); // Delegiert?? Syntaxfehler!!
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Deklaration von InstanzmethodenEndgültig & abstrakt deklarierte Methoden & Klassen
Virtuelle Methodenüberschreibbar — der Standard in Java
T f (T1 x1, ..., Tn xn) { S }
Endgültige Methodennicht überschreibbar Zwangsvererbung
final T f (T1 x1, ..., Tn xn) { S }
(empfehlenswert wenn vom Konstruktor gerufen!)
Abstrakte Methodenkeine Rumpf keine Implementierung
abstract T f (T1 x1, ..., Tn xn) ;
Finale Klassenfinal classK{...}
keine Ableitung vondieser Klasse erlaubt
Abstrakte Klassenabstract classK{...}
eine oder mehrereMethoden sindabstrakt
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Typanpassung für Referenzvariable
Typaufweitungeines Ausdrucks zu einerOberklasse ist immer erlaubt:
Ko okr = new Ku(...);
Typverengungproduziert ungünstigenfalls eineClassCastException
Ku ukr = (Ku) okr;
Laufzeittypüberprüfungwahrheitswertiger Operator fürVerweis und Typname
if (okr instanceof Ku)Ku ukr = (Ku) okr;
BeispielfragmentEs sollen alle Ventile einesGerätefeldes geöffnet werden:
Gerät[] g = { new Ventil(),new Motor(),new Fallschirm(),..., ..., ...
};for (int i=0; i<g.length; i++)
if (g[i] instanceof Ventil)((Ventil) g[i]).öffne ();
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Beispiel — lineare, homogene ListenKomponententypen fest, aber beliebig
class Link { // allg. VerweiskettenelementLink next; // Nachfolgerverweis
}class TNode extends Link { // spez. Verweiskettenelement
private T data; // der gekapselte Inhaltpublic T getData () // der/die Selektor/in
{ return data; }}
Link lk = new TNode (); //
T dt = lk.data; // ’Link’ hat kein DatenfeldT dt = lk.getData (); // ’Link’ hat keinen Selektor
TNode nd = (TNode) lk; // sichere (s.o.) TypverengungT dt = nd.data; // Tilt! Privatsphäre!T dt = nd.getData (); // Bingo! So soll es sein!
lk = nd.next; // oknd = nd.next; // k.o.nd = (TNode) nd.next; // ok
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Abstrakte Klassen — konkrete Klassen
Syntax der Deklaration
abstract class K extends Kbase {...}
kein Konstruktor · kein Standardkonstruktor
es gibt{zwar Referenzenkeine Instanzen
}vom Typ K
Abstrakte Methoden sind nicht aufrufbar!
Konkrete KlassenAlle ohne abstractdeklarierten Klassen
Syntaxfehler:K besitzt abstrakteMethode.K erbt abstrakteMethode, ohne sie zuüberschreiben.
Beispielabstract class Fahrzeug {
abstract void starte ();}class Fahrrad extends Fahrzeug {
void starte () {steigeAuf ();
}}
Fahrzeug ist abstraktwegen starte().
Fahrrad implementiertdas ererbte starte().
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Der Java-KlassenbaumEinfachvererbung — eindeutige Basisklasse
������������������������������������������������������������
������������������������������������������������������������
abstrakt
final
konstruktorlos
instanzierbar
überschreibbar
Object
Hüllklassen elementarer ZahltypenGemeinsamkeiten in gemeinsamer Basisklasseerfaßt
abstract class Number
class Integerclass Longclass Floatclass Double
Achtung!Es ist Longkein Untertypvon Float usw.
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Wurzelklasse Object
Oberklasse aller KlassenBasisimplementierung nützlicher Standardmethoden
StringkonversionMyClass ref = new MyClass(...);Out.println ("value = "+ ref);
Überschreiben — nicht Überladen!public boolean equals (MyClass x) {...}public boolean equals (Object x) {...}
Objectclone()equals()toString()hashCode()finalize()getClass()notify()notifyAll()wait()... ...
Flache Kopie — tiefe Kopie protected Object clone();
att2att1 att3orig att2att1 att3orig att2att1 att3orig
att2att1 att3copy
flach
att3copy att1 att2
partiell
att2att1 att3copy
tief
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Objektorientierte Softwareentwicklung
Abgeleitete Klassen
Verdecken & Überschreiben
Abstrakte Methoden und Klassen
Schnittstellen — Kontrakt und Implementierung
Generisches Programmieren & Typparameter
Geschachtelte Klassen & Lambda-Ausdrücke
Zusammenfassung
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
SchnittstellenImplementieren von „Interfaces“ oder „Kontrakten“
Mehrfachvererbung — oder doch lieber nicht ?⊕ Kombination unterschiedlicher Klasseneigenschaften Namenskonflikte bei rivalisierenden Attributen und Methoden
Schnittstellenähneln (abstrakten) Klassen, sind aber keine:1. keine Konstruktoren keine Instanzen2. Methoden sind abstrakt kein vererbter Programmcode3. Attribute sind statisch Selektion mit Qualifikation
Mehrfachkontrakte ohne Namenskonflikte
• Ableitung von genau einer Basisklasse• Implementierung von beliebig vielen Schnittstellen
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Syntax für Schnittstellen und Kontrakte
Deklaration einer SchnittstelleMerkmale = konstante „Klassen“attribute & abstrakte Methoden
interface Tinterface { ... ... ... }
Schlüsselwörter static, final und abstract entfallen
Schließen eines KontraktsIm Rumpf der Klassendeklaration
class K extends Kbase implements T1, . . . ,Tn { ... }
sind alle Schnittstellenmethoden zu implementieren (überschreiben).
• Andernfalls gelten sie als ererbte abstrakte Methoden.
Klasse K ist abstrakt
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Beispiele — Schnittstellen und KontrakteVertragswerk für Alleskönnerinterface KannSchwimmen { void schwimmen (); }interface KannLaufen { void laufen (); }interface KannFliegen { void fliegen (); }
class Ente extends Tier implementsKannSchwimmen, KannLaufen, KannFliegen {...}
JedeEnte-Instanz(und darunter)darf xxx()aufrufen.
Traversierungsfähigkeit package java.util;
public interface Enumeration {public boolean hasMoreElements ();public Object nextElement () throws NoSuchElementException;
}
Tiefe Instanzkopiepublic interface
Cloneable {}
Nützliche Konstantenpublic interface GlobalConstants {
int MAX_BLOCKS = 1024;String ERROR_MSG =
"Mehr als " + MAX_BLOCKS + " Blöcke";}
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Referenz und Selektion
Referenzvariable vom SchnittstellentypDeklaration wie Klassenverweise:
Tinterface ref = new Kkonkret ( ... );
Beherbergung von Objekten aller (konkreten) Kontraktklassen
Selektion von SchnittstellenmerkmalenInstanzmethoden durch polymorphen AufrufSchnittstellenattribute (nur) durch explizite Qualifikation
Beispiel MethodenKannFliegen x = new Ente();x.fliegen();x.laufen(); // Syntax!!String str = "tanga";Cloneable c = str;
Beispiel Attributeint mb=GlobalConstants.MAX_BLOCKS;Out.println(GlobalConstants.ERROR_MSG);GlobalConstants z;int blox = z.MAX_BLOCKS;
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Zweck und Syntax von Schnittstellen
Syntax (vor JDK-8)Methoden sind implizitpublic abstract
Attribute sind implizitpublic static final
Keine Konstruktoren
Ableitung neuer Schnittstellenmit extends
Syntax (seit JDK-8)Methoden mit Rumpf:
Klassenmethodenstatic fun (par) {body}(Konflikte: wie Klassenattribut)
Defaultmethodendefault fun (par) {body}(Konflikte: Regeln/Ausnahmen)
Verwendungszweckabstrakte Klasse Teilen gemeinsamen ProgrammcodesSchnittstelle Teilen gemeinsamer Syntaxstruktur, Typabstraktion
Beispiel — Schnittstellen & Konflikteinterface IfaceOne {
int magic=666;static String color () { return "blue"; }default int get () { return magic; }
}interface IfaceTwo {
int magic=42;static String color () { return "gray"; }
// default int get () { return magic; } // conflict with IfaceOne.get()}class ImpClass implements IfaceOne, IfaceTwo {
public static void main (String[] arg) {ImpClass obj = new ImpClass();IfaceOne if1 = obj;IfaceTwo if2 = obj;System.out.println (IfaceOne.magic);System.out.println (IfaceTwo.magic); // ambiguous: ImpClass.magicSystem.out.println (if1.magic);System.out.println (if2.magic); // ambiguous: obj.magicSystem.out.println (IfaceOne.color()); // ambiguous: ImpClass.color()System.out.println (IfaceTwo.color()); // ambiguous: obj.color()System.out.println (if1.get()); // undefined: if2.get()System.out.println (obj.get());
}}
Beispielausgabe6664266642bluegray666666
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Objektorientierte Softwareentwicklung
Abgeleitete Klassen
Verdecken & Überschreiben
Abstrakte Methoden und Klassen
Schnittstellen — Kontrakt und Implementierung
Generisches Programmieren & Typparameter
Geschachtelte Klassen & Lambda-Ausdrücke
Zusammenfassung
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Generisches Programmieren
Wiederverwendung von Programmcodezeitsparend · änderungsfreundlich · robust · ergonomisch• Prozedurparameter Werteabstraktionein Code — viele Argumentwerte Funktionsargumente
• Generische Methode Typabstraktionein Code — viele Argumenttypen Interface · Typparameter
• Generische Klasse Komponentenabstraktionein Behälter — viele Elementtypen Interface · Typparameter
• Funktionen zweiter Ordnung Funktionsabstraktionein Code — viele Grundoperationen Aktionsobjekte · M.Refs
InterfacetechnikJede Instanz (keinElementartyp!) ist in eineObject-Referenz verpackbar.
TypparametrisierungKlassen&Methoden mit formalenParametern für Datentypen;Konkretisierung bei Aufruf
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Beispiel — generische Klassen ohne TypparameterPaket java.util mit Behälterklassen Vector, Stack, List
public class Node {Object data;Node next;
Node (Object d, Node n) { data = d; next = n; }}
GrundideeJedes Datenobjekt läßt sich als Object verpacken.
public class List {private Node head;
public List () { head = null; }private List (Node kn) { head = kn; }public List (Object d, List l) {
head = new Node (d, l.head);}public Object car () { return head.data; }public List cdr () { return new List (head.next); }
}
ElementartypenNumber ⊂ Object
Problematisch„Salatlisten“ verbieten!Rückgabetyp=̂Object
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Beispiel — generische Methoden ohne TypparameterSortieren von Feldern mit totalgeordnetem Komponententyp
interface Comparable { // Kontrakt "totale Ordnung"public int compareTo (Object o); // (this > o) --> +1
} // (this < o) --> -1// (this = o) --> 0
public class SortierAlgorithmus { // Algorithmensammlung... ... ...
public static void quicksort (Comparable[] s) { ... }}
Integer[] seq = new Integer[883];for (int i = 0; i < 883; i++)
seq[i] = new Integer ((i*i)%4711);
SortierAlgorithmus.quicksort (seq);
InterfacetechnikStatt Object nursolche Klassen, die eineVergleichsmethodeimplementieren!
Felder bewahren die Generalisierungs/SpezialisierungsrichtungMonotonie bei der Java-Übersetzung: K1 ⊆ K2 K1[] ⊆ K2[]
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Beispiel — Funktionsabstraktion mit AktionsobjektenTraversierung eines Behälters zur wiederholten Objektmanipulation
public interface MapCarIF {public void action (Node n);
}
public class List {... ... ...public mapcar (MapCarIF fobj) {
for (Node k = head; k != null; k = k.next)fobj.action (k);
}} // TAUSEND JAHRE SPÄTER, AUF EINEM ERDÄHNLICHEN PLANETEN:
public class Druckmaschine implements MapCarIF {public void action (Node k) {
System.out.println (k.data.toString ());}
}List list; ...; list.mapcar (new Druckmaschine());
VorgehensweiseFunktionalität MethodeInstanzmethode ← ObjektObjekt ∈ KlasseKlasse ⊆ Schnittstelle
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Generisches Programmieren mit Typparametern(„Generics“ — seit Java Version 5)
GrundprinzipTypen (Klasse/Schnittstelle) als Parameter für Methoden,Klassen und Schnittstellen (Deklaration/Verwendung)
Syntax: Klasseclass name <T> {...}
Keine Monotonie!T1 ⊆ T2 6 C<T1> ⊆ C<T2>
Syntax: Methodemod <T> TR fun(par){...}Typliste: <T1, . . . ,Tn>beschränkt: <T extends C>Kontrakt: <T extends C&I1&I2>
Verwendung: KlasseDeklaration C<T> var;Konstruktor new C<T>(arg)
Verwendung: MethodeAufruf fun(arg) (Typinferenz)
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Beispiel — generische Klassen mit TypparameterPaket java.util mit Behälterklassen Vector<T>, Stack<T>, List<T>
public class GenList {public static void main (String[] args) {
List l = new List<Integer>();l = new List<Integer>(4,l); l = new List<Integer>(7,l);l = new List<Integer>(1,l); l = new List<Integer>(1,l);
}}class Node<T> {
T data;Node next;Node (T d, Node<T> n) { data = d; next = n; }
}class List<T> {
private Node<T> head;public List () { head = null; }private List (Node<T> kn) { head = kn; }public List (T d, List<T> l) {
head = new Node<T> (d, l.head);}public T car () { return head.data; }public List cdr () { return new List<T> (head.next); }
}
Beispiel — generische Methode mit Typparameterpublic class Maxvalue {
public static void main (String[] args) {Integer[] x = new Integer[] {4,7,1,1};System.out.println (maxvalue(x));System.out.println (maxvalueObj(x));System.out.println (maxvalueTP(x));
}static Integer maxvalue (Integer[] a) {
Integer amax = a[0];for (Integer val : a)
if (val > amax) amax = val;return amax;
}static Comparable maxvalueObj (Comparable[] a) {
Comparable amax = a[0];for (Comparable val : a)
if (val.compareTo(amax) == +1) amax = val;return amax;
}static <T extends Comparable> T maxvalueTP (T[] a) {
T amax = a[0];for (T val : a)
if (val.compareTo(amax) == +1) amax = val;return amax;
}}
1.nicht generischexplizit val > amax
2.generisch ohne TPSchnittstelle für Vergleich
3.generisch mit TPTypparameter beschränkt
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Nützliche Mechanismen von TypparameternWas Sie schon immmer über Typparameter wissen wollten, aber nicht zu fragen wagten
Warum Typparameter?Vorteil: Typprüfung schon zur Übersetzungszeit möglich!
TypinferenzMethodentyp wird aus den Aufrufargumenttypen erschlossen.Konstruktortyp wird aus dem Ausdruckstyp erschlossen.
Diamant: List<Double> x = new LinkedList<> ();
Rückwärtskompatibilität (vor Java-5)Unspezifizierte Verwendung Class einer parametrisierten Klassewird als Class<Object> gedeutet.
Raw types: List x = new LinkedList ();
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Probleme mit TypparameternDas Java-Generizitätskonzept ist eine gutgemeinte Mogelpackung
Synthetische Klassen„Type Erasure“ JVM konnte unverändert bleiben• keine Unterstützung der 8 elementaren Typen Hüllklassen• keine Objekterzeugung für den T -Typ Reflektion• keine Felder mit T -Komponenten Homogenitätsprüfung• keine Klassenattribute vom T -Typ Typkonflikt• kein cast, kein instanceof Typjoker• kein throw, kein catch• Überladen von Methoden? Laufzeitkonflikt• Serialisierung?!
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Objektorientierte Softwareentwicklung
Abgeleitete Klassen
Verdecken & Überschreiben
Abstrakte Methoden und Klassen
Schnittstellen — Kontrakt und Implementierung
Generisches Programmieren & Typparameter
Geschachtelte Klassen & Lambda-Ausdrücke
Zusammenfassung
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Geschachtelte Klassendeklarationen
Klassendeklaration
top-level geschachtelt
STATISCHE Klasse INNERE Klasse
LOKALE Klasse ... ...
ANONYME Klasse ... ...
Funktionsschnittstelle ... ...
Lambda-Ausdruck
SyntaxDeklaration alsKlassenmerkmal(oder schlimmer)
ZugriffskontrolleAlle vierSichtbarkeitsbereiche
ZweckLogische Gruppierung vonHilfsklassen
Unterstützungerst seit Java 5/7/8
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Statische & innere KlassenKlassen ohne/mit Bindung an eine Instanz der Umgebungsklasse
Syntax für Deklaration
class Outer {static class Static { ... }class Inner { ... }
}
Innere Klassen· Zugriff auf Outer-Merkmale· raffinierte Kapselungstechnik· Iteratoren für Behälterklassen
Achtung:· keine Klassenmerkmale· Verdeckungseffekte· Serialisierung risikobehaftet(synthetische Klassenkonstrukte)
Syntax für Konstruktoraufruf
Outer.Static os = new Outer.Static (...);// Konstruktor ohne/mit ObjektbindungOuter out = new Outer (...);Outer.Inner in = out.new Inner (...);
Beispielcode — statische & innere Klassen
class NestedClass {static final int COLOGNE=4711;static final int BERLIN=883;public static void main (String[] args) {
StaticNested sno = new StaticNested();System.out.println ("Hello " + sno.k);OtherClass.sayhello ();NestedClass nco = new NestedClass();Inner inn = nco.new Inner();System.out.println ("Hello " + inn.k);
}static class StaticNested {
int k;StaticNested () { k=COLOGNE; }
}class Inner {
int k;Inner () { k=BERLIN; }
}}class OtherClass {
static void sayhello () {NestedClass.StaticNested sno = new NestedClass.StaticNested();System.out.println ("Hello " + sno.k);
}}
Ausgabe
Hello 4711Hello 4711Hello 883
Syntaxfehlerstatic intBERLIN=1174;(in KlasseInner)
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Lokale & anonyme Klassen und FunktionsschnittstellenSpezialfälle innerer Klassen
Lokale KlasseInnere Klasse, in einem Methodenrumpf deklariertZugriff auf lokale Variablen (falls effektiv final)
Anonyme KlasseLokale Klasse, ohne eigenen KlassennamenKein Konstruktor (außer dem Standardkonstruktor)Zweck: 1× Benutzung zur Instanzerzeugung
Funktionsschnittstelle & FunktionsobjektFS Interface (Schnittstelle) mit genau einer MethodeFO ephemeres Objekt zur Übergabe einer Funktion als Parameter
import java.util.function.*;// enthält STANDARD-FUNKTIONSSCHNITTSTELLEN, z.B.:// interface Predicate<T> { boolean test (T t); }
Beispiel — lokale Klassen und Variablenzugriff
public class InnerClasses {public static void main (String[] args) {
final int X=47;int x=11;class Local {
void sayhello () {System.out.println ("Local Hero " + X+x);
}}new Local().sayhello();
// x++;}
}
Zugriff auf lokale Methodenvariable ist möglich:· Name X bezeichnet eine Konstante· Name x bezeichnet eine effektive Konstante
AusgabeLocalHero 4711
SyntaxMerkmalselektion(via this.*)kannwegfallen
SyntaxfehlerDurch dieZuweisungx++; wirddie effektiveKonstantheitzerstört!
Beispiel — anonyme Klassen und ihre Syntax
public class AnonymousClasses {public static void main (String[] args) {
final int X=47;int x=11;Basetype nn = new Basetype() {
public void sayhello () {System.out.println ("Rumpelstilzchen " + X+x);
}};nn.sayhello();
}}interface Basetype {
void sayhello ();}
Syntax (Konstruktoraufruf!)Schlüsselwort newBasistyp (Klasse oder IF)leere Parameterliste ()Klassendeklaration (nur der Rumpf)
Anonyme Klassen sind „Wegwerfklassen“AK⊆BK deklarieren Instanz erzeugen AK vergessen
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Lambda-Ausdrücke („anonyme Methoden“)Komfortable Syntax zur Instanzerzeugung für Funktionsschnittstellen
Syntax (λ-expression)
lexpr ::= parlst -> block
• Parameterlistewie in MethodendeklarationTypangaben verzichtbarKlammern verzichtbar (unäreOp.)
• Methodenrumpfwie in MethodendeklarationRückgabeausdruck statt Block(falls block ::= {returnexpr ; } )
Standardsyntaxinterface FS { T fun (par) }class FK implements FS {
T fun (par) {body}}
FS fo = new FK();Wer fo besitzt, kann fo.fun() rufen.
Anonyme Klasseinterface FS { T fun (par) }FS fo = new FS() {
T fun (par) {body}};
Lambdaausdruckinterface FS { T fun (par) }FS fo = (par) -> {body}
Beispiel — Funktionsschnittstellen und Lambda-Ausdrücke
interface Prädikat { boolean check (char c); } // Schnittstelle für FOclass CheckUpper implements Prädikat { // Klasse für FO
public boolean check (char c) { return c<’a’; }}import java.util.function.*; // interface Predicate<T> { boolean test (T t); }
public class Lambda {public static void main (String[] arg) {
print1 (arg[0]); // #1. fest eingebautprint2 (arg[0], new CheckUpper()); // #2. FO implementiert ’Prädikat’print2 (arg[0], new Prädikat() { // #3. FO aus anonymer Klasse zu ’Prädikat’
public boolean check (char c) { return c<’a’; }});print3 (arg[0], new Predicate<Character>() { // #4. FO aus anonymer Klasse zu ’Predicate<Character>’
public boolean test (Character c) { return c<’a’; }});print3 (arg[0], c -> c<’a’); // #5. FO via Lambda-Ausdruck
}static void print1 (String s) {
for (char c : s.toCharArray())if (c<’a’) Out.print (c);
Out.println ("");}static void print2 (String s, Prädikat p) {
for (char c : s.toCharArray())if (p.check(c)) Out.print (c);
Out.println ("");}static void print3 (String s, Predicate<Character> p) {
for (char c : s.toCharArray())if (p.test(c)) Out.print (c);
Out.println ("");}
}
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Funktionsobjekte und MethodenreferenzenLambdaausdrücke und ihre vereinfachten Formen
Syntax Methodenreferenz
• KlassenmethodeClass :: statmeth
• gebundene Instanzmethodeobjref :: instmeth
• bindende InstanzmethodeType :: instmeth
• KonstruktorClass :: new
Achtung:Alle 4 Formen erfordern eine geeigneteFunktionsschnittstelle als Kontext!
Lambdaausdruck (allg.)FS fo = (par) -> {body}
AusdrucksmethodenFS fo = (par) -> exprfür Methoden der GestaltT fun(par) { return expr; }
MethodenreferenzenFS fo = methreffür Ausdrucksmethoden mitexpr =̂ meth(par)
Beispiel — Methoden als Objekte oder als Referenzenpublic class LambdaCalc {
interface IntegerMath {int operation(int a, int b);
}public static int binop (int a, int b, IntegerMath op) {
return op.operation(a, b);}public static void main(String... args) {
IntegerMath add = (a, b) -> a + b;IntegerMath sub = (a, b) -> a - b;IntegerMath mul = (a, b) -> a * b;IntegerMath div = (a, b) -> a / b;IntegerMath max = (a, b) -> Math.max (a,b);System.out.println("30+12 = " + binop (30, 12, add));System.out.println("81-39 = " + binop (81, 39, sub));System.out.println("37*18 = " + binop (37, 18, mul));System.out.println("64/16 = " + binop (64, 16, div));System.out.println("max(47,11) = " + binop (47, 11, max));System.out.println("max(47,11) = " + binop (47, 11, Math::max));
} // STATISCHE METHODENREFERENZ}
Beispielausgabe30+12 = 4281-39 = 4237*18 = 66664/16 = 4max(47,11) = 47max(47,11) = 47
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
AufzählungstypenFixe Wertebereiche — moderater Umfang, zur Übersetzungszeit bekannt
Enum-Typ statt „Durchnummerieren“Bereiche: Windrose, Monate, Planeten, Alphabete, MenüpunkteEinsatz: Teilmengentyp, Fallunterscheidung, Laufschleife
Syntax einer Typdeklaration
enumdecl ::= enum enumid { cslist } |enum enumid { cslist ; classdecs+ }
cslist ::= const [ , const ]∗
Implizite Basisklasse java.lang.Enummöglich: Attribute, Methoden, Konstruktorenvordefiniert: static enumid[] values()
FunktionsweiseJe Listeneintrag const· ein enumid-Objekt· eine Klassenkonstantedieses Namens.
Beispielcode — Aufzählungstypenpublic class Enum {
public static void main (String[] args) {Richtung r = Richtung.OST;for (Richtung x : Richtung.values())
System.out.println (x);for (Planet x : Planet.values())
System.out.println (x + "\t" + x.mass + " kg");double rad = Planet.MARS.radius;
}}enum Richtung {NORD,WEST,SÜD,OST} // vanilla usageenum Planet { // looks like a class
MERCURY (3.303e+23, 2.4397e6),VENUS (4.869e+24, 6.0518e6),EARTH (5.976e+24, 6.37814e6),MARS (6.421e+23, 3.3972e6),JUPITER (1.9e+27, 7.1492e7),SATURN (5.688e+26, 6.0268e7),URANUS (8.686e+25, 2.5559e7),NEPTUNE (1.024e+26, 2.4746e7); // separator = semicolonfinal double mass; // in kilogramsfinal double radius; // in metersPlanet(double mass, double radius) {
this.mass = mass;this.radius = radius;
}}
BeispielausgabeNORDWESTSÜDOSTMERCURY 3.303E23 kgVENUS 4.869E24 kgEARTH 5.976E24 kgMARS 6.421E23 kgJUPITER 1.9E27 kgSATURN 5.688E26 kgURANUS 8.686E25 kgNEPTUNE 1.024E26 kg
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Objektorientierte Softwareentwicklung
Abgeleitete Klassen
Verdecken & Überschreiben
Abstrakte Methoden und Klassen
Schnittstellen — Kontrakt und Implementierung
Generisches Programmieren & Typparameter
Geschachtelte Klassen & Lambda-Ausdrücke
Zusammenfassung
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Absschiedsfolie zuSoll das jetzt schon alles gewesen sein zum Thema Java?
Java-Tutorial für FortgeschritteneURL: http://docs.oracle.com/javase/tutorial/index.html (Vorsicht — Produktplatzierung)
Wichtige Programmierkonzepte und Hilfsmittel
Nebenläufigkeit, Echtzeitprogrammierung „threads“
Ein-/Ausgabeströme, Serialisierung „I/O streams“
Behälterklassen Java „Collections“
Grafikausgabe, Datenbankanbindung, XML-HandhabungInternetprogrammierung „Applets“, „web start“, „rich internet“
OO-Software Ableiten Polymorphie Abstrakte Methoden Interface Generics Schachtelung Σ
Zusammenfassung (8)1. Das Typsystem eines objektorientierten Modells ist durch die Relationen
Spezialisierung und Dependenz strukturiert.
2. Die Ableitung einer neuen Klasse beruht auf Vererben, Erweitern undRedeklarieren.
3. In Java herrscht Einfachvererbung; es gibt stets genau eine Basisklasse.
4. Überdeklarierte Merkmale werden verdeckt oder aber (virtuelle Methoden)überschrieben.
5. Referenzen dürfen auf Objekte spezielleren Typs verweisen (Polymorphie).
6. Instanzmethoden werden zur Laufzeit gebunden; es entscheidet derHaldenobjekttyp eines Verweises, nicht ihr deklarierter Typ.
7. Abstrakten Methoden fehlt der Anweisungsrumpf; abstrakte Klassen besitzenkeine Konstruktoren.
8. Im Interface sind alle Methoden abstrakt, alle Attribute klassenbezogen.
9. Eine Klasse kann Kontrakte mit mehreren Schnittstellen schließen, ohneNamenskonflikte zu riskieren wie bei der Mehrfachvererbung.
10. Generische Methoden und Klassen werden mit der Wurzelklasse Objectrealisiert, seit Java-5 auch mit Typparametern.
11. Klassendeklarationen dürfen seit Java-7 auch geschachtelt werden, Funktionenwerden per Lambdaausdrücke als Methodenargumente übergeben.
Recommended