| www.r-krell.de |
| Webangebot für Schule und Unterricht, Software, Fotovoltaik und mehr |
Willkommen/Übersicht > Informatik > Informatik mit Java -Seite e) > Demonstration mitgelieferter LinADTs
Mit der Java-JDK/SDK (Versionen 1.0 bis 1.4.2) mitgelieferte Lineare Abstrakte Datentypen
(Stack, Vector, ArrayList und LinkedList für Keller, [Schlange,] und Liste)
zum Seitenanfang / zum Seitenende
Aktueller Hinweis: Über die nachfolgend genannten Datentypen hinaus werden mit/seit Java (1.)5 zusätzliche Datenstrukturen ausgeliefert, u.a. auch eine Schlange (Queue). Darüber hinaus gibt es seither die Möglichkeit, alte und neue Datenstrukturen typsicher zu machen, d.h. durch parameterisierte Typangaben so genannte generische Datenstrukturen zu schaffen, die nicht mehr allgemein für Objekte, sondern nur noch für Elemente des angegebenen Typs verwendbar sind. Diese letzte Möglichkeit ist in meinem auf der Seite „Informatik mit Java, Seite e)" erwähnten 39-seitigen Referat „Keller-und-Schlange.pdf" im Anhang 3 mit Beispielen erläutert.
Übersicht und Erläuterungen
Auf der Seite „Informatik mit Java, Teil e)" wurden die linearen abstrakten Datentypen Keller, Schlange und Liste z.T. in verschiedenen Implementationen vorgestellt und verwendet. Dabei wurden dort die von mir bzw. in meinem Unterricht entwickelten Datenstrukturen gezeigt und erläutert.
In den mit Java (bis zur Version 1.4.2) mitgelieferten Bibliotheken sind auch schon gleiche oder ähnliche Strukturen enthalten, deren Verwendung im Folgenden kurz vorgestellt wird. Dabei ist zu beachten, dass früher (in der alten Java-JDK 1.0) nur Stack und Vector (Keller und eine Art dynamische Reihung als Realisierung einer Liste) mitgeliefert wurden. Seit der SDK 1.2 kamen zwei weitere Listenimplementationen dazu (ArrayList und LinkedList), die jetzt neue, polymorphe Methodennamen haben und eigentlich die alten Versionen überflüssig machen. Tatsächlich gibt es die alten Strukturen aber immer noch; sie wurden dabei so erweitert, dass sie auch mit den neuen Methoden(-namen) benutzt werden können.
Wer Applets schreibt (viele Browser sind noch auf dem Stand von Java 1.1.4 oder sogar 1.0.8) oder sich auch an Benutzer mit alten virtuellen Java-Maschinen wendet, darf natürlich nur die alten Strukturen mit den ursprünglichen Methoden verwenden. Bei neueren virtuellen Maschinen oder entsprechendem, extra installiertem neuen Java-Plugin für den Webbrowser können auch die neuen Strukturen und/oder die neuen Methoden für die alten Datentypen Stack und Vector verwendet werden (Letzteres macht allerdings eigentlich wenig Sinn, es sei denn, verschiedene Threads nebenläufiger Prozesse greifen auf die Strukturen zu: die neuen Strukturen sind nicht synchronisiert, und bedürfen zur Synchronisation offenbar noch eines kleinen Tricks, der bei der Verwendung der alten Datentypen überflüssig ist).
Nachstehend gibt es den vollständige Javatext eines Testprogramms sowie den vom Programm erzeugten Ausgabetext. Ein Äquivalent zur sortierten Liste [siehe meine Seite e), Vierter Datentyp] wird nicht vorgestellt, obwohl auch dafür Ähnliches mit Java mitgeliefert wird. Die Elemente/Objekte für sortierte Strukturen müssen mit einem Comparator-Objekt anzuordnen sein oder das Java-Interface Comparable verwenden und den Vergleichsoperator compareTo implementieren [ähnlich dem auf meine Seite e) verwendeten Interface E_ObjektMitOrdnung mit der Methode vergleicheMit, wobei meine Methode allerdings noch die parameter-gesteuerte Auswahl unter verschiedenen Sortierkriterien erlaubt]. Für solche Elemente gibt es dann in Java die sortierte Liste als SortedMap oder - das mehr auf Mengenoperationen ausgelegte - SortedSet, das allerdings keine doppelten Element enthalten darf. Außerdem sind auch Baumimplementationen dieser Strukturen als TreeMap und TreeSet verfügbar. Auf die sortierten Strukturen wird aus Platzgründen hier nicht näher eingegangen. Bei Interesse sollte die API-Dokumentation oder die einschlägige Literatur zu Rate gezogen werden [vgl. auch Hinweise auf die Dokumentation, auf Tutorials und Online-Bücher auf meiner Seite „Informatik mit Java", Teil a)].
Auf zwei inhaltliche Besonderheiten der unten vorgestellten linearen abstrakten Datentypen wird extra hingewiesen:
Alles Weitere ist aus den Kommentaren zum folgenden Testprogramm ersichtlich.
zum Seitenanfang / zum Seitenende
Bildschirmansicht
des Testprogramms, wobei nur ein Teil der Ausgabe sichtbar ist:
Den vollständigen Ausgabetext nach Betätigen aller vier Schaltflächen gibt's als einfache Textdatei in einem eigenen Browserfenster auf der
damit er bei entsprechendem Verkleinern und Übereinander-Anordnen der Browserfenster parallel zum nachstehenden Java-Quelltext gelesen werden kann!
zum Seitenanfang / zum Seitenende
Java-Text
des Demonstrationsprogramms:
1. Klasse „Java_LinADT" mit der Funktionalität
// Demonstration: typischer Gebrauch der mit Java mitgelieferten abstrakten Datentypen
// für Java ab JDK/SDK 1.2 -- R. Krell, 26.7.2004 -- www.r-krell.de
import java.util.*; // In java.util sind die abstrakten Datentypen definiert
// -- und zwar seit SDK 1.2 als Erweiterungen (Erben) des Interfaces Collection
public class Java_LinADT //Demo typischer Operationen auf Vector, Stack, ArrayList und LinkedList
{
public String testeKeller (Stack keller)
{
String aus= "\n_________________________________________\n*** Stack (ab JDK 1.0) ***\n\n"
+ "Der Stack ist der alte und noch gebräuchliche, vom Vector abgeleitete Datentyp für einen Keller\n";
aus = aus + "(Bei neuer JDK bietet sich der Verwendung von LinkedList für den Keller und für die -- sonst nicht extra\n"
+ "implementierte -- Schlange an [in Java gibt's keine Queue]). Aber hier der Stack:\n";
aus = aus + "Anfangs ist der Keller leer: empty = " + keller.empty(); // istLeer
aus = aus + "\nNun werden 10, dann 20, dann 30 und 40 eingefüllt. Dann kommen die obersten beiden Elemente raus,\n";
keller.push (new Double (10)); // rein
keller.push (new Double (20));
keller.push (new Double (30));
keller.push (new Double (40));
aus = aus + "nämlich " + (Double)keller.pop() + " raus und " + (Double)keller.pop() + " raus. "; // raus
aus = aus + "Jetzt steht " + (Double)keller.peek() + " oben!\n"; // zeige
Enumeration en = keller.elements(); // Zusätzliches Objekt, das einen Durchlauf erlaubt - s.u. beim Vektor!
aus = aus + "Keller wird von vorne nach hinten durchlaufen, alle Element werden gezeigt (Interessant: oben=hinten)\n";
while (en.hasMoreElements()) // Gegenteil von istAmEnde
{
aus = aus + " -> "+((Double)en.nextElement());
// next = Kombination aus zeige und weiter (ähnlich wie readObject in/aus einer Datei) -- s. Vektor!
}
aus = aus + "\n\nSeit der JDK/SDK 1.2 stehen aber auch für den Stack die allgemeinen Listenoperationen zur Verfügung:\n";
aus = aus + demonstriereAllgemeineListenoperationen (keller);
return (aus);
}
public String testeVektor (Vector vektor)
{
String aus ="\n_________________________________________\n*** Vektor (ab JDK 1.0) ***\n\n"
+ "Vektor wird mit den Zahlen 0 .. 5 gefüllt\n";
for (int i=0; i<6;i++)
{
vektor.addElement (new Double(i)); // add ohne Index fügt immer hinten an!
}
Enumeration en = vektor.elements(); // Die Enumeration en
ist ein zusätzliches, mit dem Vektor
// verbundenes Objekt, das einen Zeiger auf ein aktuelles Element durch den Vektor steuert.
// Zu Beginn steht der Zeiger auf dem ersten Element; nach jedem Lesen eines Elements durch
// en.nextElement() wird der Zeiger automatisch um ein Element weiter gesetzt.
// Es gibt keinen Befehl "anDenAnfang", stattdessen muss eine neue Enumeration erzeugt
// werden
aus = aus + "Vektor wird von vorne nach hinten durchlaufen, alle Element werden gezeigt:\n";
while (en.hasMoreElements()) // Gegenteil von istAmEnde
{
aus = aus + " -> "+((Double)en.nextElement());
// next = Kombination aus zeige und weiter (ähnlich wie readObject in/aus einer Datei)
// Der Vektor wird dabei nicht verändert, aber der Nachfolger des gerade zurückgegebenen Elements
// wird aktuell (d.h. die Enemeration, die sich die aktuelle Position merkt, wird verändert.
}
aus = aus + "\nVektor wird von hinten nach vorne durchlaufen:\n";
for (int i=vektor.size()-1; i>=0; i--) // jetzt über Index: Enumeration kann nur vor, nicht rückwärts
{ // Enumeration hat nur nextElement, kein previousElement!
aus = aus + " <- "+((Double)vektor.elementAt(i)); // liefert/liest Element mit angegebenem Index
}
aus = aus + "\nEtwas hin und her:\n";
aus = aus + " - Vorderstes Elem. = "+((Double)vektor.firstElement()); //vord. El. (mit Index 0)
//Enumeration trotzdem noch hinten (durch while-Schleife etwas weiter oben. Deshalb neue Enumeration nötig:
en = vektor.elements();
aus = aus + " = "+((Double)en.nextElement());
aus = aus + " -> "+((Double)en.nextElement());
//zurück wieder nur mit Index (s.o.)! Enumeration wird dabei nicht verändert
aus = aus + ", El. #2 = "+((Double)vektor.elementAt(2));
aus = aus + ", El. #5 = "+((Double)vektor.elementAt(5));
aus = aus + ", El. #3 = "+((Double)vektor.elementAt(3))+"\n";
aus = aus + "Neues Element (77.0) eingefügt -- hinten (trotz Enumeration-Stellung)!\n";
vektor.addElement (new Double(77.0)); // addElement hängt immer nur hinten an
aus = aus + "Neues Element (33.2) an der Stelle mit Index #2 eingefügt!\n";
vektor.insertElementAt (new Double(33.2), 2); // Parameterreihenfolge anders als bei Liste!
//insertElementAt setzt neues Element hier an die Stelle mit dem Index 2; bisheriges 2. Element und
// alle folgenden Elemente werden verschoben, d.h. aufwändig je um eine Stelle weiter kopiert!
aus = aus + "Element an der Stelle mit Index #1 gelöscht!\n";
vektor.removeElementAt (1); //löscht das Element mit dem Index 1 aus dem Vektor;
//alle folgende Elemente rücken automatisch vor, d.h. werden aufwändig um je eine Stelle
//nach vorne kopiert, um Lücke zu schließen
aus = aus + " - Letztes Element = "+((Double)vektor.lastElement())+"\n"; // letztes El. zeigen
aus = aus + "Vektor wird von vorne nach hinten durchlaufen, alle Element werden gezeigt:\n";
en = vektor.elements(); // Nochmal eine neue Enumaration: nötig nach Änderung des Vektors
// bzw. seiner Elementzahl und um wieder vorne im Vektor mit dem Durchlauf zu beginnen:
while (en.hasMoreElements()) // Solange noch Elemente aufgezählt werden können
{
aus = aus + " -> "+((Double)en.nextElement());
}
aus = aus + "\nIst das Element 77.0 da? "+vektor.contains(new Double(77))+"\n";
// contains prüft, ob angegebenes Objekt im Vektor vorhanden ist, und liefert true oder false.
// Vorsicht bei komplizierten Inhalten: evtl. werden nur Referenzen, nicht Inhalte verglichen!
aus = aus + "Index des Elements 33.2 ist "+vektor.indexOf(new Double(33.2));
// Das angeg. Objekt wird gesucht und seine Position (Index) im Vektor genannt
aus = aus + ", Index des nicht vorh. Elements 198.67 ist "+vektor.indexOf(new Double(198.67));
// Gibts das gesuchte Element nicht, wird als Index -1 geliefert!
aus = aus + " -- vektor.isEmpty() = "+vektor.isEmpty(); // istLeer
aus = aus + "\n\nSeit der JDK/SDK 1.2 stehen aber auch für den Vektor die allgemeinen Listenoperationen zur Verfügung:\n";
aus = aus + demonstriereAllgemeineListenoperationen (vektor);
aus = aus + "\nAlle Elemente löschen! ";
vektor.clear(); // löscht alle Element aus dem Vektor
aus = aus + " -- vektor.isEmpty() = "+vektor.isEmpty();
return (aus+"\n\n");
}
public String demonstriereAllgemeineListenoperationen (List liste)
{
// List = allgemeines Interface mit Methoden wie isEmpty (istLeer), add (rein), get (zeige)
// und remove (raus), aber auch size (anzahl) und iterator (Definition eines Objektes, das
// einen Durchlauf durch alle Elemente ermöglicht, d.h. praktisch "aktuell" verwaltet).
// Die folgenden Operationen können (ab JDK/SDK 1.2) mit Vektoren, Stacks und mit beiden neuen
// Arten von Listen (nämlich ArrayList und LinkedList) ausgeführt werden:
String aus ="\n*** Allgemeine List-Methoden (ab SDK 1.2) ***\n\nListe wird mit den Zahlen 0 .. 5 gefüllt\n";
for (int i=0; i<6;i++)
{
liste.add (new Double(i)); // add ohne Index fügt immer hinten an!
}
ListIterator it = liste.listIterator(); // Wie bei der Enumeration erlaubt der ListIterator die
// zusätzlich die Verwaltung einer aktuellen Position und damit den schritt- bzw. elementweisen
// Durchlauf durch die Liste, jetzt sogar in beide Richtungen. Außerdem können jetzt auch
// mit dem ListIterator das aktuelle Element der Liste ersetzt oder entfernt werden.
aus = aus + "Liste wird von vorne nach hinten durchlaufen, alle Elemente werden gezeigt:\n";
while (it.hasNext()) // Gegenteil von istAmEnde
{
aus = aus + " -> "+((Double)it.next());
// next = Kombination aus zeige und weiter (ähnlich wie readObject in/aus einer Datei)
}
aus = aus + "\nListe wird von hinten nach vorne durchlaufen:\n";
while (it.hasPrevious())
{
aus = aus + " <- "+((Double)it.previous()); // zeigt aktuelles Element und macht Vorgänger aktuell
}
// jetzt steht der (vm ListIterator it verwaltete) Listenzeiger wieder vorne.
aus = aus + "\nHin und her mit Änderungen:\n";
aus = aus + " -> "+((Double)it.next());
aus = aus + " -> "+((Double)it.next());
aus = aus + " [set(44.4)] ";
it.set (new Double (44.4)); // Achtung: ersetzt aktuelles Element, hier 1.0
aus = aus + " -> "+((Double)it.next());
aus = aus + " <- "+((Double)it.previous());
//zeigt wieder "2.0", weil nach letztem next der Listenzeiger schon auf "2.0" vorgerückt war!
aus = aus + " <- "+((Double)it.previous());
aus = aus + " -> "+((Double)it.next());
aus = aus + " -> "+((Double)it.next());
aus = aus + " [remove()] ";
it.remove (); //entfernt aktuelles Element, ohne es zurück zu geben (Ergebnistyp void)
aus = aus + " -> "+((Double)it.next())+"\n"; //*
aus = aus + " - El. mit Index #4 = "+((Double)liste.get(4))+" ";
// bestimmtes Element der Liste zurückgeben (lesen, ohne Veränderung der liste und
// ohne Veränderung des ListIterators, der seine Position wie in voriger Zeile //* beibehält).
// Diese Suche nach einem Element mit angegebenem Index ist bei der LinkedList aufwändig,
// weil zur Ausführung die Liste offenbar von Anfang an bis zur angegebenen Position durchsucht wird.
// In der ArrayList wird diese Anweisung hingegen schneller ausgeführt.
aus = aus + " - El. mit Index #1 = "+((Double)liste.get(1))+" ";
aus = aus + " - Nächstes Element = "+((Double)it.next())+"\n"; //"4.0" (nach "3.0"),
// dem letzten bei //* mit dem Iterator erreichten Element. liste.get(..) ändert Iterator nicht!
aus = aus + "Neues Element (77.0) wird eingefügt -- hinten (trotz Iterator-Stellung)!\n";
liste.add (new Double(77.0)); // add mit einem Parameter fügt immer hinten an
aus = aus + "Neues Element (33.2) an der Stelle mit Index #2 eingefügt!\n";
liste.add (2, new Double(33.2)); // Achtung: Parameter umgekehrt wie bei vektor.insertElementAt !
// In der LinkedList geht add an einer bestimmten Stelle (=Einfügen eines neuen Elements an einer bel. Position)
// einigermaßen schnell, da zwar die Stelle (wie bei get) gesucht wird, das neue Element aber durch
// "Zeigerverbiegen" und ohne Umkopieren bisheriger Objekte zusätzlich in die LinkedList aufgenommen wird.
// Bei der ArrayList wird zwar die bezeichnete Stelle rascher gefunden, aber
// alle folgende Elemente müssen verschoben werden, d.h. aufwändig um eine Stelle weiter kopiert werden,
// um eine Lücke für das Einfügen zu schaffen!
aus = aus + "Elementzahl und -reihenfolge verändert: Iterator neu auffrischen!\n";
// und zwar durch liste.add oder liste.remove -- bei it.remove oder it.set wird Iterator automatisch aktualisiert
it = liste.listIterator();
aus = aus + "Liste wird von vorne nach hinten durchlaufen, alle Element werden gezeigt:\n";
while (it.hasNext()) // Gegenteil von istAmEnde
{
aus = aus + " -> "+((Double)it.next());
}
aus = aus + "\nIst das Element 77.0 da? "+liste.contains(new Double(77))+"\n"; // enthält
// Vorsicht bei komplizierten Inhalten: evtl. werden nur Referenzen, nicht Inhalte verglichen!
aus = aus + "Index des Elements 33.2 ist "+liste.indexOf(new Double(33.2)); // Index, ggf. -1
aus = aus + " -- liste.isEmpty() = "+liste.isEmpty(); // istLeer
aus = aus + "\nAlle Elemente löschen! ";
liste.clear();
aus = aus + " -- liste.isEmpty() = "+liste.isEmpty();
return (aus+"\n\n");
}
public String testeReihungsListe (ArrayList liste)
{
String aus= "\n_________________________________________\n*** ArrayList (ab SDK 1.2) ***\n\n"
+ "ArrayLists haben gegenüber allgemeinen Listen keine besonderen Zugriffsmethoden.\n";
aus = aus + "Aber die Größe kann beeinflusst werden, um statt langsamem Wachsen beim schrittweisen Aufbau\n";
aus = aus + "durch eine Anfangs-Mindestgröße Zeit-Aufwand zu sparen. \n";
liste.ensureCapacity (100); // schafft direkt Platz für 100 Elemente
aus = aus + demonstriereAllgemeineListenoperationen (liste);
aus = aus + "Ist die Endgröße erreicht, kann unverbrauchter Platz freigegeben werden.\n";
liste.trimToSize(); // reduziert Größe auf tatsächliche Füllung
return (aus);
}
public String testeVerketteteListe (LinkedList liste)
{
// Implementation als doppelt-verkettete Liste;
// kann als Keller, Schlange und als Liste mit weiter und zurück benutzt werden.
String aus= "\n_________________________________________\n*** LinkedList (ab SDK 1.2) ***\n\n"
+ "Zunächst kann die LinkedList alle normalen Listen-Operationen (wie auch Vector und ArrayList),\n"
+ "wobei sich allerdings jeweils der Aufwand auch für gleichnamige Methoden unterscheiden kann:\n";
aus = aus + demonstriereAllgemeineListenoperationen (liste);
aus = aus + "Wegen der Implementation als doppelt-verkettete Liste gibt's aber noch zusätzliche, rasche Zugriffe\n"
+ "aufs erste bzw. letzte Element (wodurch insbes. auch Keller oder Schlange gut mit LinkedLists gehen).\n";
liste.addFirst(new Double(1)); // vorne rein: füge neues Element vorne (am Kopf) an
liste.addFirst(new Double(2));
liste.addFirst(new Double(3));
aus = aus + "Nachdem erst 1, dann 2 und danach 3 vorne angefügt wurden, steht "
+ (Double)liste.getFirst() + " vorne und " + (Double)liste.getLast() + " hinten.\n";
// zeige vorderes Element (am Kopf) bzw. letztes Element (am Schwanz)
aus = aus + "Letztes Element entfernt, nämlich "+liste.removeLast(); // letztes Element hinten raus
liste.addLast(new Double(4)); // hinten rein: füge neues Element hinten (am Schwanz) an
aus = aus + ", und dafür hinten die 4 dazu, ergibt: ";
for (Iterator it = liste.iterator(); it.hasNext() ; ) // Iterator ähnlich ListIterator, aber ohne previous
{
aus = aus + " -> " + (Double)it.next();
}
return (aus + "\n\n");
}
// Hinweis: Neben den hier verwendeten und in ihrem Gebrauch demonstrierten Methoden gibt es u.a. noch eine Methode
// zum Ermitteln des letzten Indexes eines übergebenen Elements (lastIndexOf -- interessant, falls das Element
// mehrfach in der Datenstruktur auftritt, weil indexOf die nur Stelle des ersten Auftretens nennt), Methoden
// zum Einfügen mehrerer Elemente mit einer Anweisung (addAll), zum Entfernen mehrerer Elemente (removeAll),
// zum gleichzeitigen Test auf das Enthaltensein mehrerer Elemente (containsAll), zum Kopieren eines Teils (subList)
// oder der ganzen Struktur in eine andere, gleichartige Struktur (clone) (plus Vergleichsoperator equals),
// sowie Methoden zum Übertragen der Struktur in eine normale Reihung (toArray).
// Für die vollständige Übersicht wird auf die Original-Dokumentation der verwendeten JDK/SDK verwiesen.
}
zum Seitenanfang / zum Seitenende
2. Klasse „Java_LinADT_Oberflaeche" mit der vorstehend abgebildeten grafischen Oberfläche zum Test
// Demonstration: typischer Gebrauch der mit Java mitgelieferten abstrakten Datentypen
- AWT-Oberfläche
// für Java ab JDK/SDK 1.2 -- R. Krell, 26.7.2004 -- www.r-krell.de
import java.awt.*;
import java.awt.event.*;
public class Java_LinADT_Oberflaeche extends Frame
{
TextArea ausgabe = new TextArea("Bitte per Knopfdruck einen der mit Java gelieferten Typen wählen!\n",27,88);
Button knStack, knVector, knArrayList, knLinkedList; // Knöpfe definieren
Java_LinADT fkt = new Java_LinADT();
public void richteFensterEin() // Fenster initalisieren und beschreiben
{
//WindowsListener hinzufügen, damit Schließknopf funktioniert
addWindowListener (
new WindowAdapter ()
{
public void windowClosing (WindowEvent ereignis)
{
setVisible (false);
dispose();
System.exit(0);
}
}
); // runde Klammer vom Windowlistener geschlossen;
setTitle("Test der mit Java mitgelieferten linearen abtrakten Datentypen -- www.r-krell.de"); // Fenster mit Titel versehen
setSize (660,500); // Fenstergröße (Breite und Höhe in Pixeln) festlegen
setLayout (new FlowLayout());
}
public void richteKnöpfeEin()
{
// Knöpfe erzeugen:
knStack = new Button ("Stack");
knVector = new Button ("Vector");
knArrayList = new Button ("ArrayList");
knLinkedList = new Button ("LinkedList");
//Funktion der Knöpfe festlegen:
knStack.addActionListener (
new ActionListener ()
{
public void actionPerformed (ActionEvent e)
{
ausgabe.append(fkt.testeKeller (new Stack()));
}
});
knVector.addActionListener (
new ActionListener ()
{
public void actionPerformed (ActionEvent e)
{
ausgabe.append(fkt.testeVektor (new Vector()));
}
});
knArrayList.addActionListener (
new ActionListener ()
{
public void actionPerformed (ActionEvent e)
{
ausgabe.append(fkt.testeReihungsListe (new ArrayList()));
}
});
knLinkedList.addActionListener (
new ActionListener ()
{
public void actionPerformed (ActionEvent e)
{
ausgabe.append(fkt.testeVerketteteListe (new LinkedList()));
}
});
} // richteKnöpfeEin
public void führeAus ()
{
richteFensterEin();
richteKnöpfeEin();
ausgabe.setEditable(false); // Ausgabe nicht vom Benutzer änderbar
add (knStack);
add (knVector);
add (knArrayList);
add (knLinkedList);
add (ausgabe);
setVisible(true);
}
}
zum Seitenanfang / zum Seitenende
3. Klasse „Java_LinADT_Start" zum Start der Oberfläche und damit des Testprogramms
// Demonstration: typischer Gebrauch der mit Java mitgelieferten abstrakten Datentypen
// für Java ab JDK/SDK 1.2 -- R. Krell, 26.7.2004 -- www.r-krell.de
public class Java_LinADT_Start
{
public static void main (String[] args)
{
Java_LinADT_Oberflaeche test = new Java_LinADT_Oberflaeche();
test.führeAus();
}
}
zurück zur Seite „Informatik mit Java, Teil e)"