Programmierkurs Java WS 98/99 Vorlesung 11 Dietrich Boles 20/01/99Seite 1 Programmierkurs Java...

Programmierkurs Java WS 98/99 Vorlesung 11 Dietrich Boles 20/01/99 Seite 1

Programmierkurs Java

Vorlesung

im WS 1998/1999

am FB Informatik

der Universität Oldenburg

Vorlesung 11

Dietrich Boles


Gliederung von Vorlesung 11

• Vererbung– Motivation

– Beispiel

– Definitionen

– Implementierung

– Besonderheiten in Java

– Überschreiben von Methoden

– Konstruktoren

– Schlüsselwort super

– Vorteile

– Beispiele

• Polymorphie / Dynamisches Binden– Definitionen

– Beispiele

– Vorteile

• Schlüsselwort final

• Typumwandlung


Vererbung

• Motivation:– gleichartige Objekte Erstellung einer Klasse

– gleichartige Klassen ?

• Beispiele:– Abstrahierung:

n verschiedene Sortierungsalgorithmen (BubbleSort, QuickSort, ...)

– Erweiterung:

Klasse Stack Klasse SwapStack (Vertauschen der obersten Elemente)

– Spezialisierung:

Klasse Rechteck Klasse Quadrat

• Idee:– Man nehme eine existierende (Ober-)Klasse OK, leite eine neue (Unter-)Klasse UK

davon ab (d.h. UK erbt/besitzt alle Instanzvariablen und Methoden von OK) und modifiziere die geerbte Implementierung bzw. erweitere das Attribute- und Methodenangebot

– Java: Schlüsselwort extends


Beispiel

public class Stack { int[] store; // zum Speichern von Daten int actual; // aktueller Index

public Stack() { this.store = new int[10]; this.actual = -1; } public boolean isFull() { return this.actual == (this.store.length-1); } public boolean isEmpty() { return this.actual == -1; } public void push(int value) { this.store[++this.actual] = value; } public int pop() { int value = this.store[this.actual]; this.actual--; return value; } }


Beispielpublic class SwapStack extends Stack { // alle Attribute und Methoden von Stack werden geerbt public int pop() { // Modifikation return this.store[this.actual--]; } public void swap() { // Erweiterung if (this.actual >= 1) { int speicher = this.store[this.actual-1]; this.store[this.actual-1]=this.store[this.actual]; this.store[this.actual] = speicher; } } public void main(String[] args) { SwapStack stack = new SwapStack(); stack.push(3); // geerbte Methode stack.push(5); stack.swap(); // neue Methode System.out.println(stack.pop()); // modifiz. Meth.} }


Definitionen

• Erben:– Erben einer Klasse sind Klassen, die deren Spezifikation und Implementierung

übernehmen und sie erweitern oder modifizieren (ohne Code-Duplizierung!)

• Vererbung:– Strukturierungsprinzip bei der Klassendefinition

– Neue Klassen (Unterklassen) können durch Erweiterung bzw. Modifikation bereits existierender Klassen (Oberklassen) definiert werden. Unterklassen erben dabei die Instanzvariablen und Methoden der Oberklassen.

– Die Vererbung führt zur hierarchischen Anordnung von Klassen und kann sich über mehrere Stufen erstrecken (isA-Beziehungen)

• Protokoll einer Klasse:– Beschreibung der Schnittstelle einer Klasse, d.h. i.a. Menge der von außen

zugreifbaren Methoden und Attribute der Klasse

• Ableitung:– Prozeß der Klassenbildung mit Hilfe des Vererbungsprinzips


Definitionen

• Oberklasse:– Eine Klasse, von der eine andere Klasse abgeleitet worden ist

• Unterklasse:– Eine Klasse, die von einer anderen Klasse abgeleitet worden ist

• Klassenhierarchie:– Die mehrfach fortgesetzte Definition von Klassen mit Hilfe des

Vererbungsprinzips führt zur Bildung von Klassenhierarchien

• direkte Oberklasse/Unterklasse:– Klasse, die in einer Klassenhierarchie direkt oberhalb/unterhalb einer bestimmten

Klasse steht (d.h. von der direkt abgeleitet/geerbt wurde)

• Mehrfachvererbung:– Vererbungsbeziehung mit mehreren direkten Oberklassen

A

B

C

D

F G

H K

E

L


Implementierung

public class A { int value; public void print();}

public class B extends A { int value; float number; public void change();}

public class AB { public static void main(String[] args) { A a_obj = new A(); B b_obj = new B();} }

a_obj b_obj

value value (A)value (b)number

print() print();change();


Besonderheiten in Java

• Keine Mehrfachvererbung (d.h. hinter extends kann immer nur ein

Klassenname stehen!)

• es werden immer alle Instanzvariablen und Methoden geerbt (keine Auswahl

möglich)

• Konstruktoren werden nicht vererbt

• Klassenvariablen werden nicht vererbt (dupliziert), sind jedoch in der

Unterklasse zugreifbar (siehe Beispiel auf nächster Folie)

• Jede Klasse wird implizit von einer Klasse Object (aus dem JDK) abgeleitet

(siehe übernächste Folie)


Besonderheiten / Klassenvariablen

public class A { static int wert = 0; public static void incrWert() { A.wert++; } public static int liefereWert() { return A.wert; }}public class B extends A { public static void decrWert() { B.wert--; }}public class AB { public static void main(String[] args) { A.incrWert(); A.incrWert(); B.incrWert(); System.out.println(A.liefereWert()); // 3 System.out.println(B.liefereWert()); // 3 B.decrWert(); System.out.println(A.liefereWert()); // 2 System.out.println(B.liefereWert()); // 2} }


Besonderheiten / Klasse Object

public class Object {

public boolean equals(Object obj); // Wertgleichheit?

public Class getClass(); // liefert Klassenobjekt

public String toString(); // konvertiert in String

protected Object clone(); // byte-Kopie

public int hashCode(); // liefert Hash-Code

...

}

• die Methoden (außer getClass) sollten von jeder neu definierten Klasse überschrieben werden!


Überschreiben von Methoden

• Überladen:– Methoden einer Klasse mit demselben Namen aber unterschiedlichen Parametern

• Überschreiben:– Ersetzung der Implementierung einer Methode einer Oberklasse durch eine neue

Implementierung. Die Methoden müssen identische Signaturen haben!

public class Stack { public boolean isFull() public boolean isEmpty() public void push(int value) public void push(float value) // Überladen public int pop() }

public class SwapStack extends Stack { public void push(char value) // Überladen public void push(int value) // Überschreiben public int pop() // Überschreiben }


Konstruktoren

• Konstruktor: Initialisierung der Attribute eines neu erzeugten Objektes

• bzgl. der Vererbung ist zu beachten:

– wird eine Klasse durch Vererbung definiert, dann muß die Unterklasse

einen Konstruktor definieren, der einen Konstruktor der Oberklasse

aufruft, und zwar mittels des super-Konstrukts als erste Anweisung der

Konstruktorimplementierung

– Ausnahme: die Oberklasse besitzt einen parameterlosen Konstruktor;

dann wird dieser automatisch aufgerufen

– Java liefert einen voreingestellten parameterlosen Konstruktor (jedoch

nur, wenn die Oberklasse einen parameterlosen Konstruktor besitzt)

– durch Verwendung des this-Konstrukts kann der Aufruf des super-

Konstruktors verzögert werden


Konstruktoren

public class A { int value; public A() { this.value = 2; }}public class B extends A { float zahl; // implizite Def. des voreingestellten Konstruktors}public class C extends A { int value; // neue Variable! public C() { super(); // kann auch entfallen this.value = 3;} }

B b_obj = new B();C c_obj = new C();

c_obj value (A)

value (C)

2

3


Konstruktoren

public class A { int value; public A(int v) { this.value = v; } pubic A() { this.value = 4; }}public class B extends A { double value; public B(float v) { super((int)v); this.value = (double)v; } public B(double v) { // impl. Aufruf des parameterlosen Konstruktors this.value = v; } public B(long v) { this((double)v); // Verzögerung} }

B b1 = new B(1.F); B b2 = new B(2.); B b3 = new B(4L);


Schlüsselwort super

• In allen Instanzmethoden einer Klasse verfügbar

• Referenz zum aktuellen Objekt als eine Instanz seiner Oberklasse

• zum Zugriff auf geerbte (überschriebene) Methoden/Attribute

• Nutzung wie thispublic class That { int value = 2; public String name() { return “That“; }}public class More extends That { int value = 4; public String name() { return “More“; } public void printName() { System.out.println(this.name()); // More System.out.println(super.name()); // That System.out.println(this.value); // 4 System.out.println(super.value()); // 2} }


Schlüsselwort super

public class A { int value = 2; public void pA() { System.out.println(value); }}public class B extends A { int value = 3; public void pA() { System.out.println(value); }}public class C extends B { int value = 4; public void pC() { System.out.println(value); } public void test() { this.value = 5; super.value = 6; // ((B)this).value = 6; ((A)this).value = 7;//super.super.value geht nicht! } // Tymumwandlung (siehe spaeter)

C o = new C(); o.test(); o.pA(); o.pB(); o.pC();


Vorteile der Vererbung

• Wiederverwendbarkeit

• keine Quellcode-Duplizierung notwendig

• Fehlerkorrekturen bzw. Änderungen an einer Oberklasse wirken

sich automatisch auch auf alle Unterklassen aus

• Grundlage der Polymorphie


Beispiel 1

public class Hamster { // in speziellem Paket public void vor() {...} public void links_um() {...} public void gib() {...} public void nimm() {...} public boolean vorn_frei() {...} public boolean korn_da() {...} public boolean maul_leer() {...}}public class MyHamster extends Hamster { public void go() { vor(); // Aufruf der geerbten Methode if (korn_da()) nimm(); vor(2); // Aufruf der überladenen Methode } public void vor(int anzahl) { while (vorn_frei() && (anzahl > 0)) { vor(); anzahl--;} } }


Beispiel 2

public class ZaehlenderHamster extends Hamster { int koerner; public ZaehlenderHamster(int koerner) { this.koerner = koerner; } public void gib() { super.gib(); this.koerner--; } public void nimm() { super.nimm(); this.koerner++; } public int koerner_im_maul() { return this.koerner; } public boolean maul_leer() { return this.koerner == 0;} }

ZaehlenderHamster paul = new ZaehlenderHamster(4);if (!paul.maul_leer()) gib(); vor(); ...


Beispiel 3

public class Mitarbeiter { String name; int alter; float gehalt; ... public void print() { System.out.println(this.name); ... }}public class Manager extends Mitarbeiter { Mitarbeiter[] gruppe; int level; ... public void print() { super.print(); System.out.println(this.level); for (int i=0; i<this.gruppe.length; i++) gruppe[i].print();} }

Manager man = new Manager(); ...; man.print();


Polymorphie und Dynamisches Binden

• Polymorphie:– Fähigkeit einer Objektvariablen, auf Objekte unterschiedlicher Klassen

verweisen zu können

– in Java: eingeschränkt auf Objekte von Unterklassen

• Dynamisches Binden:– Zuordnung eines Methodenrumpfes zu einem Methodenaufruf erst zur

Laufzeit

• Einsatzmöglichkeit / Anmerkungen:– Eine Objektvariable vom Typ einer Oberklasse kann auch auf Instanzen

einer Unterklasse verweisen, deren Protokoll dann aber auf das Protokoll der Oberklasse eingeschränkt ist. Beim Aufruf einer Methode für die Variable wird diejenige Methode ausgeführt, die der tatsächlichen Klasse des Objektes zugeordnet ist ( überschriebene Methode)

– Gilt auch während der Ausführung von Konstruktoren(Unterschied zu C++ )

– Klassenmethoden werden nicht dynamisch gebunden


Beispiel 1

public class A { public void print() { System.out.println(“ich bin A“); ... }}public class B extends A { public void print() { System.out.println(“ich bin B“); ... }}public class AB { public static void main(String[] args) { A obj1 = new A(); obj1.print(); // ich bin A B obj2 = new B(); obj2.print(); // ich bin B

A obj3 = new B(); obj3.print(); // ich bin B

B obj1 = new A(); // Fehler!} }


Beispiel 2

public class X { int i = 4; public X() { this.print(); } public void print() { System.out.println(“X“ + i); } public void call() { this.print(); }}public class Y extends X { int j = 7; public Y() { super(); this.print(); } public void print() { super.print(); System.out.println(“Y“ + j); } public static void main(String[] args) { X obj = new X(); // Ausgabe: X4 obj.call(); // Ausgabe: X4 obj = new Y(); // Ausgabe: X4 Y0 X4 Y7 obj.call(); // Ausgabe: X4 Y7} }


Beispiel 3

public class X { public static void print() { System.out.println("in X"); } public void call() { this.print(); }}public class Y extends X { public static void print() { System.out.println("in Y"); } public static void main(String[] args) { Y y = new Y(); y.call(); // Ausgabe: in X} }


Beispiel 4

public class Graphik { public void draw() { System.out.println(“Graphik draw“);} }

public class Rectangle extends Graphik { public void draw() { System.out.println(“Rectangle draw“);} }

public class Square extends Rectangle { public void draw() { System.out.println(“Square draw“);} }

public class Circle extends Graphik { public void draw() { System.out.println(“Rectangle draw“);} }


Beispiel 4

public class GraphikSet { Graphik[] elemente; int next; public GraphikSet(int groesse) { this.elemente = new Graphik[groesse]; this.next = 0; } public void add(Graphik obj) { this.elemente[this.next++] = obj; } public Graphik[] getElements() { return this.elemente;} }public class Programm { public static void main(String[] args) { GraphikSet menge = new GraphikSet(100); menge.add(new Circle()); // Polymorphie! menge.add(new Square()); Graphik[] objekte = menge.getElements(); for (int i=0; i<objekte.length; i++) objekte.draw(); // dynamisches Binden!} }


Beispiel 5

// minimale Klasse:public class Int { // extends Object int value;

public Int(int v) { this.value = v; } public Int(Int obj) { this.value = obj.value; } public boolean equals(Object obj) { return this.value == ((Int)obj).value; } public String toString() { return String.valueOf(this.value); } protected Object clone() { return new Int(this); } ...}


Anmerkung

• Polymorphie bezieht sich ausschließlich auf überschriebene Methoden!• Polymorphie gilt nur für Methoden nicht für Attribute!• Beispiel:

public class X {

public int i;

public void f() { ... }

}

public class Y extends X {

public int i;

public void f() { ... }

}

main:

X obj = new Y();

obj.f(); // Y::f

obj.i = 3; // X::i


Vorteile

• Wiederverwendbarkeit:– folgende Stack-Klasse kann für Objekte beliebiger Klassen genutzt werden

public class Stack Object[] elemens; int actual; public void push(Object elem); public Object pop(); }

• Erweiterbarkeit (ohne Quellcode-Änderung)– Beispiel: TicTacToe-Spiel im Anhang (erweitert durch Klasse TTTProgramm)

– Methode bearbeite einsetzbar auch für später definierte Graphik-Klassen void bearbeite(Graphik obj) { ... Obj.draw(); ... }


Schlüsselwort final

final class A { ... }

von A kann keine weitere Klasse abgeleitet werden

public class B {

public final void f() { ... }

}

in einer Unterklasse von B kann die Methode f nicht überschrieben werden

public class B {

public static final double PI = 3.1415;

}

Definition von Konstanten


Typumwandlung

public class A { ... }public class B extends A { ... }public class C extends A { ... }public class D { ... }

A a = new B();B b = a; // Fehler!B b = (B)a;C c = (C)a; // ok, allerdings beim Zugriff u.U.

// LaufzeitfehlerD d = (D)a; // Fehler

Typumwandlung (Typ-Cast) von Oberklasse auf Unterklasse explizit möglich (allerdings u.U. unsicher!)

A

CB

D

Programmierkurs Java WS 98/99 Vorlesung 11 Dietrich Boles 20/01/99Seite 1 Programmierkurs Java...

Documents

Transcript of Programmierkurs Java WS 98/99 Vorlesung 11 Dietrich Boles 20/01/99Seite 1 Programmierkurs Java...