Klassen und Objekte - Typen und Werte Lineare Listen

SWE-60
Klassen und Objekte - Typen und Werte
• In Java sind Grundtypen mit ihren Werten und Operationen darauf
nicht als Klassen mit Objekten und Methoden darauf definiert!
• Da z. B. Datenstrukturen wie Hashtable nur Objekte speichern, gibt es zu den Grundtypen
int, long, float, double, boolean, char
Klassen, die Werte in Objekten kapseln und Methoden dafür definieren (envelope classes):
Integer, Long, Float, Double, Boolean, Character (wrapper classes)
• Konversion z. B. zwischen int und Integer:
Integer-Konstruktor erzeugt Objekt aus Wert
Objekt-Methode von Integer liefert Wert
Integer (int value);
int intValue ();
• Konversion z. B. zwischen Integer und String:
Integer-Konstruktor erzeugt Objekt aus Ziffernfolge
Objekt-Methode von Integer liefert Wert als String
Integer (String s);
String toString ();
© 1999 bei Prof. Dr. Uwe Kastens
• Beispiele:
int i = 12;
Integer iObj = new Integer (i); // int-Wert in Objekt verpacken
int j = iObj.intValue();
// verpackten Wert holen
String s = iObj.toString();
// aus iObj ein String-Objekt erzeugen
String t = iObj;
// dasselbe implizit
Integer kObj = new Integer ("137"); // Integer-Objekt aus Ziffernfolge
SWE-68
Lineare Listen
Lineare Listen repräsentieren Folgen gleichartiger* Elemente als
dynamisch veränderliche Datenstruktur mit linearem Zugriff:
1
2
3
4
5
Listen werden aus Paaren aufgebaut: (Elementwert, Referenz auf den Rest der Liste)
1
Einfügen eines Elementes:
2
3
4
5
7
© 1999 bei Prof. Dr. Uwe Kastens
Löschen eines Elementes:
(*) Implementierung in Java:
nicht notwendig gleichartige Elemente, Elemente sind Objektreferenzen der Klasse Object
SWE-69
Implementierung linearer Listen
• Klasse Node für Paare (Element, Rest der Liste):
ein Objekt dazu:
class Node
{ Node (Object d, Node n)
{data = d; link = n;}
Object data; Node link;
5
}
• Objektvariable sind von aussen zugänglich (für die ADT-Klasse List, siehe SWE-71)
• Die vordefinierte Klasse Object umfasst Objektreferenzen beliebiger Klassen
• Deklaration einer Listenvariable, initialisiert mit einer 1-elementigen Liste:
© 1999 bei Prof. Dr. Uwe Kastens
Node list = new Node (new Integer (5), null);
• Element muß ein Objekt sein, also „Wrapper“ (envelope) für Werte von Grundtypen
• null: vordefinierter Name für die einzige Referenz, die kein Objekt identifiziert
SWE-70
Elementare Operationen mit linearen Listen
• Aufbauen einer Liste in umgekehrter Reihenfolge:
Node list = null;
for (int i = n; i > 0; i--)
list = new Node (new Integer (i), list);
• Einen Elementwert zahl in der Liste suchen:
Integer zahlObj = new Integer (zahl);
Node l = list;
while (l != null)
{ if (l.data.equals (zahlObj)) break;
l = l.link;
}
String s = ((l == null) ? s = " not" : "");
System.out.println (zahl + s + " found");
// s.u. (*)
// bedingter Ausdruck
• Ein Element d nach dem Paar l einfügen (l sei != null):
l.link = new Node (d, l.link);
© 1999 bei Prof. Dr. Uwe Kastens
• Ein Paar l mit Vorgänger prev löschen (l, prev seien != null):
prev.link = l.link;
Bei allen Operationen die Sonderfälle am Anfang und Ende der Liste beachten!
(*) equals ist für die Klasse Object definiert und wird von den Wrapper-Klassen als
Wertvergleich spezialisiert.
SWE-71
Abstrakter Datentyp Liste
ADT- Operationen für Listen mit verschieblicher Position zum Lesen, Einfügen und Löschen:
start
prev
now
aktuelle Position:
class List
{ List();
public void insert (Object x)
{
// Konstruktor
// Element x hinter akt. Pos. einfügen
Node newElem = new Node (x, null);
// und neues Element wird aktuelle Position
if (start == null)
// Liste ist leer
{ start = newElem; now = newElem;}
else
if (now == null) // Position ist außerhalb der Liste, am Anfang einfügen
{ newElem.link = start; start = newElem; now = newElem; prev = null;}
else
{ newElem.link = now.link; now.link = newElem; prev = now; now = newElem;}
© 1999 bei Prof. Dr. Uwe Kastens
}
public void remove () {…}
public Object current () {…}
public void succ() {…}
public void reset () {…}
public boolean isEol () {…}
public boolean isEmpty () {…}
private Node start, prev, now;
// Element löschen
// Wert des Elementes
// Position weitersetzen
// Position an den Anfang
// ist die Position außerhalb der Liste?
// ist die Liste leer?
// die 3 lokalen Variablen
}
SWE-72
Anwendung des ADT List: Nelsons Kaffeeladen
Das Array für die Lieferungen zu jeder Kaffeesorte wird durch ein List-Objekt ersetzt:
import List;
class Coffee
{
boolean newBatchIn (BufferedReader in) throws IOException
{ ...
BatchStock.insert (batch);
// gelesene Lieferung einfügen
}
© 1999 bei Prof. Dr. Uwe Kastens
double sell (Double toSell)
// eine Menge Kaffee verkaufen
{ ...
// die Liste der Lieferungen durchlaufen:
for (BatchStock.reset(); !BatchStock.isEol(); BatchStock.succ())
{ Batch b = (Batch)BatchStock.current();
// ... gewünschte Menge aus den Lieferungen entnehmen
}
return toSell;
}
...
private List BatchStock = new List ();
}
Ebenso in der Klasse CoffeeShop ein List-Objekt mit den Kaffeesorten einführen.
SWE-41
Rekursive Datenstrukturen mit rekursiven Methoden
© 1999 bei Prof. Dr. Uwe Kastens
Ein binärer Baum ist leer oder er besteht aus einem Wert und zwei Unterbäumen:
class BinTree
// Binäre Bäume mit Zeichenwerten an den Baumknoten
{ BinTree (BinTree l, char v, BinTree r)
// Konstruktor für innere Knoten
{ left = l; value = v; right = r; }
BinTree (char v)
// Konstruktor für Blattknoten
{ left = null; value = v; right = null; }
void inFix ()
// Ausgabe in Infix-Form, geklammert
{ System.out.print (’(’);
if (left != null) left.inFix ();
System.out.print (value);
if (right != null) right.inFix ();
System.out.print (’)’);
}
void postFix ()
// Ausgabe in Postfix-Form
{ if (left != null) left.postFix ();
if (right != null) right.postFix ();
System.out.print (value);
}
private BinTree left, right; private char value;
}
Aufruf z.B.: (new BinTree(new BinTree(’A’),’/’,new BinTree(’B’))).inFix();