STRUKTURIERTES [height=4ex]img/javalogo PROGRAMMIEREN€¦ · STRUKTURIERTES PROGRAMMIEREN...

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


Objektorientierte Softwareentwicklung

Abgeleitete Klassen

Verdecken & Überschreiben

Abstrakte Methoden und Klassen

Schnittstellen — Kontrakt und Implementierung

Generisches Programmieren & Typparameter

Geschachtelte Klassen & Lambda-Ausdrücke

Zusammenfassung


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


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.


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


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


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


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 ⊕


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();


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


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 ();


Generalisierung/Spezialisierung

Person Fahrzeug

besitzt1 1..*Objektrelationallgemeiner Fall

Anzahlangaben inbeiden Richtungen

AbleitungsbeziehungKlasse undBasisklasse(n)Baum oderzyklenfreier Graph

Gerät

Radio Fernseher


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


A/synchrone Nachrichten

Nachricht senden

HändlerKunde

Lieferung

Bestellung

Rechnung

Methode aufrufen

RadRoboter

besitzt1

1..8

vorwärts()Rad[] r;

ein();

...

vorwärts();



Abgeleitete Klassen






Zusammenfassung


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(...)


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)


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;


Paketgebundener ZugriffStandardsichtbarkeitsbereich default — für alle Klassen des Pakets

package A;

public class One {

}


}

class Three {

}

package B;

import A.One;


}

class Five {

}

default int a; default


Dynastischer ZugriffSichtbarkeitsbereich protected — für alle (in/direkt) abgeleiteten Klassen

package A;

public class One {

}


}

class Three {

}

package B;

import A.One;


}

class Five {

}

protected int a;


Öffentlicher ZugriffSichtbarkeitsbereich public — für alle anderen Klassen

package A;

public class One {

public int a;

}


}

class Three {

}

package B;

import A.One;


}

class Five {

}



Abgeleitete Klassen






Zusammenfassung


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)


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


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“


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)


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〉


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


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’!";

}}



Abgeleitete Klassen






Zusammenfassung


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!!


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


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 ();


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


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().


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.


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



Abgeleitete Klassen






Zusammenfassung


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


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


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";}


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;


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



Abgeleitete Klassen






Zusammenfassung


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


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


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[]


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


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)


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


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 ();


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?!



Abgeleitete Klassen






Zusammenfassung


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


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)


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


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 ("");}

}


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


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



Abgeleitete Klassen






Zusammenfassung


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“


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.

STRUKTURIERTES [height=4ex]img/javalogo PROGRAMMIEREN€¦ · STRUKTURIERTES PROGRAMMIEREN...

Documents

Transcript of STRUKTURIERTES [height=4ex]img/javalogo PROGRAMMIEREN€¦ · STRUKTURIERTES PROGRAMMIEREN...