Klasse Grundstzliches: Als Klasse wird der Bauplan eines Objektes bezeichnet. Jedes Objekt bedarf eines Bauplans.

Der Bauplan legt die Eigenschaften des Objektes und sein mgliches Verhalten fest. Pakete in Java: In Java knnen Klassen in Pakete strukturiert werden. Nutzung von Klassen: Wenn eine Klasse a in einer anderen Klasse b genutzt werden soll, so muss in der Klasse b die Klasse a bekannt sein. Attribute Grundstzliches: Die Eigenschaften eines Objektes werden in den Attributen des Objektes gespeichert. Entsprechend mssen diese Attribute in der Definition der Klasse deklariert werden. Attribute knnen elementare Datentypen oder Objekte sein. Programmiersprachen erlauben es, zwischen Attributen der Klasse (Klassenattribute) und den Attributen des Objektes (Objektattribute) zu unterscheiden. Klassenattribute sind nur einmal vorhanden. Objektattribute sind fr jedes Objekt von diesem Typ genau einmal vorhanden. Attribute knnen Variable oder Konstante sein. Darber hinaus knnen Variable und Konstante in Methoden einer Klasse eingefhrt werden. Klassenattribute mssen mit dem Schlsselwort static gekennzeichnet werden. Soll ein Attribut auch auerhalb des Paketes verfgbar sein, so ist das Attribut mit dem Schlsselwort public zu kennzeichnen. Soll ein Attribut nur innerhalb der Klasse verfgbar sein, so ist das Attribut mit dem Schlsselwort private zu kennzeichnen. Neben den Schlsselworten public und private kann auch das Schlsselwort protected fr Attribute genutzt werden. Wenn ein Attribut seinen Wert nach der erstmaligen Zuweisung nicht mehr ndern darf, ist es mit dem Schlsselwort final zu kennzeichnen. Zugriff auf Attribute in Java: Der Punkt-Operator ist in Java definiert fr den Zugriff auf Attribute. Wenn ein Klassenattribut angesprochen werden soll, so ist der Name der Klasse anzugeben gefolgt von einem Punkt und dem Namen des Attributes. Wenn ein Objektattribut angesprochen werden soll, so ist der Name der Variablen des Objektes anzugeben gefolgt von einem Punkt und dem Namen des Attributes. Wenn die Objektattribute innerhalb des Objektes selbst gemeint sind, kann in Java das Schlsselwort this genutzt werden. Grundstzliches: Eine Klasse kann genutzt werden, um Objekte zu bilden. Der Programmierer kann mit dem Schlsselwort new Speicherplatz anfordern. Hat eine Referenz den Wert null, so verweist die Referenz auf keinen gltigen Speicherbereich. Methoden Grundstzliches: Methoden dienen dazu, Verhalten zu definieren. Methoden werden benannt. In der objektorientierten Programmierung sind Methoden an die Klasse (Klassenmethode) oder an das Objekt (Objektmethode) gebunden.
1

Dieser Begriff umfasst ihren Namen, die Deklaration ihrer bergabeparameter und die eklaration ihrer ckgabewertes. In den objektorientierten Programmiersprachen haben diejenigen Methoden eine besondere Bedeutung, die bei der Zuweisung von Speicherplatz aufgerufen werden. Diese Methoden heien Konstruktor. Definition einer Methode in Java: Eine Methode in Java muss benannt werden. Ihr Name beginnt mit einem Buchstaben optional gefolgt von Ziffern und Buchstaben. Vor dem Namen muss der Datentyp ihres Rckgabewertes angegeben werden. Konstruktoren in Java: Konstruktoren werden aufgerufen, wenn Speicherplatz fr ein Objekt reserviert wird. Aufgabe eines Konstruktors ist es, Objektattribute mit gltigen Werten zu belegen. Aufruf von Methoden in Java: Methoden werden in Java aufgerufen fr Klassen oder Objekte. Entsprechend ist der Name der Klasse oder der Name des Objektes anzugeben, gefolgt von einem Punkt und dem Namen der Methode, gefolgt von runden Klammern. Die zu bergebenden Parameter werden in die Runden Klammern geschrieben. Grundstzliches: Die Vererbung ist eines der fundamentalen Konzepte der objektorientierten Programmierung. Grundgedanke der Vererbung ist die Unterscheidung zwischen Generalisierung und Spezialisierung. Die Klasse, von der geerbt wird, wird auch als Elternklasse bezeichnet. Die Klasse, die erbt, wird auch als Kindklasse bezeichnet. Kindklassen knnen Elternklassen erweitern und vorhandene Methoden der Elternklasse berschreiben. Eine Elternklasse kann mehrere Kindklassen haben. Wenn eine Klasse eine andere Klasse erweitert, steht hierfr in Java das Schlsselwort extends zur Verfgung. Sichtbarkeit bei der Vererbung in Java: Neben den bereits behandelten Schlsselworten public und private kann fr Attribute die Sichtbarkeit protected angegeben werden. Ein Attribut der Elternklasse ist nur in der Kindklasse sichtbar, wenn die Sichtbarkeit protected gesetzt ist. Analoges gilt fr Methoden. Zugriff auf Attribute und Methoden der Elternklasse in Java: Fr den Zugriff der Kindklasse auf Attribute und Methoden der Elternklasse ist in Java das Schlsselwort super reserviert. In Java besteht die Mglichkeit, eine Elternklasse so zu konzipieren, dass nur ihre Unterklassen genutzt werden knnen. Das Schlsselwort abstract ist hierfr reserviert. Wrapper-Klassen: In Java sind Klassen fr alle elementaren Datentypen implementiert. Diese Klassen knnen genutzt werden, um Objekte zu bilden. Boolean boolean Integer int Long long Character char Float float Double double

Zeichenketten in Java: In Java beginnt eine Zeichenkette mit dem doppelten Hochkomma und sie endet mit dem doppelten Hochkomma. In Java ist die Klasse String fr Zeichenketten implementiert. main() in Java: Die Methode, mit deren Aufruf die Ausfhrung eines Programms in Java beginnt, heit main(). Sie verfgt ber folgende Signatur: public static void main(String[] args) Die Methode ist ffentlich. Es ist eine Klassenmethode. Sie hat keinen Rckgabewert. Ihr bergabeparameter ist die Referenz auf ein eindimensionales Feld von Zeichenketten. Behandlung von Ausnahmen Die Schlsselworte throws und throw sind fr das Werfen eines Objektes in Java reserviert. Die Schlsselworte try und catch sind fr das Fangen eines Objektes in Java reserviert. Eine Ausnahme bildet die Klasse RuntimeException. Schnittstelle: Der Begriff Schnittstelle (engl.: Interface) wird in den Technikwissenschaften in unterschiedlichen Zusammenhngen verwendet. Werden Schnittstellen zwischen den verschiedenen Komponenten eines technischen Systems vereinbart, so kann die Fertigung der einzelnen Komponenten dezentral erfolgen. Definition einer Schnittstelle: Das Schlsselwort interface steht in Java fr die Definition einer Schnittstelle zur Verfgung. Die Methoden der Schnittstelle sind ffentlich (public), auch wenn dies nicht explizit angegeben wird. Schnittstellen werden oft durch eine Namenskonvention mit einem vorausgehenden "I" gekennzeichnet, um die Verwechselung mit einer gleichnamigen Klasse zu vermeiden. Eine Schnittstelle kann eine vorhandene Schnittstelle erweitern. Das Konzept der Vererbung ist fr Schnittstellen anwendbar. Implementierung einer Schnittstelle: Das Schlsselwort implements steht zur Verfgung, um die Implementierung einer Schnittstelle anzuzeigen. Nutzung einer Schnittstelle: Objekte von Klassen, die eine Schnittstelle implementieren, knnen ber die Schnittstelle angesprochen werden. Variable vom Typ einer Schnittstelle knnen angelegt werden. Diese Variablen werden analog zu Variablen fr Objekte deklariert. Einer Variablen vom Typ einer Schnittstelle kann ein Objekt einer Klasse zugewiesen werden, das diese Schnittstelle implementiert. Danach knnen die Methoden, die in der Schnittstelle deklariert sind, fr dieses Objekt ber die Variable vom Typ der Schnittstelle aufgerufen werden. Hierbei gelten analog alle Regeln, die fr Objektmethoden gelten. Speicherstrukturen 7.1 Einfhrung Eine Datenstruktur kann entwickelt werden, um eine endliche Anzahl von Variablen zu verwalten und den Zugriff auf diese verwalteten Variablen zu gewhrleisten. Datenstrukturen mit der Aufgabe der Verwaltung von Variablen werden auch als Speicherstrukturen bezeichnet. Statische Speicherstrukturen sind dadurch gekennzeichnet, dass die Anzahl der zu verwaltenden Variablen bei ihrer Erzeugung vorgegeben wird. Diese Anzahl ist dann nicht
3

mehr vernderlich. Im Gegensatz hierzu knnen dynamisch Speicherstrukturen eine variable Anzahl von Variablen verwalten. Feld: Der Begriff Feld bezeichnet in Programmiersprachen statische Speicherstrukturen fr Folgen. Die Elemente eines Feldes werden sequentiell hintereinander im Speicher des Rechners abgelegt. Felder knnen mehrdimensional sein. 1. Im ersten Schritt muss eine Variable fr das 1-dimensionale Feld deklariert werden. 2. Im zweiten Schritt muss Speicherplatz fr die Elemente des Feldes angefordert werden. Hierbei muss angegeben werden, von welchem Typ die Elemente sind und fr wie viele Elemente Speicher bereitgestellt werden soll. Wo der angeforderte Speicherplatz im Arbeitsspeicher zu finden ist, ist in der Variablen fr das Feld zu speichern. 1. Im ersten Schritt ist eine Variable fr das 2-dimensionale Feld zu deklarieren. 2. Im zweiten Schritt ist Speicher fr Variable der 1-dimensionalen Felder anzufordern. Hierbei ist anzugeben, wie viele 1-dimensionale Felder bentigt werden. 3. Fr jedes 1-dimensionale Feld ist der Speicherplatz fr die Elemente anzufordern. Hierbei ist es nicht zwingend, dass alle 1-dimensionalen Felder dieselbe Lnge haben. Zugriff auf Elemente in Feldern: Basierend auf dem Konzept, wie mehrdimensionale Felder auf den eindimensionalen Speicher des Rechners abgebildet werden, ist der Zugriff auf die einzelnen Elemente festgelegt. In den Programmiersprachen stehen hierfr Operatoren zur Verfgung. Dies sind in der Regel Klammern. In den Klammern ist anzugeben, welches Element gemeint ist. Felder in Java 1-dimensionales Feld: Eine Variable fr ein 1-dimensionales Feld wird in Java wie folgt deklariert: Datentyp[] Name; Name = new Datentyp[Anzahl]; Wenn beispielsweise auf ein Element eines Feldes zugegriffen werden soll, das nicht Bestandteil des Feldes ist, so wirft Java eine Ausnahme vom Typ ArrayIndexOutOfBoundsException. Diese Ausnahme muss nicht gefangen werden. Sie ist abgeleitet von der Klasse RuntimeException. Eine RuntimeException muss nicht explizit gefangen werden. 2-dimensionales Feld: Eine Variable fr ein 2-dimensionales Feld wird in Java wie folgt deklariert: Datentyp [][] Name; Dynamische Speicherstrukturen fr Folgen Im Wesentlichen sind dann vier Schritte auszufhren: 1. Ein neues Feld ist anzulegen, das die vorhandenen und die neu einzufgenden Elemente aufnehmen kann. 2. Die vorhandenen Elemente werden in das neue Feld bis zu der Stelle bertragen, an der neue Elemente einzufgen sind. 3. Die neu einzufgenden Elemente werden in das neu angelegte Feld eingetragen. 4. Das neu angelegte Feld wird aufgefllt mit den noch einzutragenden Elementen aus dem ursprnglichen Feld.
4

Verkettete Listen knnen so gebaut werden, dass jedes Element der Liste ausschlielich seinen Nachfolger kennt. Die Liste kann dann in einer Richtung von Vorne nach Hinten durchlaufen werden. Man spricht in diesem Zusammenhang von einfach verketteten Listen. Verkettete Listen knnen auch so gebaut werden, dass jedes Element der Liste sowohl seinen Nachfolger als auch seinen Vorgnger kennt. Bei derartigen verketteten Listen spricht man von doppelt verketteter Liste. Doppelt verkettete Listen knnen in beide Richtungen von Vorne nach Hinten und von Hinten nach Vorne durchlaufen werden. Listenelement: In der einfach verketteten Liste wird als Listenelement eine Datenstruktur gewhlt, in der das Element der Folge und der Nachfolge, also der Verweis auf das nchste Listenelement gespeichert werden. Fr den Zugriff auf das Element der Folge wird dabei in der Regel die Referenz auf das Element der Folge gespeichert. Ein Listenelement besteht somit aus der Referenz auf das Element der Folge und aus der Referenz das nchste Listenelement. Das Prinzip des Listenelements der einfach verketteten Liste ist in Bild 7.6 dargestellt. Liste: Eine Liste besteht aus verknpften Listenelementen. Fr den Einstig in die einfach verkettete Liste ist dann die Referenz auf das erste Listenelement erforderlich. Ist die Liste leer, so verweist diese Referenz auf kein Listenelement. Das Ende der Liste wird dadurch kenntlich gemacht, dass ein Listenelement keinen Nachfolger hat, also als Referenz ein Sonderzeichen eingetragen ist und nicht eine gltige Adresse im Speicher des Rechners. Das Listenelement ohne Nachfolger ist das letzte Element der Liste. Bearbeitung: Fr die Bearbeitung der Elemente sind Funktionalitten erforderlich. Drei Grundfunktionalitten werden bentigt: Eintragen eines Elementes Austragen eines Elementes Holen eines Elementes Das Eintragen eines Elementes kann im einfachsten Fall so erfolgen, dass jedes einzutragende Element an die erste Stelle eingetragen wird. In diesem Fall muss die Liste nicht durchlaufen werden. Analog kann das Austragen eines Elementes konzipiert werden. Wenn eine Stelle angegeben wird, an der ein Element eingetragen oder ausgetragen werden kann, so muss innerhalb der Liste zu diesem Element gegangen werden. Hierzu ist es zweckmig, jeweils vom ersten Element zu beginnen und entsprechend so oft zum nachfolgenden Element zu gehen, bis das ein- bzw. auszutragende Element erreicht ist. Das Konzept, innerhalb der Liste die Liste zu durchlaufen, ist beim Holen eines Elementes unzweckmig, da in diesem Fall die Liste immer von vorne beginnend zu durchlaufen wre. Es ist in diesem Fall zweckmig, ein eigenstndiges Objekt zu konstruieren, das die aktuelle Position in der Liste speichert und wie Methoden zur Verfgung stellt, eine Methode zum Prfen, ob ein nchstes Element existiert, und eine Methode, die das nchste Element aus der Liste zurckgibt und hierbei intern die aktuelle Position um Eins verschiebt. Dieses Konzept wird auch als Iterator-Konzept bezeichnet und ist allgemein anwendbar fr Speicherstrukturen.
5

Die Anwendung des Iterator-Konzeptes ermglicht es, parallel mit mehreren Iteratoren die jeweilige Speicherstruktur zu durchlaufen. Die Iteratoren selbst beeinflussen sich nicht gegenseitig. Die Nutzung der Iteratoren fhrt zu Problemen, wenn die Speicherstruktur durch das Einfgen eines neuen Elementes oder das Austragen eines vorhandenen Elementes verndert wird. Implementierung einer einfach verketteten Liste Umfang der Implementierung: Gezeigt ist eine einfache Implementierung einer einfach verketteten Liste. Listenelement: Das Listenelement ist eine Datenstruktur bestehend aus zwei Referenzen. Die Implementierung sieht wie folgt aus: package verketteteListe; /* * Ein Listenelement fuer eine einfach verkettete Liste. */ class EinfachVerkettetesListenElement { // das zu verwaltende Objekt Object o; // das naechste Listenelement EinfachVerkettetesListenElement nachfolger; } Die Implementierung des Iterators wird ebenso wie die Implementierung der Ausnahmen nach der Implementierung der Liste gezeigt. package verketteteListe; /* * Eine einfach verkettete Liste. */ public class EinfachVerketteteListe { // das erste Element der Liste, wenn die Liste leer ist verweist es auf null private EinfachVerkettetesListenElement erster; /* * Erstellt eine leere Liste */ public EinfachVerketteteListe() { erster = null; } /* * Fuege das Objekt am Anfang ein */ public void fuegeAmAnfangEin(Object o) throws FehlerBeimZugriff {
6

if (o == null) { throw new FehlerBeimZugriff( "Einfuegen: Kein Objekt uebergeben!"); } // erzeuge ein neues Listenelement EinfachVerkettetesListenElement neu = new EinfachVerkettetesListenElement(); // Setze das Objekt neu.o = o; // Baue das Elemente an den ersten Platz neu.nachfolger = erster; erster = neu; } /* * Trage das Objekt an Stelle i aus. Fuer das erste Element gilt i = 0. */ public Object trageAus(int i) throws FehlerBeimZugriff { // wenn i kleiner 0 ist if (i < 0) { throw new FehlerBeimZugriff( "Die Position muss positiv einschlielich Null sein!"); } // Merke den Vorgaenger EinfachVerkettetesListenElement vorgaenger = null; // beginne von vorne EinfachVerkettetesListenElement aktueller = erster; // gehe i-mal zum Naechsten for (int j = 0; j < i; j++) { if (aktueller == null) { throw new FehlerBeimZugriff("Austragen: Stelle " + i + " existiert nicht!"); } vorgaenger = aktueller; aktueller = aktueller.nachfolger; } // pruefe, ob aktueller exisitert if (aktueller == null) { throw new FehlerBeimZugriff("Austragen: Stelle " + i + " existiert nicht!"); } // Baue das aktuelle Listenelement aus
7

Object o = aktueller.o; // wenn das erste Listenelement auszubauen ist if (aktueller == erster) { erster = aktueller.nachfolger; } // wenn ein Listenelement auszubauen ist else { vorgaenger.nachfolger = aktueller.nachfolger; } // setze den Nachfolger des ausgebauten Listenelements auf null aktueller.nachfolger = null; return o; } /* * Hole einen Iterator */ public ListenIterator iterator(){ return new ListenIteratorEinfachVerketteteListe(erster); } } Zum Durchlaufen der Liste wird die Schnittstelle ListenIterator genutzt. Diese Schnittstelle stelle zwei Methoden bereit: package verketteteListe; /* * Schnittstelle zum Durchlaufen einer Liste. */ public interface ListenIterator { /* * Untersucht, ob noch ein Element verfuegbar ist. */ public boolean hatNaechsten(); /* * Holt das naechste Element und geht intern zu dem danach folgenden Element. */ public Object naechsten(); } Die Schnittstelle ListenIterator wird durch die Klasse ListenIteratorEinfachVerketteteListe implementiert:
8

package verketteteListe; /* * Implementierung eines Listen-Iterators fuer eine einfach verkettete Liste */ public class ListenIteratorEinfachVerketteteListe implements ListenIterator { // das aktuelle Element wird gespeichert private EinfachVerkettetesListenElement aktueller; /* * Erzeuge einen Listeniterator fuer eine einfach verkettete Liste */ protected ListenIteratorEinfachVerketteteListe( EinfachVerkettetesListenElement erster) { aktueller = erster; } /* * Pruefe, on ein naechstes Objekt exisitiert */ public boolean hatNaechsten() { // Naechster nicht mehr verfuegbar, wenn Aktueller auf null verweist if (aktueller == null) { return false; } return true; } /* * Hole Naechsten und verschiebe Aktuellen um einen weiter. */ public Object naechsten() throws FehlerBeimZugriff { if (aktueller == null) { throw new FehlerBeimZugriff("Kein Objekt mehr vorhanden!"); } // hole das Objekt Object o = aktueller.o; // setze Aktuellen auf seinen Nachfolger aktueller = aktueller.nachfolger; // gib das Objekt zurueck return o; }
9

} Doppelt verkettete Liste Listenelement: In der doppelt verketteten Liste wird als Listenelement eine Datenstruktur gewhlt, in der das Element der Folge, das nachfolgende Listenelement und das vorangehende Listenelement gespeichert werden. In den Implementierungen werden hierfr in der Regel Referenzen gespeichert. Liste: Eine Liste besteht aus verknpften Listenelementen. Fr den Einstieg in eine doppelt verkettete Liste werden Referenzen auf das erste und das letzte Listenelement bentigt. Dies kann durch ein besonderes Listenelement realisiert werden, das auf kein Element der Folge verweist. Ein derartiges Listenelement wird auch als Wurzel bezeichnet. Die Wurzel verweist auf das erste Listenelement und das letzte Listenelement. Ist die Liste leer, dann verweist die Wurzel auf sich selbst. Beginnend mit der Wurzel kann die Liste von Vorne nach Hinten und von Hinten nach Vorne durchlaufen werden. Bearbeitung: Fr die Bearbeitung der Elemente sind Funktionalitten erforderlich. Ebenso wie bei der einfach verketteten Liste werden drei Grundfunktionalitten bentigt: Eintragen eines Elementes Austragen eines Elementes Holen eines Elementes Implementierung einer doppelt verketteten Liste Umfang der Implementierung: Gezeigt ist eine einfache Implementierung einer doppelt verketteten Liste. Listenelement: Das Listenelement ist eine Datenstruktur bestehend aus drei Referenzen. Die Implementierung sieht wie folgt aus: package verketteteListe; /* * Ein Listenelement fuer eine doppelt verkettete Liste. */ class DoppeltVerkettetesListenElement { // das zu verwaltende Objekt Object o; // Vorgaenger und Nachfolger DoppeltVerkettetesListenElement vorgaenger; DoppeltVerkettetesListenElement nachfolger; } Implementierung: Die Implementierung der doppelt verketteten Liste umfasst Methoden fr das Eintragen und das Austragen. Das Eintragen eines Elementes kann nur vorne oder hinten erfolgen. Beim Austragen wird innerhalb der Liste an die Stelle gelaufen, an der das Element
10

auszutragen ist. Hierbei kann die Liste entweder von Vorne nach Hinten oder von Hinten nach Vorne durchlaufen werden. Fr die Bearbeitung der Elemente der Liste ist das IteratorKonzept umgesetzt. Eine Methode gibt ein Objekt zurck, das die Schnittstelle ListenIterator implementiert. Die Schnittstelle ListenIterator ist bereits bei der Implementierung der einfach verketteten Liste vorgestellt worden. Die Implementierung der Klasse ListenIteratorDoppeltVerketteteListe, die diese Schnittstelle implementiert, ist im Anschluss an die Implementierung der Klasse DoppeltVerketteteListe gezeigt. package verketteteListe; /* * Eine doppelt verkettete Liste. */ public class DoppeltVerketteteListe { // in der Wurzel werden das erste und das letzte Element gespeichert private DoppeltVerkettetesListenElement wurzel; /* * Erstellt eine leere Liste */ public DoppeltVerketteteListe() { wurzel = new DoppeltVerkettetesListenElement(); wurzel.nachfolger = wurzel; wurzel.vorgaenger = wurzel; } /* * Fuege am Anfang ein Element ein. */ public void fuegeEinAmAnfang(Object o) throws FehlerBeimZugriff { if (o == null) { throw new FehlerBeimZugriff("Einfuegen: Kein Objekt uebergeben!"); } // erzeuge ein neues Listenelement DoppeltVerkettetesListenElement e = new DoppeltVerkettetesListenElement(); // Setze das Objekt e.o = o; // Baue das Elemente an den ersten Platz e.nachfolger = wurzel.nachfolger; e.vorgaenger = wurzel;
11

wurzel.nachfolger = e; e.nachfolger.vorgaenger = e; } /* * Fuege am Ende ein Element ein. */ public void fuegeEinAmEnde(Object o) throws FehlerBeimZugriff { if (o == null) { throw new FehlerBeimZugriff("Einfuegen: Kein Objekt uebergeben!"); } // erzeuge ein neues Listenelement DoppeltVerkettetesListenElement e = new DoppeltVerkettetesListenElement(); // Setze das Objekt e.o = o; // Baue das Elemente an den letzen Platz e.nachfolger = wurzel; e.vorgaenger = wurzel.vorgaenger; wurzel.vorgaenger.nachfolger = e; wurzel.vorgaenger = e; } /* * Trage das Element i von vorne aus. Fuer das erste Element gilt i = 0. Der * Aktuelle wird nach erfolgreichem Austragen um einen weiter nach hinten * verschoben. */ public Object trageAusVonVorne(int i) throws FehlerBeimZugriff { // wenn die Liste leer ist if (wurzel.vorgaenger == wurzel) { throw new FehlerBeimZugriff("Austragen: Liste ist leer!"); } // wenn i kleiner 0 ist if (i < 0) { throw new FehlerBeimZugriff( "Die Position muss positiv einschlielich Null sein!"); } // Aktueller ist Wurzel DoppeltVerkettetesListenElement aktueller = wurzel;
12

// Schleife ueber alle Elemente bis i einschliesslich for (int j = 0; j <= i; j++) { // Aktueller ist Nachfolger von Aktueller aktueller = aktueller.nachfolger; // wenn wieder die Wurzel erreicht wurde if (aktueller == wurzel) { throw new FehlerBeimZugriff("Austragen: Stelle " + i + " existiert nicht!"); } } // Hole das Objekt Object o = aktueller.o; // Baue das Listenelement Aktueller aus aktueller.vorgaenger.nachfolger = aktueller.nachfolger; aktueller.nachfolger.vorgaenger = aktueller.vorgaenger; // setze Vorgenger und Nachfolger vom Aktuellen auf null aktueller.vorgaenger = null; aktueller.nachfolger = null; // gib das Objekt zurueck return o; } /* * Trage das Element i von hinten aus. Fuer das erste Element gilt i = 0. Der * Aktuelle wir nach erfolgreichem Austragen um einen weiter nach vorne * verschoben. */ public Object trageAusVonHinten(int i) throws FehlerBeimZugriff { // wenn die Liste leer ist if (wurzel.vorgaenger == wurzel) { throw new FehlerBeimZugriff("Austragen: Liste ist leer!"); } // wenn i kleiner 0 ist if (i < 0) { throw new FehlerBeimZugriff( "Die Position muss positiv einschlielich Null sein!"); } // Aktueller ist Wurzel DoppeltVerkettetesListenElement aktueller = wurzel; // Schleife ueber alle Elemente bis i einschliesslich
13

for (int j = 0; j <= i; j++) { // Aktueller ist Vorgaenger von Aktueller aktueller = aktueller.vorgaenger; // wenn wieder die Wurzel erreicht wurde if (aktueller == wurzel) { throw new FehlerBeimZugriff("Austragen: Stelle " + i + " existiert nicht!"); } } // Hole das Objekt Object o = aktueller.o; // Baue das Listenelement Aktueller aus aktueller.vorgaenger.nachfolger = aktueller.nachfolger; aktueller.nachfolger.vorgaenger = aktueller.vorgaenger; // setze Vorgenger und Nachfolger vom Aktuellen auf null aktueller.vorgaenger = null; aktueller.nachfolger = null; // gib das Objekt zurueck return o; } /* * Hole einen Iterator */ public ListenIterator iterator() { return new ListenIteratorDoppeltVerketteteListe(wurzel); } } Die Klasse ListenIteratorDoppeltVerketteteListe implementiert die Schnittstelle ListenIterator: package verketteteListe; /* * Implementierung eines Listen-Iterators fuer eine doppelt verkettete Liste */ public class ListenIteratorDoppeltVerketteteListe implements ListenIterator { // die Wurzel der Liste private DoppeltVerkettetesListenElement wurzel; // das aktuelle Element wird gespeichert private DoppeltVerkettetesListenElement aktueller;
14

/* * Erzeuge einen Listeniterator fuer eine doppelt verkettete Liste */ protected ListenIteratorDoppeltVerketteteListe( DoppeltVerkettetesListenElement wurzel) { this.wurzel = wurzel; this.aktueller = wurzel; } /* * Pruefe, ob ein Nachfolger exisitiert */ public boolean hatNaechsten() { // Nachfolger nicht mehr verfuegbar, wenn der Nachfolger die Wurzel ist if (aktueller.nachfolger == wurzel) { return false; } return true; } /* * Hole Nachfolger und verschiebe Aktuellen um einen weiter in Richtung * Nachfolger. */ public Object naechsten() throws FehlerBeimZugriff { // setze Aktuellen auf seinen Nachfolger aktueller = aktueller.nachfolger; // Fehler: kein Objekt vorhanden if (aktueller.o == null) { // setze den aktuellen zurueck aktueller = aktueller.vorgaenger; throw new FehlerBeimZugriff("Kein Objekt mehr vorhanden!"); } // gib das Objekt zurueck return aktueller.o; } } Sortieren und Suchen R := { (a,b) A B | aRb } M gilt aRa
15

identiv: fr alle a,b M mit aRb und bRa folgt a=b transitiv: fr alle a,b,c M gilt: aus aRb und bRc folgt aRc irreflexiv: es gibt kein aRa asymmetrisch: es gibt keine Elemente a,b mit aRb und bRa linear: fr alle a,b konnex: fr alle a,b M gilt: aRb oder bRa M folgt aus a b: aRb oder bRa

Bearbeitung einer Menge von Objekten: Eine Ordnungsrelation kann genutzt werden, um Elemente einer Menge mit einem geringeren Aufwand als dem beim sequentiellen Durchsuchen finden zu knnen. Voraussetzung ist, dass eine Ordnungsrelation existiert und dass die Objekte der Menge entsprechend dieser Ordnungsrelation in Speicherstrukturen abgelegt sind. Abbildung von Objekten auf Gleitkommazahlen Schnittstelle: Eine Schnittstelle wird eingefhrt. Diese Schnittstelle enthlt eine Objektmethode. In dieser Methode ist ein Algorithmus zu implementieren, der aus den Attributen des Objektes eine Zahl vom Typ double berechnet. Die Schnittstelle ist im Folgenden gezeigt. package ordnung; /* * Schnittstelle zur Abbildung von Objekten auf eine Zahl vom Typ double. * Objekte, die diese Schnittstelle implementieren, sind vergleichbar. */ public interface IAbbildungAufDouble { /* * Methode zur Berechnung einer Zahl vom Typ double aus den Attributen des * jeweiligen Objektes. Der Rueckgabewert ist die berechnete Zahl. */ public double bildeAbAufDouble(); } Vergleich: Der Vergleich ist in einer Klassenmethode der Klasse Vergleich implementiert.Werden zwei Objekte verglichen, so werden fr beide Objekte zuerst die Gleitkommazahlen berechnet. Diese Zahlen werden gerundet. Der Vergleich der gerundeten Zahlen kann zu drei Ergebnissen fhren. Der Rckgabewert der Methode ist entsprechend des Ergebnisses unterschiedlich: 1. Objekt 1 > Objekt 2: Rckgabewert ist grer Null 2. Objekt 1 < Objekt 2: Rckgabewert ist kleiner Null 3. Objekt 1 = Objekt 2: Rckgabewert ist gleich Null Neben der Methode zum Vergleichen von zwei Objekten ist eine weitere Methode
16

reflexiv: fr alle a

implementiert, mit deren Hilfe ein Objekt mit einer Zahl verglichen werden kann. Analog zum Vergleich von zwei Objekten liefert auch diese Methode fr die drei verschiedenen Ergebnisse des Vergleichs einen unterschiedlichen Rckgabewert: 1. Objekt > Zahl: Rckgabewert ist grer Null 2. Objekt < Zahl: Rckgabewert ist kleiner Null 3. Objekt = Zahl: Rckgabewert ist gleich Null Bubble-Sort Art der Sortierung: Der in der Literatur unter dem Namen Bubble-Sort behandelte Algorithmus wird vorgestellt. Dieser Algorithmus kann die Objekte in einem Feld so sortieren, dass sie entweder aufsteigend oder absteigend im Feld abgelegt sind. Algorithmus: Der Algorithmus basiert auf der berlegung, ein unsortiertes Feld mit n Objekten von vorne nach hinten zu durchlaufen. Die ersten beiden Objekte werden verglichen. Wenn das erste Objekt grer ist als das zweite, werden die beiden Objekte vertauscht, sodass nun das ursprnglich erste Objekt an zweiter Stelle abgelegt ist. Nun wird das an der zweiten Stelle abgelegte Objekt mit dem an der dritten Stelle abgelegten Objekt verglichen. Wenn das an der zweiten Stelle abgelegte Objekt grer ist als das an der dritten Stelle abgelegte, werden beide Objekte vertauscht. Nun ist an dritter Stelle im Feld ein Objekt gespeichert, dass grer ist als die Objekte, die vor ihm abgelegt sind. Das Feld wird bis zum Ende nach diesem Prinzip durchlaufen. Nun ist sichergestellt, dass im Feld kein greres Objekt als das Objekt an der letzten Stelle abgelegt ist. Das Feld besteht nun aus zwei Teilen, einem unsortierten Bereich der Lnge n-1 und einem sortierten Bereich der Lnge 1. Es ist sichergestellt, dass im unsortieren Bereich kein greres Objekt abgelegt ist als im sortierten Bereich. Der unsortierte Bereich des Feldes wird erneut von vorne nach hinten durchlaufen. Das oben beschriebene Vorgehen, zwei Objekte zu vergleichen, wird erneut angewendet. Bei Bedarf werden die Objekte vertauscht. Ist der unsortiere Bereich durchlaufen, so besteht das Feld nun aus einem unsortieren Bereich, der um 1 kleiner geworden ist, und einem sortieren Bereich, der um 1 grer geworden ist. Dieses Vorgehen wird wiederholt, bis kein unsortierter Bereich mehr existiert. Implementierung des Bubble-Sort-Algorithmus: Im Folgenden ist eine Implementierung des Bubble-Sort-Algorithmus gezeigt. Die Methode ist eine statische Methode der Klasse sortierenUndSuchen.SortierenEinesFeldes. Ihr wird ein Feld von Objekten bergeben, die die Schnittstelle IAbbildungAufDouble implementieren. public static void bubbleSort(IAbbildungAufDouble[] objekte) { // Anzahl Objekte int n = objekte.length; // Schleife ueber alle Objekte while (n > 0) { // Schleife ueber den unsortierten Bereich for (int i = 0; i < n - 1; i++) {
17

// wenn objekte[i] groesser ist als objekte[i+1] if (Vergleich.vergleiche(objekte[i], objekte[i + 1]) > 0) { // tausche objekte[i] und objekte[i+1] IAbbildungAufDouble merke = objekte[i]; objekte[i] = objekte[i + 1]; objekte[i + 1] = merke; } } /* * das groesste Objekt ist nun an der letzen Position des unsortierten * Bereichs, der unsortierte Bereich wird um 1 verkleinert */ n--; } } Quicksort Ausgangssituation: Wie beim Bubble-Sort sind auch hier die Referenzen der zu sortierenden Objekte in einem Feld gespeichert. Die Objekte sind vergleichbar. Es existiert eine Ordnungsrelation. Art der Sortierung: Der Algorithmus Quicksort kann ein Feld von Objekten entweder so sortieren, dass die Objekte aufsteigend angeordnet sind, oder so, dass die Objekte absteigend angeordnet sind. Algorithmus: Betrachtet wird ein unsortiertes Feld. Aus diesem Feld wird ein Objekt gewhlt, das Vergleichsobjekt v. Das Vergleichsobjekt ist beispielsweise das Objekt, das in der Mitte des Feldes abgelegt ist. Die Objekte des Feldes werden so umsortiert, dass sich zwei berschneidungsfreie Bereiche Links und Rechts ergeben, wobei gilt: Alle Objekte im Bereich Links sind kleiner oder gleich v. Alle Objekte im Bereich Rechts sind grer oder gleich v. Fr die beiden Bereiche Links und Rechts wird derselbe Algorithmus erneut durchgefhrt, wenn der zu untersuchende Bereich mehr als ein Element hat.

18

wenn mglich verkleinert. Wenn sich die beiden Bereiche berschneiden, wird erneut

Danach werden Bereiche des Feldes betrachtet. Jeder Bereich ist durch einen Start und ein Ende eindeutig beschrieben. Die Betrachtung des ganzen Feldes ist ein Sonderfall der Betrachtung eines Bereichs des Feldes, bei dem der Start durch den Wert 0 und das Ende durch den Wert Anzahl der Elemente des Feldes minus 1 beschrieben wird. Zur Beschreibung eines Bereichs des Feldes werden die Variablen start und ende eingefhrt. Das Umsortieren eines Bereichs des Feldes in zwei Bereiche Links und Rechts mit den oben beschriebenen Eigenschaften wird im Folgenden beschrieben. Es werden zwei weitere Variable eingefhrt. Mit der Variablen startRechts wird schrittweise der Beginn von Rechts berechnet, also der Beginn des Bereichs, in dem nur Objekte v abgelegt werden. Mit der Variablen endeLinks wird schrittweise das Ende von Links berechnet, also das Ende des Bereichs, in dem nur Objekte mit v Objekt abgelegt werden. Die Variable startRechts wird mit dem Beginn des Feldes, dem Wert der Variablen start vorbelegt. Die Variable endeLinks wird mit dem Ende des Feldes, dem Wert der Variablen ende vorbelegt. Der Bereich Rechts wird betrachtet. In einer Schleife wird geprft, ob gilt v Objekt[startRechts] und noch nicht das Ende des zu sortierenden Bereichs erreicht ist. Wenn beide Aussagen wahr sind, wird der Wert von startRechts um 1 erhht und die Schleife erneut durchlaufen. Wenn sich die so gebildeten Bereiche Links und Rechts berschneiden, tauschen die Objekte an den Stellen startRechts und endeLinks ihren Platz. Der Wert der Variablen startRechts wird um 1 erhht, der Wert von endeLinks wird um 1 verringert. Es wird geprft, ob der berechnete Start von Rechts kleiner ist als das berechnete Ende von Links. Ist dies der Fall, so sind die Bereichsgrenzen noch nicht endgltig berechnet. Der Bereich Rechts wird erneut betrachtet. Es wird erneut versucht, den Beginn dieses Bereichs nach hinten zu verschieben, solange fr jedes Objekt gilt v Objekt[startRechts] und noch nicht das Ende des Feldes erreicht ist. Anschlieend wird der Bereich Links betrachtet und

etauscht, usw. Suchen in einem Feld Ausgangssituation: Betrachtet wird ein Feld von Objekten. Die Objekte sind abgebildet auf Gleitkommazahlen. Damit existiert eine Ordnungsrelation. Das Feld ist sortiert. Die Objekte sind aufsteigend im Feld abgelegt. Gegeben ist eine Zahl. Das Objekt, das auf diese Zahl abgebildet ist, ist zu suchen. Algorithmus: Es wird ein Algorithmus vorgestellt, der ein Objekt im Feld sucht. Der Algorithmus arbeitet nach dem Prinzip der Binrsuche. Das Prinzip der Binrsuche kann angewendet werden fr Felder, in denen Objekte aufsteigend abgelegt sind, und fr Felder, in denen Objekte absteigend abgelegt sind. In einem ersten Schritt wird die Mitte des Feldes bestimmt. Das Objekt in der Mitte des Feldes wird mit der gegebenen Zahl verglichen. Drei Flle knnen unterschieden werden: 1. Das Objekt in der Mitte ist kleiner als die Zahl: In diesem Fall kann das zu suchende Objekt nur rechts der Mitte liegen, da alle Objekte links der Mitte kleiner oder gleich als sind das Objekt in der Mitte.
20

19

2. Das Objekt in der Mitte ist grer als die Zahl: In diesem Fall kann das zu suchende Objekt nur links der Mitte liegen, da alle Objekte links der Mitte grer oder gleich sind als das Objekt in der Mitte. 3. Das Objekt in der Mitte ist gleich der Zahl: Das Objekt ist gefunden.

In einer Implementierung kann die Binrsuche in einer Schleife durchgefhrt werden. Der Bereich, in dem das zu suchende Objekt liegen kann, ist beim ersten Durchlauf der Schleife durch die Startstelle 0 und die Endstelle Anzahl der Objekte 1 gekennzeichnet. In einem Durchlauf der Schleife werden die drei Flle geprft: 1. Im Fall 1 wird der Bereich verkleinert. Der Start ist die Mitte + 1. Das Ende bleibt unverndert. 2. Im Fall 2 wird der Bereich verkleinert. Das Ende ist die Mitte 1. Der Start bleibt unverndert. 3. Im Fall 3 ist das Element gefunden. import ordnung.Vergleich; /* * Klasse zum Suchen in einem sortierten Feld */ public class SuchenImFeld {
21

/* * Methode zum Suchen eines Objektes in einem Feld nach dem Algorithmus der * Binaersuche. Das Feld muss aufsteigend sortiert sein. Wenn das Objekt im * Feld abgelegt ist, wird die Stelle im Feld zurueckgegeben. Wenn das Objekt * nicht im Feld abgelegt ist, wird eine Ausnahme geworfen. */ public static int sucheStelle(double zahl, IAbbildungAufDouble[] objekte) throws AusnahmeBeimSuchen { // die zu besimmende Stelle int stelle; stelle = -1; // -1 bedeutet: kein Objekt gefunden // Variablen zum Suchen im Feld int mitte, start, ende; // Vorbelegung: das ganze Feld wird betrachtet start = 0; ende = objekte.length - 1; // solange ein Bereich zu untersuchen ist und noch kein Element gefunden // wurde while (start <= ende && stelle == -1) { // berechne die Mitte mitte = start + (ende - start) / 2; // wenn das Objekt an der Stelle mitte kleiner ist als die Zahl if (Vergleich.vergleiche(objekte[mitte], zahl) < 0) { // Objekt liegt rechts neben mitte: start wird umgesetzt start = mitte + 1; } // wenn das Objekt groesser ist als die Zahl else if (Vergleich.vergleiche(objekte[mitte], zahl) > 0) { // Objekt liegt links neben mitte: ende wird umgesetzt ende = mitte - 1; } // Gleichheit else { // Objekt ist gefunden stelle = mitte; } } // wenn das Objekt nicht gefunden wurde if (stelle == -1) { throw new AusnahmeBeimSuchen("Objekt nicht gefunden!"); } // die Stelle, an der das Objekt gespeichert ist, wird zurueckgegeben
22

return stelle; } } Bume Grundstzliches: Als dynamische Speicherstruktur zur Verwaltung sortierter Objekte kann ein Baum gewhlt werden.

Ein Knoten bildet die Wurzel des Baums. Die Anwendung referenziert die Wurzel. Die Wurzel hat keinen Knoten des Baums, der auf sie verweist. Jeder andere Knoten des Baums hat genau einen Knoten im Baum, der auf ihn verweist. Man spricht bei den Verweisen zwischen Knoten auch von Eltern-Kind-Verweisen. Die Wurzel hat keinen lternknoten. Alle brigen Knoten im Baum haben einen Elternknoten. Attribute eines Knotens: Drei Attribute werden in der Implementierung der Klasse Knoten eingefhrt: der Verweis auf den Knoten links, der Verweis auf den Knoten rechts und der Verweis auf das Objekt am Knoten. // am Knoten kann verzweigt werden: nach links und rechts private Knoten links; private Knoten rechts; // am Knoten kann ein Objekt gespeichert werden private IAbbildungAufDouble objekt; Der Konstruktor belegt die Attribute vor mit dem Wert null. /* * Konstruktor: der Konstruktor erzeugt einen Knoten, der nicht verzweigt und * kein Objekt traegt. Dieser Knoten kann als Wurzel eines Baums genutzt * werden. */ public Knoten() { links = null; rechts = null; objekt = null; } Aufbau des Baums: Zum Aufbau eines Baums ist ein Knoten erforderlich, die Wurzel. Wird die Wurzel erzeugt, so trgt sie keinen Knoten. Wird das erste Objekt zum Einbauen der Wurzel bergeben, so wird dieses Objekt das Objekt der Wurzel. Wird der Wurzel ein weiteres Objekt zum Einbauen bergeben, so wird dieses Objekt mit dem bereits eingebauten Objekt verglichen. Ist das Objekt am Knoten grer als das einzubauende Objekt, so ist das einzubauende Objekt links vom Knoten einzubauen, im anderen Fall rechts. public void baueEin(IAbbildungAufDouble objekt) {
23

// der Knoten ist leer if (this.objekt == null) { // das Objekt wird an dem Knoten eingebaut, die Methode ist beendet this.objekt = objekt; return; } // das aktuelle Objekt ist groesser: gehe nach links if (Vergleich.vergleiche(this.objekt, objekt) > 0) { // wenn links kein Konten da ist, erzeuge ihn if (this.links == null) { this.links = new Knoten(); } // baue das Objekt links ein this.links.baueEin(objekt); } // das aktuelle Objekt ist kleiner oder gleich: gehe nach rechts else { // wenn rechts kein Knoten da ist, erzeuge ihn if (this.rechts == null) { this.rechts = new Knoten(); } // baue das Objekt rechts ein this.rechts.baueEin(objekt); } } Methode zum Speichern der Objekte in einer Liste: Die Anordnung im Baum wird genutzt, um die Objekte aufsteigend in eine Liste einzutragen. Die Methode durchlaufeUndTrageEinInListe() wird zuerst fr die Verzweigung nach links aufgerufen. Dann wird das Objekt am Knoten in die Liste am Ende eingetragen, wenn am Knoten ein Objekt abgelegt ist. Wenn am aktuellen Knoten eine Verzweigung nach rechts existiert, wird diese im letzten Schritt nach demselben Algorithmus durchlaufen. private void durchlaufeUndTrageEinInListe(DoppeltVerketteteListe liste) { // pruefe, ob eine Verzweigung nach links exisitiert if (links != null) { // durchlaufe den Knoten links links.durchlaufeUndTrageEinInListe(liste); } // pruefe, ob ein Objekt eingetragen ist if (objekt != null) {
24

// trage das Objekt in die Liste ein try { liste.fuegeEinAmEnde(objekt); } catch (AusnahmeFehlerBeiDerBearbeitung e) { // die Ausnahmen kann nicht auftreten, da die Referenz != null ist } } // pruefe, ob eine Verzweigung nach rechts exisitiert if (rechts != null) { // durchlaufe den Knoten rechts rechts.durchlaufeUndTrageEinInListe(liste); } } Methode zur Ausgabe des Baums: Zur Ausgabe der Knoten und Objekte des Baums ist die Methode durchlaufeUndSchreibeAufShell() implementiert. Fall das Objekt am Knoten existiert, schreibt sie seinen Inhalt auf die Shell. Falls eine Verzweigung nach links mit einem Objekt existiert, schreibt sie dieses Objekt auf die Shell. Falls eine Verzweigung nach rechts existiert, schreibt sie seinen Inhalt auf die Shell. Danach ruft sie dieselbe Methode fr die Knoten links und dann fr rechts auf. public void durchlaufeUndSchreibeAufShell() { // schreibe das Objekt auf die Shell, wenn es da ist if (objekt != null) { System.out.println("Objekt: " + objekt.toString()); } // schreibe das Objekt links auf die Shell, wenn es da ist if (links != null) { if (links.objekt != null) { System.out.println("Links: " + links.objekt.toString()); } else { System.out.println("Links traegt kein Objekt"); } } else { System.out.println("Links ist nicht vorhanden"); } // schreibe das Objekt rechts auf die Shell, wenn es da ist if (rechts != null) { if (rechts.objekt != null) { System.out.println("Rechts: " + rechts.objekt.toString()); } else { System.out.println("Rechts traegt kein Objekt");
25

} } else { System.out.println("Rechts ist nicht vorhanden"); } System.out.println(); // gehe zum Knoten links und schreibe ihn auf die Shell if (links != null) { links.durchlaufeUndSchreibeAufShell(); } // gehe zum Knoten rechts und schreibe ihn auf die Shell if (rechts != null) { rechts.durchlaufeUndSchreibeAufShell(); } } Suchen in einem Baum Grundstzliches: Ein Baum kann genutzt werden, um Objekte effizient finden zu knnen. Hierbei wird von der Regel Gebrauch gemacht, dass alle Objekte, die kleiner sind als das Objekt an einem betrachteten Knoten, in der linken Verzweigung zu finden sind. Objekte, die grer oder gleich dem Objekt an einem betrachteten Knoten sind, sind in der rechten Verzweigung zu finden. Algorithmus: Gegeben ist eine Zahl. Der Baum soll untersucht werden, ob ein Objekt in ihm gespeichert ist, dessen Abbildung diese Zahl ergibt. Der Algorithmus beginnt mit der Wurzel. Das Objekt am Knoten wird mit der gegebenen Zahl verglichen. Drei Flle werden unterschieden: 1. Das Objekt am Knoten ist grer als die gegebene Zahl: Wenn dies der Fall ist, wird die linke Verzweigung geprft. Wenn sie existiert, wird derselbe Algorithmus fr die linke Verzweigung durchgefhrt. Wenn sie nicht existiert, ist im Baum kein Objekt enthalten, dessen Abbildung die gegebene Zahl ergibt. 2. Das Objekt am Knoten ist kleiner als die gegebene Zahl: Wenn dies der Fall ist, wird die rechten Verzweigung geprft. Wenn sie existiert, wird derselbe Algorithmus fr die rechte Verzweigung durchgefhrt. Wenn sie nicht existiert, ist im Baum kein Objekt enthalten, dessen Abbildung die gegebene Zahl ergibt. 3. Das Objekt am Knoten wird auf die gegebene Zahl abgebildet: Das Objekt ist gefunden. Aufwand: Der Aufwand, ein Objekt im Baum zu finden, ist linear von der Anzahl der geprften Knoten abhngig. Komponenten zur Darstellung auf dem Bildschirm in JAVA

26

public void actionPerformed(ActionEvent e);

JPanel: Ein Objekt der Klasse JPanel ist eine Arbeitsflche in einem Fenster. Die Klasse JPanel hat die Klasse Container als Elternklasse, sodass auf einer Arbeitsflche andere Komponenten angeordnet werden knnen. Ein Objekt der Klasse JPanel hat ein Layout.

GridLayout: Ein Objekt der Klasse GridLayout berzieht einen Bereich mit einem regelmigen Raster bestehend aus Zeilen und Spalten. Die Anzahl an Zeilen und Spalten kann dem Konstruktor bergeben werden. JLabel: Ein Objekt vom Typ JLabel stellt eine Zeichenkette auf dem Bildschirm dar. Der Nutzer am Bildschirm kann diese Zeichenkette nicht verndern. JTextField: Die Klasse JTextField stellt Funktionalitten bereit, damit der Nutzer am Bildschirm eine Zeichenkette eingeben kann. JButton: Ein Objekt vom Typ JButton ist ein Knopf. Der Knopf kann beschriftet werden. Verarbeitung von Ereignissen in Java Beobachter-Konzept: Die Verarbeitung von Ereignissen in Java basiert auf dem BeobachterKonzept (Listener Concept). Nach diesem Konzept arbeitet die Laufzeitumgebung von Java mit einem Objekt der Oberflche und Objekten, die dieses Objekt der Oberflche beobachten, zusammen. Ziel der Zusammen-arbeit ist es, dass ein Ereignis, das fr ein Objekt der Oberflche ausgelst wurde, beim Beobachter verarbeitet werden kann. Wird beispielsweise ein Knopf betrachtet, so wird das Loslassen des Knopfes in Java als Aktion bezeichnet (action). Der Beobachter eines Knopfes kann die Schnittstelle ActionListener implementieren. Diese Schnittstelle verfgt ber eine Methode:
27

Blickwinkel der Sicht, die ndert: Die Sicht, die ndert, bentigt den Steuerer. In einer Implementierung kann der Steuerer dem Konstruktor der Sicht bergeben werden. Der Steuerer wird im Objekt gespeichert. Nachdem die Sicht eine nderung vorgenommen hat, ruft sie den Steuerer auf. Blickwinkel der Sicht, die ber die eingetretene nderung informiert wird: Eine Sicht, die ber eine nderung informiert werden mchte, wird beim Steuerer registriert. Das Eintragen und auch das Austragen werden zweckmig von dem Objekt vorgenommen, das die zu informierende Sicht verwaltet. Wenn nun die erste Sicht ndert und den Steuerer aufgerufen hat, ruft dieser die bei ihm als zu informierende Objekte eingetragenen Sichten auf. Steuerer: Die Kommunikation zwischen den Sichten und dem Steuerer wird zweckmig ber eine Schnittstelle geregelt. Die Sichten implementieren diese Schnittstelle. Diese Schnittstelle bentigt eine Methode, die vom Steuerer aufgerufen wird, wenn zu informieren ist.

28