der Universität Oldenburg Programmierkurs Java Vorlesung am FB Informatik der Universität Oldenburg Vorlesung 9 Dietrich Boles

Gliederung von Vorlesung 9 OO-Programmierung Einführung / Motivation OO-Hamstermodell Hamsterobjekte Hamsterklassen Methoden Attribute Konstruktoren Hamsterprogramme Vererbung Polymorphismus Aggregation/Delegation Klassenattribute Zugriffsrechte Exceptions Definitionen Motivationsbeispiel Klassen und Objekte in Java Klassendefinition Objektvariablen Objekterzeugung Objektinitialisierung Objektzerstörung Methodenaufruf Zugriff auf Attribute Beispiele

OO-Programmierung bisher: kleine Probleme  Programmieren im Kleinen nun: größere Probleme  Programmieren im Großen gesucht: natürliche(re) Vorgehensweise zum Lösen bzw. Modellieren von Problemen Mittelpunkt der OO-Programmierung: Objekte Objekte: Gegenstände / Lebewesen / Sachverhalte / ... besitzen Eigenschaften haben Verhaltensweisen Beziehungen zu anderen Objekten Vorteile: einfache Erweiterbarkeit existierender Programme Wiederverwendbarkeit von Programmen Modularisierung / Datenkapselung natürlichere Modellierung von Problemen

OO-Hamstermodell / Hamsterobjekte Motivation: mehrere Hamster void main() { Hamster paul = new Hamster(1, 1, ‘O‘, 12); Hamster willi = new Hamster(9, 3, ‘W‘, 2); while (paul.vornFrei()) { paul.vor(); } while (willi.kornDa()) { willi.nimm(); Objekte: konkrete und abstrakte Dinge des Anwendungsbereichs

OO-Hamstermodell / Hamsterklassen Motivation: Zusammenfassung/Beschreibung von Eigenschaften und Verhalten class Hamster { // Attribute int anzahlKoerner; // Konstruktor Hamster(int x, int y, char blick, int koerner) {...} // Methoden void vor() {...} void linksUm() {...} void gib() {...} void nimm() {...} boolean vornFrei() {...} boolean kornDa() {...} boolean maulLeer() {...} }

OO-Hamstermodell / Hamsterklassen Baupläne für gleichartige Objekte beschreiben Eigenschaften, Struktur und Verhalten von Objekten bestehen aus Attributen und Methoden aus Klassen werden Objekte erzeugt (instantiiert) Attribute:  Variablen repräsentieren Eigenschaften und Struktur (Zustand) von Objekten alle Objekte einer Klasse besitzen dieselben Attribute die Werte der Attribute können aber verschieden sein Methoden:  Funktionen realisieren die Operationen, die auf Objekten einer Klasse ausgeführt werden können definieren das Verhalten von Objekten Konstruktoren: spezielle Methoden zur Initialisierung von Objekten

OO-Hamstermodell / Hamsterprogramme OO-Hamsterprogramme: Definitionsteil (Klassendefinitionen) Anwendungsteil („Hauptprogramm“) besteht aus agierenden und miteinander kommunizierenden Objekten Methodenaufruf = „Schicken einer Nachricht“ class Hamster { ... } void main() { Hamster paul = new Hamster(1, 1, ‘O‘, 12); while (paul.vornFrei()) paul.vor(); ... }

OO-Hamstermodell / Vererbung Strukturierungsprinzip bei der Klassendefinition Definition neuer Klassen durch Erweiterung bzw. Modifikation bereits existierender Klassen Vererbung von Attributen und Methoden class MyHamster extends Hamster { void kehrt() { linksUm(); linksUm(); } } void main() { MyHamster willi = new MyHamster(1, 1, ‘O‘, 12); if (!willi.vornFrei()) willi.kehrt(); ...

OO-Hamstermodell / Polymorphismus Polymorphismus / Dynamisches Binden: Objektvariablen können auch auf Objekte von Unterklassen referenzieren Zuordnung von auszuführenden Methoden zur Laufzeit class DummHamster extends MyHamster { void kehrt() { rechtsUm(); rechtsUm(); } void rechtsUm() { linksUm(); linksUm(); linksUm(); } } void main() { MyHamster willi = new MyHamster(1, 1, ‘O‘, 12); willi.kehrt(); willi = new DummHamster(1, 1, ‘O‘, 12); }

OO-Hamstermodell / Aggregation/Delegation Attribute können selbst wieder Objekte (Subobjekte) sein (Part-Of-Beziehung) Delegation: Weiterreichen von Nachrichten an Subobjekte class MyHamster extends Hamster { Hamster knecht; MyHamster(int x, int y, char b, int k) { super(x, y, b, k); knecht = new Hamster(x, y, b, k); } void laufeZurMauer() { while (knecht.vornFrei()) knecht.vor(); } }

OO-Hamstermodell / Klassenattribute gemeinsame Attribute aller Objekte einer Klasse class MyHamster extends Hamster { static int koerner; void nimm() { super.nimm(); koerner++; } } void main() { MyHamster willi = new MyHamster(1,1,‘W‘,0); MyHamster paul = new MyHamster(2,3,‘S‘,0); willi.nimm(); paul.nimm(); }

OO-Hamstermodell / Zugriffsrechte Kapselung von Daten Bildung von Abstrakten Datentypen class MyHamster extends Hamster { private int schritte; void vor() { super.vor(); schritte++; } } void main() { MyHamster willi = new MyHamster(1,1,‘W‘,0); willi.vor(); willi.schritte++; // Fehler!!! }

OO-Hamstermodell / Exceptions natürliche Art der Fehlerbehandlung class MauerException extends Exception {} class MyHamster extends Hamster { void vor() throws MauerException { if (!vornFrei()) throw new MauerException(); super.vor(); } } void main() { MyHamster willi = new MyHamster(1,1,‘W‘,0); try { willi.vor(); ... } catch (MauerException exc) { willi.linksUm(); }

Definitionen Klasse: beschreibt Eigenschaften (Variablen / Attribute) Struktur (Subobjekte) Verhalten (Funktionen / Methoden) einer Gruppe von gleichartigen Objekten ( Datentyp) Objekt (Instanz): werden durch Klassen beschrieben setzen sich demnach zusammen aus Datenelementen (Attribute)  Eigenschaften / Struktur / Zustand den auf den Attributen ausführbaren Operationen  Verhalten Objekte einer Klasse haben gleiche Attribute und gleiche Funktionen; sie unterscheiden sich nur in den Werten ihrer Attribute

Definitionen Attribut (Instanzvariable): Variable, für die in jedem Objekt Speicherplatz reserviert ist Menge der Attribute eines Objektes repräsentiert Zustand eines Objektes ( Komponente eines Verbundes) Methode: realisieren die auf Objekten einer Klasse anwendbaren Operationen ( Funktionen auf Verbund (d.h. Attributen)) Konstruktor: spezielle Methode zur Initialisierung von Objekten Instantiierung: Erzeugung von Objekten

Motivationsbeispiel public static void main(String[] args) { Bruch a = ; Bruch b = ; Bruch c = a * b; System.out.println( c ) ; // }  Definition einer Klasse Bruch zur Handhabung von Brüchen: Attribute: zaehler (int) / nenner (int) Methoden: Addition / Multiplikation / Vergleiche / Konvertierung / ... 3 4 4 5 3 5

Realisierung via Verbund plus separater Funktionen: Motivationsbeispiel Realisierung via Verbund plus separater Funktionen: class Bruch { int zaehler; int nenner; } public class BruchRechnung { public static Bruch init(int z, int n) { Bruch bruch = new Bruch(); bruch.zaehler = z; bruch.nenner = n; kuerzen(bruch); return bruch; } public static void mult(Bruch b1, Bruch b2) { b1.zaehler = b1.zaehler * b2.zaehler; b1.nenner = b1.nenner * b2.nenner; kuerzen(b1); public static void kuerzen(Bruch b) { ... } ...

Motivationsbeispiel public static boolean equal(Bruch b1, Bruch b2) { return (b1.nenner == b2.nenner) && (b1.zaehler == b2.zaehler); } public static void print(Bruch b) { System.out.println(b.zaehler + “/“ + b.nenner); public static void main(String[] args) { Bruch bruch1 = init(3, 4); Bruch bruch2 = init(4, 5); print(bruch1); mult(bruch1, bruch2); if (equal(bruch1, init(6,10)) System.out.println(“sind gleich“); } }

Klassendefinition <klassen-def> ::= „public“ „class“ <bezeichner> „{“ { <attr-def> | <methoden-def> | <konstruktor-def> } „}“ <attr-def> ::= <variablen-def> <methoden-def> ::= <funktionen-def> (ohne static) <konstruktor-def> ::= <methoden-def> (ohne Funktionstyp) Anmerkungen: Bezeichner = Klassenname (neuer Typ) Attribute sind bzgl. der Methoden einer Klasse global Zugriff im algemeinen via Schlüsselwort this Klasse = Verbund inklusive Funktionen auf Verbund

Realisierung via Klasse: Klassendefinition Realisierung via Klasse: public class Bruch { // Attribute int zaehler = 1; int nenner = 1; // Konstruktoren public Bruch(int z, int n) { this.zaehler = z; this.nenner = n; this.kuerzen(); } // Methoden public void mult(Bruch b2) { this.zaehler = this.zaehler * b2.zaehler; this.nenner = this.nenner * b2.nenner;

Klassendefinition public void kuerzen() { ... } public boolean equal(Bruch b2) { return (this.nenner == b2.nenner) && (this.zaehler == b2.zaehler); } public void print() { System.out.println(this.zaehler+“/“+this.nenner); public static void main(String[] args) { Bruch bruch1 = new Bruch(3, 4); Bruch bruch2 = new Bruch(4, 5); bruch1.print(); bruch1.mult(bruch2); if (bruch1.equal(new Bruch(6,10)) System.out.println(“sind gleich“); } }

Objektvariablendefinition <object-def> ::= <bezeichner> // Klassenname (Typ) <bezeichner> // Objektvariable { „,“ <bezeichner> } „;“ Anmerkungen: Klassen sind Referenzdatentypen Default-Initialisierung mit null Beispiele: Bruch bruch1; // bruch1 ist Objektvariable, // NICHT Objekt!!!!! Bruch bruch2, bruch3; Bruch bruch4 = null; Bruch[] brueche = new Bruch[5];

Objekterzeugung <object-creat> ::= „new“ <bezeichner> „(“ „)“ Anmerkungen: Bezeichner muss gültiger Klassenname sein new-Operator bildet Ausdruck, der eine Referenz auf den Speicherplatz (Menge der Attribute) für das neu erzeugte Objekt liefert Beispiele: new Bruch(); // Objekterzeugung Bruch bruch1; bruch1 = new Bruch(); // Objektvar. bruch1 verweist // auf erzeugtes Objekt Bruch bruch2 = new Bruch(); Bruch[] brueche = {new Bruch(), new Bruch()}; bruch1 bruch2 Objektvariable 1 zaehler 1 nenner 1 zaehler 1 nenner Objekt

Objektinitialisierung Anmerkungen: entspricht Initialisierung der Attribute des Objektes Default-Initialisierung der Attribute explizite Initialisierung der Attribute bei der Attributdefinition via Konstruktor Beispiele: public class Bruch { int zaehler; int nenner = 1; public Bruch(int z, int n) { this.zaehler = z; this.nenner = n; } public Bruch() {this(2,2);} // Default-Konstruktor public Bruch(Bruch b) { // Copy-Konstruktor this(b.zaehler, b.nenner);

Objektinitialisierung Anmerkungen: Aufruf eines Konstruktors bei der Objekterzeugung hinter dem new-Operator (notwendig!) Überladen des Konstruktors ist möglich Angabe eines gültigen Konstruktors (oder Default-Konstruktor) Aufruf via this-Konstrukt innerhalb der Methoden der Klasse möglich Beispiele: public static void main(String[] args) { Bruch b1 = new Bruch(); Bruch b2 = new Bruch(3,4); Bruch b3 = new Bruch(b2); Bruch b4 = b3; Bruch b5 = new Bruch(3); // Fehler !!! } b1 b2 b3 b4 3 zaehler 2 zaehler 4 nenner 2 nenner 3 zaehler 4 nenner

Objektzerstörung Anmerkungen: automatisch: Garbage Collection Beispiele: public static void main(String[] args) { Bruch b1 = new Bruch(); b1 = new Bruch(3,4); Bruch b3 = new Bruch(b2); Bruch b4 = b3; b3 = new Bruch(5,6); b1 = null; b3 = new Bruch(b1); // Laufzeitfehler! } b1 b3 b4 zaehler zaehler nenner nenner zaehler zaehler nenner nenner

Methodenaufruf <meth-aufruf> ::= <bezeichner> „.“ <funk-aufruf> Anmerkungen: Bezeichner muss Objektvariable sein! Objekt muss erzeugt worden sein! aufgerufene Methode muss in der Klasse des Objekts definiert sein! Beispiele: Bruch b1 = new Bruch(3,4); b1.print(); b1.mult(new Bruch(5,6)); if (b1.equals(new Bruch(7,6))) System.out.println(„gleich“); (new Bruch(-5,4)).print(); b1.println(); // Compilerfehler! Bruch b2; b2.print(); // Laufzeitfehler!

Methodenaufruf Schema: public class Bruch { int zaehler; int nenner; public void mult( /*Bruch this,*/ Bruch b) { this.zaehler = this.zaehler * b.zaehler; this.nenner = this.nenner * b.nenner; this.kuerzen(); // entspricht: kuerzen(this) } public void kuerzen(/*Bruch this*/) { ... } public static void main(String[] args) { Bruch b1 = new Bruch(); Bruch b2 = new Bruch(); b1.mult(b2); // entspricht: mult(b1, b2); b2.mult(b1); // entspricht: mult(b2, b1); } } Methodenaufruf = syntaktisch veränderter Funktionsaufruf !

Attributzugriff Anmerkungen: Attribute sind nur innerhalb von Methoden der Klasse zugreifbar nicht von „außen“ zugreifbar (Datenkapselung; später mehr) zum Zugriff auf Attribute müssen entsprechende Methoden definiert werden Beispiele: public class Bruch { int zaehler; int nenner = 1; public int getZaehler() { return this.zaehler; } public void setZaehler(int z) { this.zaehler = z; }} ... Bruch bruch = new Bruch(); bruch.setZaehler(4); // ok bruch.zaehler = 4; // bitte vermeiden!

Beispiel 1 public class Stack { int[] store; // zum Speichern von Daten int actual; // aktueller Index public Stack(int size) { this.store = new int[size]; this.actual = -1; } public Stack(Stack stack) { this(stack.store.length); for (int i=0; i<this.store.length; i++) this.store[i] = stack.store[i]; this.actual = stack.actual; public boolean isFull() { return this.actual == (this.store.length-1); public boolean isEmpty() { return this.actual == -1;

Beispiel 1 public void push(int value) { this.store[++this.actual] = value; } public int pop() { return this.store[this.actual--]; public static void main(String[] args) { Stack stack = new Stack(10); int wert = 1234; while ((wert > 0) && !stack.isFull()) { stack.push(wert % 10); wert = wert / 10; while (!stack.isEmpty()) { System.out.println(stack.pop()); } } }

Beispiel 2 public class MString { char[] zeichen; // zum Abspeichern der Zeichen public MString(char[] zeichen) { this.zeichen = new char[zeichen.length]; for (int i=0; i<this.zeichen.length; i++) this.zeichen[i] = zeichen[i]; } public MString(MString string) { this(string.zeichen); public boolean equal(MString string) { if (this.zeichen.length != string.zeichen.length) return false; if (this.zeichen[i] != string.zeichen[i]) return true;

Beispiel 2 public MString concat(MString str) { char[] store = new char[this.zeichen.length+str.zeichen.length]; for (int i=0; i<this.zeichen.length; i++) store[i] = this.zeichen[i]; for (int i=0; i<str.length; i++) store[this.zeichen.length+i] = str.zeichen[i]; this.zeichen = store; return this; } public void println() { System.out.print(this.zeichen[i]); System.out.println(); public int length() { return this.zeichen.length;

Beispiel 2 public static void main(String[] args) { MString str1 = new MString({‘h‘,‘a‘,‘l‘,‘l‘,‘o‘}); MString str2 = new MString({‘d‘,‘i‘,‘b‘,‘o‘}); Mstring str3 = new MString(str1); str3.println(); // hallo str3.concat(str2); str3.println() // hallodibo str1.concat(str2).concat(new MString({‘!‘})). println(); // hallodibo! if (str1.equal(str3) && (str1.length() < 10)) str1.println(); else System.out.println(“nicht gleich oder zu gross“); }

Beispiel 3 public class Int { int value; public Int(int v) { this.value = v; } public Int(Int obj) { this(obj.value); } public int getInt() { return this.value; } public void setInt(int v) { this.value = v; } public static void main(String[] args) { Int i1 = new Int(3); Int i2 = new Int(4); change(i1, i2); } public static void change(Int i1, Int i2) { int help = i1.getInt(); i1.setInt(i2.getInt()); i2.setInt(help); } }