Datenabstraktion

CS1005
Objektorientierte Programmierung
Bachelor of Science (Informatik)
Th Letschert
Klassenentwurf : Datenabstraktion
Seite 1
© Th Letschert
Datenabstraktion
Spezifikationen
Seite 2
© Th Letschert
Datenabstraktion
abstrakte Datentypen
Seite 3
Th Letschert
Abstraktion in der Informatik
Abstraktion
Von Unwesentlichem absehen
Konzentration auf das Wesentliche
Das Wesentliche in der Flut der Details finden
Abstraktion ist ein Grundprinzip der Informatik
Das Chaos der komplizierten Details ist das Problem.
Abstraktion ist die Lösung.
Seite 4
Th Letschert
Abstraktion: Funktionale Abstraktion
Funktionale Abstraktion:
Vom Algorithmus zum Programm
x ~> √x
Funktionale Abstraktion
public static double squareRoot( double x )
{
double a = 1;
for (int i = 0; i < 100; i++) {
a = (a + x / a) / 2;
}
return a;
}
Seite 5
Th Letschert
Abstraktion: Datenabstraktion
Daten-Abstraktion: Von ? zu ?
Was ist das ?
Was ist das ?
Daten-Abstraktion
public final class Vektor {
private double x;
private double y;
public Vektor addVektor (Vektor v2) {
return new Vektor(x+v2.x,
y+v2.y);
}
public boolean equals (Vektor v){
return x == v.x && y == v.y;
}
Vektor() {
this.x = 1.0; this.y = 1.0;
}
Vektor(double x, double y) {
this.x = x; this.y = y;
}
public static Vektor add (Vektor v1,
public boolean equals (Object o){
if ( o instanceof Vektor )
return equals( (Vektor) o);
else return false;
}
Vektor v2) {
return new Vektor(v1.x+v2.x,
v1.y+v2.y);
}
}
Seite 6
Th Letschert
Abstraktion: Datenabstraktion
Daten-Abstraktion: Von der Klasse zum Datentyp
Werte und Operationen
auf diesen Werten
Daten-Abstraktion
public final class Vektor {
private double x;
private double y;
Datentyp
Klasse
public Vektor addVektor (Vektor v2) {
return new Vektor(x+v2.x,
y+v2.y);
}
public boolean equals (Vektor v){
return x == v.x && y == v.y;
}
Vektor() {
this.x = 1.0; this.y = 1.0;
}
Vektor(double x, double y) {
this.x = x; this.y = y;
}
public static Vektor add (Vektor v1,
public boolean equals (Object o){
if ( o instanceof Vektor )
return equals( (Vektor) o);
else return false;
}
Vektor v2) {
return new Vektor(v1.x+v2.x,
v1.y+v2.y);
}
}
Seite 7
Th Letschert
Datenabstraktion
Daten-Abstraktion: Von einer Klasse zu einem
Datentyp
Datentyp
Werte
+ passende Operationen
konkreter Datentyp
in der Sprache implementierter / verfügbarer Datentyp
abstrakter Datentyp (ADT)
selbst implementierter Datentyp
typischerweise als Klasse
Objekte repräsentieren Werte
Methoden (statisch oder nicht statisch) repräsentieren
Operationen
interne Darstellung der Werte in den Objektvariablen:
Geheimnis der Klasse
Seite 8
Th Letschert
Datenabstraktion
Abstrakter Datentyp:
Werte: Vektoren
Operation: Vektoraddition
Implementierung
=
public final class Vektor {
private final double x;
private final double y;
Klasse:
Werte
Operationen
+
~ Objekte
~ Methoden
public Vektor() {
this.x = 1.0; this.y = 1.0;
}
public Vektor(double x, double y) {
this.x = x; this.y = y;
}
public Vektor add(Vektor v) {
return new Vektor(
x+v.x,
y+v.y);
}
Die abstrakten Werte entsprechen
Objekten in bestimmten
Zuständen
Zustand: aktuelle Belegung der
Objektvariablen
}
Seite 9
Th Letschert
Datenabstraktion und Geheimnisprinzip
Abstrakter Datentyp:
externe Sicht / Schnittstelle der
Klasse:
Was gibt es
Was tut es
Implementierung
+
=
public final class Vektor {
private final double x;
private final double y;
Geheim / gekapselt:
Wie werden die Werte intern
repräsentiert
Welche Algorithmen realisieren
die Operationen
public Vektor() {
this.x = 1.0; this.y = 1.0;
}
public Vektor(double x, double y) {
this.x = x; this.y = y;
}
public Vektor add(Vektor v) {
return new Vektor(
x+v.x,
y+v.y);
}
}
Seite 10
Th Letschert
Datenabstraktion, Kopplung und Kohäsion
Datenabstraktion = Klasse realisiert Abstrakten Datentyp
Trennung von Schnittstelle und Implementierung
➔ Kopplung gering !
Klasse repräsentiert einen anwendungsorientierten Typ
➔ Klasse hat ein klares, fest umrissenes, verstehbares
Konzept
➔ Kohäsion hoch !
+
=
p ublic final class Vektor {
p rivate fina l doub le x;
p rivate fina l doub le y;
p ublic Vektor() {
t his.x = 1.0; thi s.y = 1.0;
}
p ublic Vektor(doubl e x, doubl e y) {
t his.x = x; this.y = y;
}
p ublic Vektor add(Vektor v) {
r eturn new Vektor(
x+v.x,
y+v.y);
}
}
Seite 11
Th Letschert
ADTs, Wert- und Zustandsorientierung
Wertorientierte Klasse als Datenabstraktion
Klasse repräsentiert Datentyp (Typ von Daten):
Menge unveränderlicher Werte mit zugehörigen Funktionen
Operationen erzeugen Werte aus anderen Werten
Objekt-Variablen oft (nicht unbedingt) final
Methoden oft (nicht unbedingt) statisch
equals (+ hashcode) muss i.d.R. implementiert werden
oft wird Comparable und Cloneable implementiert
Zustandsorientierte Klasse als Datenabstraktion
Klasse repräsentiert Typ von Maschinen / Automaten:
Menge von veränderlichen – zustandsbehafteten - Objekten
Operationen sind Zustandsveränderer
Objektvariablen nicht final
Methoden i.d.R. nicht statisch
equals muss i.d.R. nicht implementiert werden
Comparable / Clonable werden i.d.R. nicht implementiert
Seite 12
Th Letschert
Spezifikation und
Implementierung
Seite 13
Th Letschert
Spezifikation und Schnittstelle
Spezifikation
Die Spezifikation einer Software-Komponente enthält die
Informationen die zu deren Erstellung notwendig sind.
Schnittstelle
Die Schnittstelle einer Software-Komponente enthält die
Informationen die zu deren Benutzung notwendig sind.
Die Spezifikation enthält mehr Informationen als die Schnittstelle. Sie umfasst
die Informationen der Schnittstelle.
Die Schnittstelle ist Bestandteil der Komponente, die Spezifikation dagegen
nicht.
Seite 14
Th Letschert
Spezifikation
Spezifikation: Funktionalität festlegen
Was kann die Klasse (was können ihre Objekte),
welchen Dienst bietet / bieten sie.
Die Spezifikation beschreibt die Einsatzmöglichkeiten der
Komponente
Die Implementierung bleibt dabei offen, wird nicht festgelegt /
beschrieben
Ziele einer (Klassen-) Spezifikation
die Möglichkeiten der Verwendung
möglichst genau beschreiben
die Möglichkeiten der Implementierung
möglichst wenig einschränken
Seite 15
Th Letschert
Spezifikation / Schnittstelle einer Funktion
Funktion:
Spezifikation / Schnittstelle / Implementierung
Funktion
Name:
Typ:
Ergebnis:
squareRoot
double -> double
Spezifikation
x ~> √x
public static double squareRoot( double x )
public static double squareRoot( double x ) {
double a = 1;
for (int i = 0; i < 100; i++) {
a = (a + x / a) / 2;
}
return a;
}
Seite 16
Schnittstelle
Implementierung
Th Letschert
Vertragsorientierte Spezifikation
Vertragsorientierte Spezifikation
Spezifikation beschreibt Rechte und Pflichten der Komponente und ihrer
Benutzer
Vorbedingung
= Recht der Komponente / Pflicht der Benutzer
Beschreibt die Bedingungen einer legalen Benutzung, Dinge
auf die die Komponente sich verlassen kann
Nachbedingung
= Recht der Benutzer / Pflicht der Komponente
Beschreibt die Leistung der Komponente, Dinge auf die die Benutzer
der Komponente sich verlassen können.
Zahlt der
Kunde 10 Jahre
monatlich
100 €
ein, so zahlt
die Bank
150000 €
aus
Seite 17
Th Letschert
Vertragsorientierte Spezifikation
Vertragsorientierte Spezifikation einer Funktion
/**
* Berechnet die Quadratwurzel
* @param x Eingabe
* @pre
x >= 0
* @return e mit e*e -0.001 < x < e*e +0.001
*/
public static double sqrt(double x) {
double a = 1;
for (int i = 0; i < 100; i++) {
a = (a + x / a) / 2;
}
return a;
}
Strukturierter
Kommentar
Vorbedingnung ~ Pre
(Precondition)
Rufst du mich
mit positiven
Werten auf,
dann liefere ich
die Wurzel mit
einer
Genauigkeit
von 0.001
Seite 18
Th Letschert
Spezifikation einer Datenabstraktion
Daten-Abstraktion:
Zustand Spezifikation und Implementierung
Abstrakter Zustand: Idee des Objektzustands (Plan)
Konkreter Zustand: tatsächliche Implementierung
Beispiel Stapel:
- abstrakter (gedachter) Zustand: Stapel von Elementen
- realer (implementierter) Zustand: Feld + Zählvariable
Stapel
3
2
2
count
int-Variable,
int-Feld
2 3 0 2 7 4
2
elem
Spezifikation
Implementierung
Seite 19
Th Letschert
Datenabstraktion: Abstraktionsfunktion
konkreter Zustand: aktuelle Belegung der Variablen
Abstraktionsfunktion: was (abstrakter Zustand) soll das
bedeuten
Implementierung
Spezifikation
– manche Details der konkreten Zustände (Wertebelegungen)
sind irrelevant (weg-zu-abstrahieren)
Stapel: Feldelemente „hinten“ uninteressant
– manche Zustände (Wertebelegungen) nicht erlaubt
count = 12999 nicht erlaubt
Abstraktionsfunktion
2
3
count
2 3 0 2 7 4
2
2
elems
elem
repräsentiert
abstrakter Zustand (Stapel)
(mit der Variablenbelegung
gemeinter Stapel)
konkreter Zustand (Feld + Variable)
(aktuelle Variablenbelegung)
Seite 20
Th Letschert
Datenabstraktion: Klasseninvariante
Abstraktionsfunktion:
Was bedeutet die Belegung der Variablen
Klasseninvariante:
Welche Belegungen sind erlaubt
class Stack {
....
private:
int count;
int a[10];
// aktuelle Zahl der Elemente
// Ablageplatz fuer die Elemente
// a[0]...a[count-1] sind die gestapelten Elemente,
a[count-1] ist dabei das oberste
// invariant: 0 <= count <= 10
Abstraktionsfunktion: Kommentar zu den
Objektvariablen: was bedeuten sie.
Klasseninvariante: Kommentar zu den erlaubten
Belegungen der Objektvariablen
Seite 21
Th Letschert
Korrektheit einer Implementierung
7
3
push(7)
2
3
2
elems
Spezifikation der Methode:
pre: size(elems)<10
post: elems = x+elems@pre
A
A(s.push(x)) = (A(s)).push(x)
2
push(7)
count
2 3 0 2 7 4
elems
2
Implementierung
der Methode
A
32
count
2 3 70 2 7 4
2
elems
elems
Seite 22
Th Letschert
Datenabstraktion: Spezifikation / Implementierung
Spezifikation und Implementierung einer Datenabstraktion
Spezifikation
abstrakter Zustand
vertragsorientierte Spezifikation der Methoden
Implementierung
Konkreter Zustand: Objektvariablen
mit:
Abstraktionsfunktion
Kommentar: Sinn / Bedeutung der Objektvariablen
Klasseninvariante
Kommentar: legale Belegungen der Objektvariablen
Methoden-Implementierungen
Seite 23
Th Letschert