der Universität Oldenburg 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: Beispiele: Idee: 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; } }

Beispiel public 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: Vererbung: Protokoll einer Klasse: Ableitung: 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: Unterklasse: Klassenhierarchie: 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 G F C H K L D E

Implementierung public class A { int value; public void print(); } public class B extends A { 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 2 value (A) 3 value (C)

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 this public 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 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; 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 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 { 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 { 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 { System.out.println(“Rectangle draw“); public class Square extends Rectangle { System.out.println(“Square draw“); public class Circle extends Graphik {

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 { main: X obj = new Y(); obj.f(); // Y::f obj.i = 3; // X::i

Vorteile Wiederverwendbarkeit: public class Stack Object[] elemens; 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 static final double PI = 3.1415; Definition von Konstanten

Typumwandlung A D B C 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. // Laufzeitfehler D d = (D)a; // Fehler Typumwandlung (Typ-Cast) von Oberklasse auf Unterklasse explizit möglich (allerdings u.U. unsicher!) B C