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

Programmierkurs Java Vorlesung 10 Dietrich Boles Seite 1

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

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

studis 0 1 2 idgehalt

Stack Heap

0 1 2

5555. 5555. 5555.


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

dibo

Stack Heapmain

mchange

ggehaltabteilung


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

gehalt

id

gehalt

id

idZaehler

Stack

Heap


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


String-Objekte

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

...

}


String-Objekte

• 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:– 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 *.javaAusführen: java UniBetrieb


Beispiel

Datenstruktur „Speicher“, in der prinzipiell beliebig vieleElemente 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

Voll?

obj obj obj obj obj


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) { ListElem help = this.first; while (help != null) { 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; } help = 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; } System.out.println("*****"); } 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.print(); 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; }



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]; for (int i=0; i<this.next; i++) store[i] = this.values[i]; this.values = store; }



public void print() { System.out.println("*****"); for (int i=0; i<this.next; i++) System.out.println(this.values[i]); System.out.println("*****"); }

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.print(); 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: – 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: – 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: – 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: – Ü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


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.

leeres Spielbrett Zug von Spieler A Sieger: Spieler AZug von Spieler B


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

TTTSpielzug......

TTTSpieler

ist_spieler_aliefere-

Naechsten-Spielzug()

...

TTTFigur......

TTTBrett...... TTTRegeln

...

...

TTTSpiel......

gehört

kennt

1

1

1

0..9

1

2

1

1

TTTProgramm......

ausführen

regelkonform

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

spielen()

liefereNaechsten-Spielzug(zug)

...

spielzugOK(akt_spieler, zug)

[antwort = true] fuehreSpielzugAus (akt_spieler, zug)

gebeSpielbrettAus()

zug

antwort

akt_spieler: TTTSpieler

tictactoe: TTTSpiel

regeln: TTTRegeln

brett: TTTBrett

...

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


Beispiel

akt_spieler: TTTSpieler

tictactoe: TTTSpiel

regeln: TTTRegeln

brett: TTTBrett

1: spielen()

1.1: zug := liefereNaechstenZug(zug)

1.2: antwort := spielzugOK(akt_spieler, zug)

1.3: fuehreSpielzugAus(akt_spieler, zug)

1.4: gebeSpielbrettAus()

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

Documents

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