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

Programmierkurs Java Vorlesung 9 Dietrich Boles Seite 1

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

• Klassen:– 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

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

willi.kehrt();

}


OO-Hamstermodell / Aggregation/Delegation

• Aggregation:– Attribute können selbst wieder Objekte (Subobjekte) sein (Part-Of-

Beziehung)

• Delegation:– Weiterreichen von Nachrichten an Subobjekte


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

• Klassenattribute:– gemeinsame Attribute aller Objekte einer Klasse


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

• Zugriffsrechte:– Kapselung von Daten– Bildung von Abstrakten Datentypen


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

• 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 / ...

3445

35


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


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


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); bruch1.print(); 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(); // ObjekterzeugungBruch bruch1;bruch1 = new Bruch(); // Objektvar. bruch1 verweist // auf erzeugtes ObjektBruch bruch2 = new Bruch();

Bruch[] brueche = {new Bruch(), new Bruch()};

bruch1 bruch2

zaehler

nenner zaehler

nenner

1

1 1

1

Objekt

Objektvariable


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

zaehler

nenner zaehler

nenner

2

2 3

4

b3

zaehler

nenner

3

4

b4


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

zaehler

nenner

zaehler

nenner

b3

zaehler

nenner

b4

zaehler

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

werdenBeispiele:

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); // okbruch.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; for (int i=0; i<this.zeichen.length; i++) if (this.zeichen[i] != string.zeichen[i]) return false; 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() { for (int i=0; i<this.zeichen.length; i++) 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);} }

Documents

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