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

Gliederung von Vorlesung 10 Klassen und Objekte in Java (II) Wiederholung Überladen von Methoden Objektarrays Objektparameter Objektattribute (Subobjekte) Klassenvariablen Klassenmethoden Konstante String-Objekte main-Funktion OO-Programme Beispiel OO-Softwareentwicklung Überblick OO-Analyse OO-Entwurf OO-Programmierung OO-Test UML Beispiel

Wiederholung Objekte (Instanz): setzen sich zusammen aus Datenelementen (Attribute) den auf den Attributen ausführbaren Operationen (Methoden) werden durch Klassen beschrieben Attribute (Instanzvariablen): Variablen, für die in jedem Objekt Speicherplatz reserviert sind Methoden: realisieren die auf Objekten einer Klasse anwendbaren Operationen Konstruktoren: spezielle Methoden zur Initialisierung von Objekten Instantiierung: Erzeugung von Objekten

Wiederholung public class Stack { // Klassendefinition // Attribute int[] store; // zum Speichern von Daten int actual; // aktueller Index // Konstruktoren public Stack(int size) { this.store = new int[size]; this.actual = -1; // Attributzugriff } 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;

Wiederholung // Methoden 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() { return this.store[this.actual--];

Wiederholung public static void main(String[] args) { //Objektvariablen, -erzeugung und -initialisierung Stack stack1 = new Stack(10); Stack stack2 = new Stack(5); int wert = 1234; while ((wert > 0) && !stack1.isFull()) { stack1.push(wert % 10); // Methodenzugriff wert = wert / 10; } while (!stack1.isEmpty() && !stack2.isFull()) stack2.push(stack1.pop()); while (!stack2.isEmpty()) { System.out.println(stack2.pop()); } } } // Objektzerstörung

Überladen von Methoden zwei oder mehrere Methoden (auch Konstruktoren!) einer Klasse können denselben Namen besitzen, wenn sie eine unterschiedliche Anzahl an Parametern besitzen oder wenn sich die Parametertypen an entsprechender Stelle unterscheiden public class Int { int value = 0; public void add(int v) { this.value += v; } public void add(float v) { this.value += (int)v; } public void add(int v1, int v2) { this.value += v1 + v2; } public static void main(String[] args) { Int obj = new Int(); obj.add(3); // int-add obj.add(3.4F); // float-add obj.add(4, 5); // int-int-add } }

Objektarrays public class Mitarbeiter { int id; float gehalt = 5555.0F; public Mitarbeiter(int no) { this.id = no; } public int getId() { return this.id; } public static void main(String[] args) { Mitarbeiter[] studis = new Mitarbeiter[3]; for (int i=0; i<studis.length; i++) studis[i] = new Mitarbeiter(i); int id = studis[2].getId(); Mitarbeiter[] profs = {new Mitarbeiter(4), new Mitarbeiter(5)}; } } Stack Heap studis 1 2 id 1 2 gehalt 5555. 5555. 5555.

Objektparameter public class Mitarbeiter { float gehalt; int abteilung = 1; public Mitarbeiter(float g) { this.gehalt = g; } public static void main(String[] args) { Mitarbeiter dibo = new Mitarbeiter(4444.0F); change(dibo, 6666.0F); System.out.println(dibo.gehalt); } public static void change(Mitarbeiter m, float g) { m.gehalt = g; m = new Mitarbeiter(3333.0F); } } Stack Heap main change gehalt dibo m g abteilung

Objektattribute (Subobjekte) public class Gehirn { ... } public class Herz { ... } public class Arm { ... } public class Mensch { Herz herz; // Subobjekt Gehirn gehirn; // exklusives Subobjekt Arm[] arme; // mehrere Subobjekte public Mensch() { this.gehirn = new Gehirn(); this.herz = new Herz(); this.arme = new Arm[2]; this.arme[0] = new Arm(); this.arme[1] = new Arm(); } public void transplantation(Herz neuesHerz) { this.herz = neuesHerz; } }

Klassenvariablen Definition: Klassenvariablen (static-Variablen) sind globale Variablen bzgl. einer Klasse (d.h. der Menge aller Methoden einer Klasse). Sie sind von allen Instanzen der Klasse zugreifbar. Der Wert einer Klassenvariablen ist für alle Instanzen einer Klasse stets identisch. Beispiel: Jedes Objekt einer Klasse soll eine eindeutige ID erhalten! public class Mitarbeiter { float gehalt; int id; static int idZaehler = 0; // Klassenvariable public Mitarbeiter(float geh) { this.gehalt = g; this.id = Mitarbeiter.idZaehler++; // alternativ: this.id = idZaehler++; // alternativ: this.id = this.idZaehler++; }

Klassenvariablen public static void main(String[] args) { Mitarbeiter dibo = new Mitarbeiter(6666); // -> dibo.id == 0 Mitarbeiter kurt = new Mitarbeiter(5555); // -> kurt.id == 1; } } Definition: mit Hilfe des Schlüsselwortes static Zugriff: via <Klassenname> . <Attributname> dibo kurt Stack gehalt gehalt Heap id id idZaehler

Klassenmethoden Definition: Klassenmethoden beschreiben das Verhalten von Operationen, die ausschließlich einer Klasse und nicht den von ihr erzeugten Objekten zugeordnet sind. Motivation: Zugriff auf Klassenvariablen Zugriff auf Elemente einer Klasse, ohne eine Instanz dieser Klasse zu besitzen public class Mitarbeiter { float gehalt; int id; static int idZaehler = 0; // Klassenvariable public Mitarbeiter(float geh) { this.gehalt = g; this.id = Mitarbeiter.idZaehler++; } public static int getZaehler() { // Klassenmethode return Mitarbeiter.idZaehler;

Klassenmethoden public static void main(String[] args) { Mitarbeiter dibo = new Mitarbeiter(6666); System.out.println(Mitarbeiter.getZaehler() ); // alternativ: dibo.getZaehler() } Definition: mit Hilfe des Schlüsselwortes static Zugriff: via <Klassenname> . <Methodenname> Anmerkungen: kein Zugriff auf Instanzvariablen/-methoden innerhalb einer Klassenmethode i.a. Zugriff auf Klassenvariablen Bereitstellung allgemeingültiger Operationen

Klassenmethoden public class Bruch { int zaehler, nenner; public Bruch(int z, int n) { this.zaehler = z; this.nenner = n; } public void mult(Bruch b) { this.zaehler *= b.zaehler; this.nenner *= b.nenner; public static Bruch mult(Bruch b1, Bruch b2); return new Bruch(b1.zaehler * b2.zaehler, b1.nenner * b2.nenner); public static void main(String[] args) { Bruch b1 = new Bruch(3, 4); Bruch b2 = new Bruch(7, 8); b1.mult(b2); // b1 *= b2 Bruch b4 = Bruch.mult(b1,b2); // b4 = b1 * b2 } }

Konstanten Definition: Konstante = ausschließlich lesbare Klassenvariable Schlüsselwort final: nicht veränderbar; nur lesbar public class Circle { public static final double PI = 3.1415926; double radius; public Circle(double r) { this.radius = r; } public double getRadius() { return this.radius; } public static void main(String[] args) { Circle c = new Circle(3.4); double umfang = 2 * Circle.PI * c.getRadius(); Circle.PI = 3.1416; // Fehler! }

String-Objekte Strings (Zeichenketten) sind in Java keine Standarddatentypen es existiert eine vordefinierte Klasse String im JDK: public class String { public String() {...} public String(char[] str) {...} public String(String str) {...} public int length() {...} public char charAt(int index) {...} public boolean equals(String str) {...} public boolean startsWith(String prefix) {...} public int indexOf(char ch) {...} public String subString(int begInd, int endInd) {...} public String concat(String str) {...} public static String valueOf(int i) {...} ... }

String-Objekte Definition, Erzeugung und Initialisierung: String str = new String(“hello“); // alternativ: String str = “hello“; +-Operator: String str = “hello“ + “world!“; Konvertierung in String-Objekte: int i = 4711; System.out.println(“Ich bin Nummer“ + i + “!“); public class Bruch { ... public String toString() { return this.zaehler + “/“ + this.nenner; } } Bruch bruch = new Bruch(3,4); System.out.println(“Bruch:“ + bruch); // automatischer Aufruf der toString-Methode

Manipulation von String-Objekten: nicht direkt möglich (keine entsprechenden Methoden vorhanden) Grund: Performance Umweg über Klasse StringBuffer aus dem JDK: public class StringBuffer { public StringBuffer(int length) {...} public StringBuffer(String str) {...} public void setCharAt(int index, char ch) {...} public StringBuffer append(String str) {...} public StringBuffer insert(int off, String str) {...} public String toString() {...} ... }

Vorgehensweise bei der Manipulation von String-Objekten: Umwandlung des zu manipulierenden String-Objektes in StringBuffer-Objekt Manipulation mit StringBuffer-Methoden Re-Umwandlung mittels der toString-Methode String str = “moin moin“; StringBuffer buffer = new StringBuffer(str); for (int i=0; i<buffer.length(); i++) if (buffer.charAt(i) == ‘o‘) buffer.setCharAt(i,‘e‘); str = buffer.toString(); System.out.println(str); // mein mein

main-Funktion public static void main(String[] args) { ... } Klassenmethode besitzt eine Klasse X eine main-Funktion und wird der Java-Interpreter mit java X aufgerufen, so startet das Programm automatisch mit dem Aufruf der Funktion X.main args: Übergabeparameter der Shell public class Echo { public static void main(String[] args) { for (int i=0; i<args.length; i++) System.out.println(args[i]); } } $ java Echo hello world $ java Echo moin hello moin world $ $

OO-Programme Definition OO-Programm: Gliederung: Verzeichnis uni: statisch: Menge an Klassen + eine Hauptklasse (Hauptprogramm) dynamisch: Menge an miteinander kommunizierenden Objekten Gliederung: jede Klasse i.a. in einer separaten Datei (zur Zeit im selben Verzeichnis!) Aufruf: java X  Aufruf der main-Prozedur der Klasse X Verzeichnis uni: Datei Mensch.java: public class Mensch {...} Datei Uni.java: public class Uni {...} Datei Bibliothek.java: public class Bibliothek {...} Datei UniBetrieb.java: public class UniBetrieb {...} Compilieren: javac *.java Ausführen: java UniBetrieb

Datenstruktur „Speicher“, in der prinzipiell beliebig viele Beispiel Datenstruktur „Speicher“, in der prinzipiell beliebig viele Elemente gespeichert werden können: public class Speicher { public void add (String str) {...} public void remove(String str) {...} public boolean isElement(String value) {...} // weitere Methoden ... } 1. Implementierungsalternative: verkettete Liste 2. Implementierungsalternative: wachsendes Array obj obj obj obj obj Voll?

Beispiel (verkettete Liste) class ListElem { ListElem prev; ListElem next; String value; public ListElem(ListElem p, ListElem n, String v) { this.prev = p; this.next = n; this.value = v; } public class List { ListElem first; public List() { this.first = null;} public void add(String value) { this.first = new ListElem(null, this.first, value); if (this.first.next != null) this.first.next.prev = this.first;

Beispiel (verkettete Liste) public boolean IsElement(String value) { ListElem help = this.first; while (help != null) { if (help.value.equals(value)) return true; help = help.next; } return false; public void remove(String value) { if (help.value.equals(value)) { if (help.prev != null) help.prev.next = help.next; if (help.next != null) help.next.prev = help.prev; if (help == this.first) this.first = help.next; } }

Beispiel (verkettete Liste) public void print() { System.out.println("*****"); ListElem help = this.first; while (help != null) { System.out.println(help.value); help = help.next; } public static void main(String[] args) { List list = new List(); list.add("1"); list.add("2"); list.add("3"); list.add("1"); list.add("1"); list.add("4"); list.print(); list.remove("1"); list.remove("5"); list.add("1"); list.print(); } }

Beispiel (wachsendes Array) public class DynArray { String[] values; int next; public DynArray() { this.values = new String[3]; this.next = 0; } public void add(String value) { if (this.next == this.values.length) this.grow(); this.values[this.next++] = value; public boolean IsElement(String value) { for (int i=0; i<this.next; i++) if (this.values[i].equals(value)) return true; return false;

Beispiel (wachsendes Array) public void remove(String value) { for (int i=0; i<this.next; i++) if (this.values[i].equals(value)) { for (int j=i+1; j<this.next; j++) this.values[j-1] = this.values[j]; this.next--; i--; } public void grow() { String[] store = new String[2*this.values.length]; store[i] = this.values[i]; this.values = store;

Beispiel (wachsendes Array) public void print() { System.out.println("*****"); for (int i=0; i<this.next; i++) System.out.println(this.values[i]); } public static void main(String[] args) { DynArray store = new DynArray(); store.add("1"); store.add("1"); store.add("2"); store.add("3"); store.add("1"); store.add("1"); store.add("4"); store.add("5"); store.print(); store.remove("1"); store.remove("5"); store.add("1"); store.print();

OO-Softwareentwicklung Ziel der Softwareentwicklung: Erstellung eines Softwaresystems zur Lösung eines Problems OO-Softwareentwicklung: Analyse des Anwendungsgebietes Modellierung des Anwendungsgebietes Transformation in ein Modell des Lösungsraumes Transformation in ein Programm (= Abstraktion des Anwendungsgebietes) durchgängiger Prozeß ohne Strukturbruch Vorgehensmodell mit folgenden Phasen: OO-Analyse OO-Entwurf/-Design OO-Implementierung/-Programmierung OO-Test Evolutionäres Vorgehen: iterativ und inkrementell Problem Programm

OO-Analyse Aufgabe: Ziel: Aktivitäten: Methoden: Untersuchung des Problem- bzw. Anwendungsbereiches Ziel: Erstellung eines Modells (OOA-Modell) als Abbild des statischen Aufbaus des Anwendungsgebietes sowie der dynamischen Abläufe im Anwendungsgebiet Aktivitäten: Identifikation von Objekten und Klassen Identifikation von Beziehungen zwischen Objekten Identifikation von Methoden und Attributen Identifikation von (Arbeits-)Abläufen Methoden: grammatikalische Untersuchung der Problembeschreibung: Substantive  Klassen/Objekte Adjektive  Attribute Verben  Methoden Sätze mit mehreren Substantiven  Beziehungen CRC-Methode

OO-Entwurf Aufgabe: Ziel: Aktivitäten: Methoden: Abbildung des Modells des Anwendungsgebietes (OOA-Modells) auf ein Modell des zu entwickelnden Systems (OOD-Modell) Ziel: konkrete Vorbereitung der Implementierungsphase Aktivitäten: Ergänzung des OOA-Modells um weitere Klassen/Objekte/Attribute/Methoden, die im Problembereich nicht auftreten, bei der Implementierung aber unerläßlich sind (Speicherung, Darstellung, ...) Entwurf der Softwarearchitektur Berücksichtigung von Betriebssystem, Programmiersprache, Datenverwaltung, ... Methoden: Untersuchung von möglichen Anwendungsszenarien des Systems Verwendung von Entwurfsmustern (Design Pattern)

OO-Programmierung Aufgabe: Ziel: Aktivitäten: Methoden: Anmerkungen: Umsetzung des OOD-Modells in eine konkrete Programmiersprache Ziel: Erstellung eines Programmsystems Aktivitäten: Implementierung der Klassen des OOD-Modells Aufbau von Klassenbibliotheken Methoden: relativ mechanische Überführung des OOD-Modells in ein Programm Nutzung von Klassenbibliotheken Anmerkungen: Nutzung nicht-objektorientierter Sprachen ist nicht ausgeschlossen

OO-Test Aufgabe: Ziel: Aktivitäten: Methoden: Anmerkungen: Überprüfung der Korrektheit des Programmsystems Ziel: Erstellung eines korrekten, vollständigen Programmsystems Aktivitäten: Test der Korrektheit der Methoden der einzelnen Klassen Test der Korrektheit der einzelnen Klassen Test der Korrektheit des Zusammenspiels der einzelnen Klassen Methoden: übliche Testmethoden Anmerkungen: Vorteile objektorientierter Software (Datenkapselung, Erweiterbarkeit, Wiederverwendbarkeit) kommen zur Geltung OO-Modellierungsnotationen sorgen für gute Dokumentation und Verständlichkeit

Unified Modeling Language: UML Unified Modeling Language: OO-Modellierungsnotation Festhalten von Ergebnissen Kommunikationsgrundlage keine Entwicklungsmethode! Strukturdiagramme Klassendiagramme Paketdiagramme Verhaltensdiagramme Anwendungsfalldiagramme Interaktionsdiagramme Sequenzdiagramme Kollaborationsdiagramme Zustandsdiagramme Aktivitätsdiagramme Implementierungsdiagramme Komponentendiagramme Einsatzdiagramme

Beispiel Implementierung des TicTacToe-Spiels: Beim TicTacToe-Spiel versuchen zwei Personen das Spiel zu gewinnen, indem sie abwechselnd Kreuz-Figuren (Spieler A) und Kreis-Figuren (Spieler B) auf einem 3x3-Brett so plazieren, dass ihre Figuren in einer Horizontalen, Vertikalen oder Diagonalen eine 3er-Reihe bilden. Anfangs ist das Brett leer. Das Spiel endet mit einem Unentschieden, wenn alle Felder des Brettes besetzt sind und kein Spieler eine 3er-Reihe bilden konnte.

Beispiel Identifikation von Objekten / Klassen: Spiel (class TTTSpiel) Spieler (class TTTSpieler) Spielbrett (class TTTBrett) Spielfiguren (class TTTFigur) Spielregeln (class TTTRegeln) Spielzüge (class TTTSpielzug) Identifikation von Beziehungen zwischen Objekten: ein Spiel besteht aus einem Spielbrett zu einem Spiel gehören Spielregeln zu einem Spiel gehören zwei Spieler auf dem Spielbrett können Spielfiguren plaziert werden auf dem Spielbrett werden Spielzüge ausgeführt jede Spielfigur gehört einem Spieler jeder Spieler kennt die Spielregeln Spielzüge müssen regelkonform zu den Spielregeln sein ...

Beispiel UML-Klassendiagramm:

Beispiel Identifikation von Attributen / Methoden: class TTTSpiel: void spielen(); class TTTBrett: void fuehreZugAus(TTTSpieler spieler, TTTSpielzug zug); void gebeSpielbrettAus(); class TTTFigur: boolean a_oder_b; int zeile, spalte; class TTTRegeln: boolean spielzugOK(TTTSpielzug zug); boolean spielEnde(); void gebeSiegerBekannt(); class TTTSpieler: boolean ist_spieler_a; TTTSpielzug liefereNaechstenZug(TTTSpielzug geg_zug);

Beispiel Identifikation von Arbeitsabläufen (UML-Sequenzdiagramm):

Beispiel Identifikation von Arbeitsabläufen (UML-Kollaborationsdiagramm):