Objektorientierte Programmierung in Java · Traditionelle Konzepte der Softwaretechnik Folgende traditionelle Konzepte des Software-Engineering werden u.a. im objektorientierten Ansatz

Objektorientierte Programmierung in Java

Algorithmen und Datenstrukturen II 1

Traditionelle Konzepte der Softwaretechnik

Folgende traditionelle Konzepte des Software-Engineering werden u.a. imobjektorientierten Ansatz verwendet:

Datenabstraktion (bzw. Datenkapselung) und Information HidingDie zentrale Idee der Datenkapselung ist, dass auf eine Datenstruktur nichtdirekt zugegriffen wird, indem etwa einzelne Komponenten gelesen odergeändert werden, sondern, dass dieser Zugriff ausschließlich überZugriffsoperatoren erfolgt. Es werden also die Implementierungen derOperationen und die Datenstrukturen selbst versteckt.

Vorteil: Implementierungdetails können beliebig geändert werden, ohneAuswirkung auf den Rest des Programmes zu haben.


Traditionelle Konzepte der Softwaretechnik

Folgende traditionelle Konzepte des Software-Engineering werden u.a. imobjektorientierten Ansatz verwendet:

Datenabstraktion (bzw. Datenkapselung) und Information HidingDie zentrale Idee der Datenkapselung ist, dass auf eine Datenstruktur nichtdirekt zugegriffen wird, indem etwa einzelne Komponenten gelesen odergeändert werden, sondern, dass dieser Zugriff ausschließlich überZugriffsoperatoren erfolgt. Es werden also die Implementierungen derOperationen und die Datenstrukturen selbst versteckt.

Vorteil: Implementierungdetails können beliebig geändert werden, ohneAuswirkung auf den Rest des Programmes zu haben.


abstrakte Datentypen (ADT)Realisiert wird die Datenabstraktion duch den Einsatz abstrakter Datentypen,die Liskov & Zilles (1974) folgendermaßen definierten:

“An abstract data type defines a class of abstract objects which iscompletely characterized by the operations available on those objects.This means that an abstract data type can be defined by defining thecharacterizing operations for that type.”


Oder etwas prägnanter:

Datentyp = Menge(n) von Werten + Operationen darauf

abstrakter Datentyp = Operationen auf Werten, deren Repräsentation nichtbekannt ist. Der Zugriff erfolgt ausschließlich über Operatoren.


Oder etwas prägnanter:

Datentyp = Menge(n) von Werten + Operationen darauf

abstrakter Datentyp = Operationen auf Werten, deren Repräsentation nichtbekannt ist. Der Zugriff erfolgt ausschließlich über Operatoren.

Datenabstraktion fördert die Wiederverwendbarkeit von Programmteilen und dieWartbarkeit großer Programme.


Beispiel: Der ADT Stack

Stack: Eine Datenstruktur über einem Datentyp T bezeichnet man als Stacka, wenndie Einträge der Datenstruktur als Folge organisiert sind und es die Operationenpush, pop und peek gibt:




push fügt ein Element von T stets an das Ende der Folge.pop entfernt stets das letzte Element der Folge.peek liefert das letzte Element der Folge, ohne sie zu verändern.




push fügt ein Element von T stets an das Ende der Folge.pop entfernt stets das letzte Element der Folge.peek liefert das letzte Element der Folge, ohne sie zu verändern.

Prinzip: last in first out (LIFO)

abedeutet soviel wie Keller oder Stapel


Operatoren

Typen der Operationen: initStack: −→ Stack

push: T × Stack −→ Stack

pop: Stack −→ Stack

peek: Stack −→ T

empty: Stack −→ boolean


Spezifikation

Spezifikation der Operationen durch Gleichungen. Sei x eine Variable vom Typ T,stack eine Variable vom Typ Stack:

empty (initStack) = true

empty (push (x, stack)) = false

peek (push (x, stack)) = x

pop (push (x, stack)) = stack


Spezifikation

Spezifikation der Operationen durch Gleichungen. Sei x eine Variable vom Typ T,stack eine Variable vom Typ Stack:

empty (initStack) = true

empty (push (x, stack)) = false

peek (push (x, stack)) = x

pop (push (x, stack)) = stack

initStack und push sind Konstruktoren (sie konstruieren Terme), daher gibt eskeine Gleichungen für sie.


Konzepte der objektorientierten Programmierung

Ziel jeglicher Programmierung ist:

• Modellierung von Ausschnitten der Realität

• sachgerechte Abstraktion

• realitätsnahes Verhalten

• Nachbildung von Ähnlichkeit im Verhalten

• Klassifikation von Problemen


Phylogenetische Klassifizierung

Tiere��

�� ?

HHHHHHHj

Insekten Fische Säugetiere

�� ?

@@@R

�� ?

@@@R

�� ?

@@@R


Ökonomische Klassifizierung

Tiere��

�� ?

HHHHH

HHj

Zuchttiere Wild Störtiere

�� ?

@@@R

�� ?

@@@R

�� ?

@@@R


Drei Vorgehensweisen im Systementwurf

1. die funktionsorientierte

2. die datenorientierte

3. die objektorientierte


Der Kerngedanke des objektorientierten Ansatzes besteht darin, Daten undFunktionen zu verschmelzen. Im ersten Schritt werden die Daten abgeleitet, imzweiten Schritt werden den Daten die Funktionen zugeordnet, die sie manipulieren.Die entstehenden Einheiten aus Daten und Funktionen werden Objekte genannt.


Der Kerngedanke des objektorientierten Ansatzes besteht darin, Daten undFunktionen zu verschmelzen. Im ersten Schritt werden die Daten abgeleitet, imzweiten Schritt werden den Daten die Funktionen zugeordnet, die sie manipulieren.Die entstehenden Einheiten aus Daten und Funktionen werden Objekte genannt.Wir schränken den Begriff Objektorientierung gemäß folgender Gleichung vonCoad & Yourdon weiter ein:

Objektorientierung = Klassen und Objekte

+ Kommunikation mit Nachrichten

+ Vererbung


Einfachvererbung

Object

�� ?

@@@R

System Math Point

@@@R

...


Mehrfachvererbung

. . .

��

@@@R

Tiere Pflanzen

@@@R

��

Fleischfresser

@@@R

. . .


Klasse Object

Object oref = new Point();

oref = "eine Zeichenkette";


Konstruktoren und Initialisierungsblöcke


public class Circle {

int x=0, y=0, r=1;

static int numCircles=0;

public Circle() {

numCircles++;

}

public double circumference() {

return 2*Math.PI*r;

}

public double area() {

return Math.PI*r*r;

}


public static void main(String[] args) {

Circle c = new Circle();

System.out.println(c.r);

System.out.println(c.circumference());

System.out.println(c.area());

System.out.println(numCircles);

}

}


Konstruktor mit Parametern

public Circle(int xCoord, int yCoord, int radius) {

numCircles++;

x = xCoord;

y = yCoord;

r = radius;

}


mit this-Referenz

public Circle(int x, int y, int r) {

numCircles++;

this.x = x;

this.y = y;

this.r = r;

}


Überladen von Konstruktoren



int x = 0, y = 0, r = 1;

static int numCircles;

public Circle() {

numCircles++;

}


this();

this.x = x;

this.y = y;

this.r = r;

}


public Circle(int r) {

this(0,0,r);

}


Circle c1 = new Circle();

Circle c2 = new Circle(1,1,2);

Circle c3 = new Circle(3);

System.out.println(numCircles);

}

}


Komplexe Initialisierung von Klassenvariablenpublic class Circle {

public static double[] sines = new double[1000];

public static double[] cosines = new double[1000];

static {

double x, delta_x;

int i;

delta_x = (Math.PI/2)/(1000-1);

for(i=0,x=0; i<1000; i++,x+=delta_x) {

sines[i] = Math.sin(x);

cosines[i] = Math.cos(x);

}

}

}


Java-Klassen als Realisierung und Implementierung von

abstrakten Datentypen

Durch den Modifizierer private können wir Implementierungsdetails verstecken,denn als private deklarierte Attribute und Methoden sind nur in der Klasse selbstzugreifbara. Folgende Klasse implementiert einen ADT Stack mittels eines Feldes:

aSynonyme für Zugreifbarkeit sind: Gültigkeit bzw. Sichtbarkeit.



public class Stack {

private Object[] stack;

private int top = -1;

private static final int CAPACITY = 10000;

/** liefert einen leeren Keller. */

public Stack() {

stack = new Object[CAPACITY];

}

/** legt ein Objekt im Keller ab und liefert dieses Objekt

zusaetzlich zurueck. */

public Object push(Object item) {


stack[++top] = item;

return item;

}

/** entfernt das oberste Objekt vom Keller und liefert es zurueck.

Bei leerem Keller wird eine Fehlermeldung ausgegeben und

null zurueckgeliefert. */

public Object pop() {

if (empty()) {

System.out.println("Method pop: empty stack");

return null;

}

else

return stack[top--];

}


/** liefert das oberste Objekt des Kellers, ohne ihn zu veraendern.

Bei leerem Keller wird eine Fehlermeldung ausgegeben und

null zurueckgeliefert. */

public Object peek() {

if (empty()) {

System.out.println("Method peek: empty stack");

return null;

}

else

return stack[top];

}

/** liefert true genau dann, wenn der Keller leer ist. */


public boolean empty() {

return (top == -1);

}

/** liefert die Anzahl der Elemente des Kellers. */

public int size() {

return top+1;

}

}


Der Dokumentationskommentar /** ... */ wird zur automatischenDokumentierung der Attribute und Methoden einer Klasse benutzt. Das Programmjavadoc generiert ein HTML-File, in dem alle sichtbaren Attribute und Methodenmit deren Parameterlisten aufgezeigt und dokumentiert sind.

> javadoc Stack.java

Dieses HTML-File ist der Vertrag (die Schnittstelle) der Klasse und entspricht demADT Stack, wobei die Operationen bzw. Methoden allerdings nurnatürlichsprachlich spezifiziert wurden. Die obige verbale Spezifikation entsprichtweitgehend der der vordefinierten Java-Klasse Stack (genauer java.util.Stack).Man beachte, dass (aus diesem Grund) die obige Spezifikation von derGleichungsspezifikation aus dem Unterabschnitt ?? abweicht.


Methoden in Java

1. Methoden und Signaturen

2. Überladen von Methoden

3. Wertübergabe (call by value)


call by value

Die Parameterübergabe zu Methoden erfolgt in Java durch Wertübergabe (call byvalue). D.h., dass Werte von Parametervariablen in einer Methode Kopien der vomAufrufer angegebenen Werte sind. Das nächste Beispiel verdeutlicht dies.


public class CallByValue {

public static int sqr(int i) {

i = i*i;

return(i);

}


int i = 3;

System.out.println(sqr(i));

System.out.println(i);

}

}

> java CallByValue

9

3


Allerdings ist zu beachten, dass nicht Objekte, sondern Objektreferenzenübergeben werden. Wir betrachten unser Standardbeispiel Circle in folgenderabgespeckter Form (gemäß der Devise, Implementierungsdetails zu verbergen,werden die Datenfelder als private deklariert).



private int x,y,r;


this.x = x;

this.y = y;

this.r = r;

}

public double circumference() {

return 2 * Math.PI * r;

}

public double area() {

return Math.PI * r * r;

}


public static void setToZero (Circle arg) {

arg.r = 0;

arg = null;

}


Circle kreis = new Circle(10,10,1);

System.out.println("vorher : r = "+kreis.r);

setToZero(kreis);

System.out.println("nachher: r = "+kreis.r);

}

}


> java Circle

vorher : r = 1

nachher: r = 0


> java Circle

vorher : r = 1

nachher: r = 0

Dieses Verhalten entspricht jedoch nicht der Parameterübergabe call by reference,denn bei der Wertübergabe wird eine Kopie der Referenz erzeugt und dieursprüngliche Referenz bleibt erhalten. Bei call by reference würde die übergebeneReferenz eben nicht kopiert und daher in der Methode setToZero auf nullgesetzt.


Unterklassen und Vererbung in Java


import java.awt.Color;

import java.awt.Graphics;

public class GraphicCircle extends Circle {

protected Color outline; // Farbe der Umrandung

protected Color fill; // Farbe des Inneren

public GraphicCircle(int x,int y,int r,Color outline) {

super(x,y,r);

this.outline = outline;

this.fill = Color.lightGray;

}

public GraphicCircle(int x,int y,int r,Color outline,Color fill) {

this(x,y,r,outline);

this.fill = fill;


}

public void draw(Graphics g) {

g.setColor(outline);

g.drawOval(x-r, y-r, 2*r, 2*r);

g.setColor(fill);

g.fillOval(x-r, y-r, 2*r, 2*r);

}


GraphicCircle gc = new GraphicCircle(0,0,100,Color.red,Color.blue);

double area = gc.area();

System.out.println(area);

Circle c = gc;

double circumference = c.circumference();


System.out.println(circumference);

GraphicCircle gc1 = (GraphicCircle) c;

Color color = gc1.fill;

System.out.println(color);

}

}


Color und Graphics

Color und Graphics sind vordefinierte Klassen, die durch import zugreifbargemacht werden (vgl. Abschnitt ??). Diese Klassen werden z.B. in [?] beschrieben.Zum Verständnis reicht es hier zu wissen, dass der erste Konstruktor denKonstruktor seiner Oberklasse aufruft (vgl. Abschnitt ??) und das Kreisinnere dieFarbe hellgrau erhält, sowie, dass die Methode draw einen farbigen Kreis zeichnet.


Da GraphicCircle alle Methoden von Circle erbt, können wir z.B. denFlächeninhalt eines Objektes gc vom Typ GraphicCircle berechen durch:

double area = gc.area();

Jedes Objekt gc vom Typ GraphicCircle ist ebenfalls ein Objekt vom Typ Circle

bzw. vom Typ Object. Deshalb sind folgende Zuweisungen korrekt.

Circle c = gc;

double area = c.area();

Man kann c durch castinga in ein Objekt vom Typ GraphicCircle

zurückverwandeln.aexplizite Typumwandlung


GraphicCircle gc1 = (GraphicCircle)c;

Color color = gc1.fill;

Die oben gezeigte Typumwandlung funktioniert nur, weil c tatsächlich ein Objektvom Typ GraphicCircle ist.


Überschreiben von Methoden und Verdecken von

Datenfeldern

Wir betrachten folgendes Java-Programm (Arnold & Gosling [?], S. 66):

public class SuperShow {

public String str = "SuperStr";

public void show() {

System.out.println("Super.show: "+str);

}

}


Überschreiben von Methoden und Verdecken von

Datenfeldern

Wir betrachten folgendes Java-Programm (Arnold & Gosling [?], S. 66):

public class SuperShow {

public String str = "SuperStr";


System.out.println("Super.show: "+str);

}

}


public class ExtendShow extends SuperShow {

public String str = "ExtendStr";


System.out.println("Extend.show: "+str);

}


ExtendShow ext = new ExtendShow();

SuperShow sup = ext;

sup.show();

ext.show();

System.out.println("sup.str = "+sup.str);

System.out.println("ext.str = "+ext.str);

}

}


Verdecken von Datenfeldern

Jedes ExtendShow-Objekt hat zwei String-Variablen, die beide str heißen undvon denen eine ererbt wurde. Die neue Variable str verdeckt die ererbte; wir sagenauch die ererbte ist verborgen. Sie existiert zwar, man kann aber nicht mehr durchAngabe ihres Namens auf sie zugreifen.


Überschreiben von Methoden

Wenn eine Methode von einem Objekt aufgerufen wird, dann bestimmt immer dertatsächliche Typ des Objektes, welche Implementierung benutzt wird. Bei einemZugriff auf ein Datenfeld wird jedoch der deklarierte Typ der Referenz verwendet.Daher erhalten wir folgende Ausgabe beim Aufruf der main-Methode:

> java ExtendShow

Extend.show: ExtendStr

Extend.show: ExtendStr

sup.str = SuperStr

ext.str = ExtendStr


Die Objektreferenz super

Das Schlüsselwort super kann in allen objektbezogenen Methoden undKonstruktoren verwendet werden. In Datenfeldzugriffen und Methodenaufrufenstellt es eine Referenz zum aktuellen Objekt als eine Instanz seiner Oberklasse dar.Wenn super verwendet wird, so bestimmt der Typ der Referenz über die Auswahlder zu verwendenden Methodenimplementierung. Wir illustrieren dies wieder aneinem Beispielprogramm.


super Beispiel

public class T1 {

protected int x = 1;

protected String s() {

return "T1";

}

}



public class T2 extends T1 {

protected int x = 2;

protected String s() {

return "T2";

}

protected void test() {

System.out.println("x= "+x);

System.out.println("super.x= "+super.x);

System.out.println("((T1)this).x= "+((T1)this).x);

System.out.println("s(): "+s());

System.out.println("super.s(): "+super.s());

System.out.println("((T1)this).s(): "+((T1)this).s());

}



new T2().test();

}

}


> java T2

x= 2

super.x= 1

((T1)this).x= 1

s(): T2

super.s(): T1

((T1)this).s(): T2


Konstruktoren in Unterklassen

In Konstruktoren der Unterklasse kann direkt einer der Oberklassenkonstruktorenmittels des super() Konstruktes aufgerufen werden.

Achtung: Der super-Aufruf muss die erste Anweisung des Konstruktors sein!


Wird kein Oberklassenkonstruktor explizit aufgerufen, so wird der parameterloseKonstruktor der Oberklasse automatisch aufgerufen, bevor die Anweisungen desneuen Konstruktors ausgeführt werden. Verfügt die Oberklasse nicht über einenparameterlosen Konstruktor, so muss ein Konstruktor der Oberklasse explizit mitParametern aufgerufen werden, da es sonst einen Fehler bei der Übersetzung gibt.


Wird kein Oberklassenkonstruktor explizit aufgerufen, so wird der parameterloseKonstruktor der Oberklasse automatisch aufgerufen, bevor die Anweisungen desneuen Konstruktors ausgeführt werden. Verfügt die Oberklasse nicht über einenparameterlosen Konstruktor, so muss ein Konstruktor der Oberklasse explizit mitParametern aufgerufen werden, da es sonst einen Fehler bei der Übersetzung gibt.

Ausnahme: Wird in der ersten Anweisung eines Konstruktors ein andererKonstruktor derselben Klasse mittels this aufgerufen, so wird nichtautomatisch der parameterlose Oberklassenkonstruktor aufgerufen.


Java liefert einen voreingestellten parameterlosen Konstruktor für eine erweiterndeKlasse, die keinen Konstruktor enthält. Dieser ist äquivalent zu:

public class ExtendedClass extends SimpleClass {

public ExtendedClass () {

super();

}

}

Der voreingestellte Konstruktor hat dieselbe Sichtbarkeit wie seine Klasse.


Ausnahme: Enthält die Oberklasse keinen parameterlosen Konstruktor, so muss dieUnterklasse mindestens einen Konstruktor bereitstellen.


Reihenfolgeabhängigkeit von Konstruktoren

Wird ein Objekt erzeugt, so werden zuerst alle seine Datenfelder auf voreingestellteWerte initialisiert. Jeder Konstruktor durchläuft dann drei Phasen:

• Aufruf des Konstruktors der Oberklasse.

• Initialisierung der Datenfelder mittels der Initialisierungsausdrücke.

• Ausführung des Rumpfes des Konstruktors.



public class X {

protected String infix = "fel";

protected String suffix;

protected String alles;

public X() {

suffix = infix;

alles = verbinde("Ap");

}

public String verbinde(String original) {

return (original+suffix);

}

}


public class Y extends X {

protected String extra = "d";

public Y() {

suffix = suffix+extra;

alles = verbinde("Biele");

}


new Y();

}

}


Schritt Aktion infix extra suffix alles

0 Datenfelder auf Voreinstellungen

1 Y-Konstruktor aufgerufen

2 X-Konstruktor aufgerufen

3 X-Datenfeld initialisiert fel

4 X-Konstruktor ausgeführt fel fel Apfel

5 Y-Datenfeld initialisiert fel d fel Apfel

6 Y-Konstruktor ausgeführt fel d feld Bielefeld


Abstrakte Klassen und Methoden

Es gilt:



Es gilt:

• eine abstrakte Methode hat keinen Rumpf;



Es gilt:


• jede Klasse, die eine abstrakte Methode enthält, ist selbst abstrakt und muss alssolche gekennzeichnet werden;



Es gilt:



• jede abstrakte Klasse muss mindestens eine abstrakte Methode besitzen;



Es gilt:




• man kann von einer abstrakten Klasse keine Objekte erzeugen;



Es gilt:





• von einer Unterklasse einer abstrakten Klasse kann man Objekte erzeugen –vorausgesetzt sie überschreibt alle abstrakten Methoden der Oberklasse undimplementiert diese;



Es gilt:





• von einer Unterklasse einer abstrakten Klasse kann man Objekte erzeugen –vorausgesetzt sie überschreibt alle abstrakten Methoden der Oberklasse undimplementiert diese;


• eine Unterklasse, die nicht alle abstrakten Methoden der Oberklasseimplementiert ist selbst wieder abstrakt.


Beispiel Benchmark

public abstract class Benchmark {

public abstract void benchmark();

public long repeat(int count) {

long start = System.currentTimeMillis();

for(int i=0; i<count; i++)

benchmark();

return (System.currentTimeMillis()-start);

}

}


public class MethodBenchmark extends Benchmark {

public void benchmark() { }


int count = Integer.parseInt(args[0]);

long time = new MethodBenchmark().repeat(count);

System.out.println(count+" Methodenaufrufe in "+time+

" Millisekunden");

}

}


Documents

Objektorientierte Programmierung in Java · Traditionelle Konzepte der Softwaretechnik Folgende traditionelle Konzepte des Software-Engineering werden u.a. im objektorientierten Ansatz