Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

der Universität Oldenburg

Ähnliche Präsentationen


Präsentation zum Thema: "der Universität Oldenburg"—  Präsentation transkript:

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

2 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

3 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

4 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

5 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() {...} }

6 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

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

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

9 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); }

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

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

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

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

14 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

15 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

16 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

17 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) { ... } ...

18 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“); } }

19 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

20 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;

21 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“); } }

22 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];

23 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

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

25 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

26 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

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

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

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

30 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;

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

32 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;

33 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;

34 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“); }

35 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); } }


Herunterladen ppt "der Universität Oldenburg"

Ähnliche Präsentationen


Google-Anzeigen