Keller: Interface und Implementierung Innere Klassen

SWE-76a
Keller: Interface und Implementierung
public interface Stack
{ void push (Object x);
Object top ();
}
import java.util.Vector;
void pop();
boolean isEmpty();
public class VectorStack implements Stack
{ private Vector elems;
// Kellerelemente
VectorStack () { elems = new Vector (); }
public void push( Object x )
{ elems.addElement (x); }
// neues Element oben anfuegen
© 1999 bei Prof. Dr. Uwe Kastens
public void pop()
// Falls Stack nicht leer oberstes Element entfernen
{ if (!elems.isEmpty()) elems.removeElementAt (elems.size()-1); }
public Object top()
// Falls Keller nicht leer oberstes Element
{ if (!elems.isEmpty())
// sonst kein Element zurückgeben
return elems.lastElement ();
else return null;
}
public boolean isEmpty() { return elems.isEmpty (); }
}
SWE-98a
Innere Klassen
Innere Klassen können z. B. als Hilfsklassen zur Implementierung der umgebenden Klasse
verwendet werden:
class List { ... static class Node { ...} ...}
Die List-Objekte und Node-Objekte sind dann unabhängig voneinander.
Es wird nur die Gültigkeit des Namens Node auf die Klasse List eingeschränkt.
In inneren Klassen, die nicht static sind, können Methoden der inneren Klasse auf
Objektvariable der äusseren Klasse zugreifen. Ein Objekt der inneren Klasse ist dann immer in
ein Objekt der äusseren Klasse eingebettet; z. B. die inneren Listener Klassen, oder auch:
interface Einnehmer { void bezahle (int n); }
class Kasse
// Jedes Kassierer-Objekt eines Kassen-Objekts
{ private int geldSack = 0;
// zahlt in denselben Geldsack
class Kassierer implements Einnehmer
{ public void bezahle (int n)
{ geldSack += n; }
}
Einnehmer neuerEinnehmer ()
{ return new Kassierer (); }
}
SWE-77
Beispiel zur Implementierung eines Interface: Enumeration
Schnittstelle zum Aufzählen der Elemente eines Behälter-Objektes, definiert in java.util:
public interface Enumeration
{ boolean hasMoreElements(); Object nextElement();}
Erweiterung der Klasse List, so dass sie Enumerations erzeugen kann:
class List
{ ...
// Eine innere Klasse implementiert Enumeration für List:
class ListEnum implements Enumeration
{ Node current = start; // Objektvariable initialisiert mit dem Listenanfang
// Schnittstellenmethode
public boolean hasMoreElements()
{ return current != null;}
public Object nextElement()
// Schnittstellenmethode
{ if (current != null)
{ Object result = current.data;
// Wert des Listenelementes
current = current.link;
// nächstes Paar
return result;
} else throw new NoSuchElementException("List Enumeration");
} }
public Enumeration elements ()
{ return new ListEnum ();}
// Methode zur Erzeugung eines
// "Enumeration"-Objektes
}
SWE-77a
Implementierung von Enumeration für den ADT List
Enumeration
Objekte
Interface u.
lotto
enum
Klassen
List
Hashtable
current ListEnum
List-Objekt
start
prev
current
now
ListEnum
Objekt
Klassen mit inneren Klassen, die das
Interface Enumeration implementieren
List lotto = new List();
lotto.insert (new Integer (7));
...
Enumeration enum = lotto.elements();
while (enum.hasMoreElements())
{... enum.nextElement()...}
start
7
prev
13
now
29
SWE-58
Wörterbücher
Wörterbuch: Datenstruktur zur Speicherung von Paaren (Schlüssel, Wert).
Operationen: ein Paar zufügen; den Wert zu einem Schlüssel liefern.
Beispiele für solche Mengen von Paaren:
• (Name, Studierendendaten) in der Studierendenverwaltung
• (deutsche Vokabel, englische Vokabel) Wörterbuch im engen Sinne
• (Koordinate, geografisches Objekt) Sammlung geografischer Informationen
Implementierung mit der Hash-Methode (siehe Algorithmen und Datenstrukturen, 2. Sem.):
Aus dem Schlüssel jedes Paares wird ein Index eines Arrays errechnet.
Das Paar wird an einer freien Stelle an oder nach diesem Index im Array gespeichert.
Beim Zugriff wird entprechend von dem Index an gesucht, der zu dem Schlüssel gehört.
© 1999 bei Prof. Dr. Uwe Kastens
Implementiert durch die Klasse Hashtable im Package java.util. Operationen:
void
Object
boolean
boolean
void
put (Object key, Object value);
// Paar zufügen
get (Object key);
// Wert zum Schlüssel liefern
containsKey (Object key);
// Gibt es ein Paar mit dem Schlüssel?
contains (Object value);
// Gibt es ein Paar mit dem Wert?
remove (Object key);
// Paar mit dem Schlüssel entfernen
Ein Hashtable-Objekt kann Paare aufnehmen, deren Schlüssel und Werte Objekte beliebiger
Klassen sind. Object ist die allgemeinste (Oberklasse) aller Klassen.
SWE-59
Elemente einer Datenstruktur aufzählen (Enumeration)
Mit einer Enumeration kann man die Elemente einer Datenstruktur, wie Hashtable, z. B. in
Schleifen aufzählen (Iterator):
e = table.keys();
erzeugt ein Enumeration-Objekt für die Schlüssel in table
e.hasMoreElements() liefert true, wenn e noch nicht alle Elemente durchlaufen hat
e.nextElement()
liefert das nächste Element
Benutzung:
Hashtable englischDeutsch = new Hashtable();
// Wörterbuch füllen:
englischDeutsch.put ("dog", "Hund");
englischDeutsch.put ("cat", "Katze"); ...
© 1999 bei Prof. Dr. Uwe Kastens
// ein Zugriff auf das Wörterbuch:
System.out.println ( (String)englischDeutsch.get ("dog") );
// Alle Schlüssel des Wörterbuches ausgeben:
Enumeration e = englischDeutsch.keys();
while (e.hasMoreElements())
{ String key = (String) e.nextElement ();
System.out.println (key);
}
SWE-99
Anonyme Klasse
Meist wird zu der Klasse, mit der Implementierung der Ereignisreaktionen nur ein Objekt
benötigt:
class WClose extends WindowAdapter
{ public void windowClosing (WindowEvent e)
{ System.exit (0); }
}
Zufügen eines Listener-Objektes zu einer AWT-Komponente:
f.addWindowListener (new WClose ());
Das läßt sich kompakter formulieren mit einer anonymen Klasse:
Die Klassendeklaration wird mit der new-Operation (für das eine Objekt) kombiniert:
f.addWindowListener
( new WindowAdapter ()
{ public void windowClosing (WindowEvent e)
{ System.exit (0); }
}
);
In der new-Operation wird der Name der Oberklasse der deklarierten anonymen Klasse
(hier: WindowAdapter) oder das Interface, das sie implementiert, angegeben!