Zielsetzung
Wir wollen eine kleine Klasse Bibliothek entwickeln, in der eine größere Anzahl unterschiedlicher Bücher verwaltet werden kann. Die Bibliothek soll es ermöglichen, Bücher hinzuzufügen, gezielt nach Büchern zu suchen (zum Beispiel nach Autor, Titel oder Erscheinungsjahr), die gespeicherten Bücher umzusortieren sowie einzelne Bücher wieder aus der Sammlung zu entfernen. Darüber hinaus soll die Bibliothek in der Lage sein, ihren internen Speicher bei Bedarf zu erweitern, wenn die vorhandene Kapazität nicht mehr ausreicht, um weitere Bücher aufzunehmen.
Anhand dieses überschaubaren Projekts bereiten wir uns auf mehrere zentrale Konzepte der objektorientierten Programmierung vor. Im Mittelpunkt stehen dabei Sammlungen von Objekten sowie das Prinzip der Vererbung, insbesondere das damit verbundene Konzept der Polymorphie. Diese Themen werden nicht isoliert eingeführt, sondern ergeben sich unmittelbar aus den Anforderungen an die Bibliothek als realistische Anwendung.
1. Vererbung und die Klassenhierarchie der Bücher
Bücher kann man bekanntlich in viele Untergruppen unterteilen, beispielsweise Romane und Fachbücher. Bei den Fachbüchern kann man dann wieder zwischen Lehrbüchern und Nachschlagewerken unterscheiden und so weiter.
Graphisch kann man diese Beziehungen folgendermaßen darstellen:
Die Beziehungen zwischen den fünf Klassen
Autor: Ulrich Helmich 12/2025, Lizenz: Public domain
Die Abbildung zeigt die Beziehungen zwischen den Buch-Klassen. Die Klasse Buch ist dabei die fachliche Oberklasse dieser Klassenhierarchie. Wie alle Java-Klassen erbt auch sie implizit von der Klasse Object, die deshalb in der Abbildung mit dargestellt ist.
Vererbung, Oberklassen und Unterklassen
Eine Klasse U kann Instanzvariablen und Methoden von einer Klasse O erben. Das heißt, alle öffentlichen (public) oder geschützten (protected) Instanzvariablen und Methoden von O (Oberklasse) stehen auch U (Unterklasse) zur Verfügung.
Objekte der Unterklasse U sind gleichzeitig auch Objekte der Oberklasse O. In der Informatik-Didaktik spricht man dann von einer IST-Beziehung(is a relation): U IST O.
Von Buch sind die beiden gleichwertigen Unterklassen Roman und Fachbuch abgeleitet. Die Klasse Fachbuch wird ihrerseits weiter spezialisiert: Lehrbuch und Lexikon sind zwei gleichwertige Unterklassen von Fachbuch.
Da Fachbuch eine Unterklasse von Buch ist, sind Lehrbuch und Lexikon automatisch ebenfalls Unterklassen von Buch. Man kann auch sagen: Ein Lexikon IST ein Fachbuch, und ein Lexikon IST ein Buch.
Aufgabe 7.2 #1
Erstellen Sie ein neues Java-Projekt "Bibliothek" und legen Sie die fünf Klassen Buch, Roman, Fachbuch, Lehrbuch und Lexikon an. Die Rümpfe der Klasse bleiben zunächst leer.
Die fünf Klassen im BlueJ-Editor
Autor: Ulrich Helmich 12/2025, Lizenz: Public domain
Im BlueJ-Editor kann man die fünf erzeugten Klassen sehr gut und übersichtlich anordnen, so ähnlich wie in der Abbildung 1. Aber die Pfeile zwischen den Klassen existieren noch nicht; es handelt sich immer noch um fünf völlig eigenständige Klassen, es bestehen keine Beziehungen zwischen diesen Klassen.
Das werden wir jetzt aber ändern. Dazu erweitern wir zunächst einmal den Quelltext der Klasse Roman:
public class Roman extends Buch
{
}
Durch das Schlüsselwort extends haben wir die Klasse Roman zu einer Tochterklasse oder Unterklasse von Buch gemacht.
Aufgabe 7.2 #2
Ergänzen Sie die anderen Klassen entsprechend: Fachbuch als Tochterklasse von Buch, Lehrbuch und Lexikon als Tochterklasse von Fachbuch.
Wenn Sie diese Aufgabe erfolgreich gelöst haben müssten Sie unter BlueJ folgendes Bild sehen:
Die fünf Klassen im BlueJ-Editor
Autor: Ulrich Helmich 12/2025, Lizenz: Public domain
Wir wollen jetzt einmal überlegen, welche Eigenschaften die Objekte dieser fünf Klassen haben sollen. Alle Bücher - egal ob Roman oder Fachbuch - haben einen eindeutigen Titel, einen oder mehrere Autoren sowie ein Erscheinungsjahr. Weitere Eigenschaften wie Verlag, Auflage, ISBN und so vernachlässigen wir jetzt, damit die Sache nicht zu kompliziert wird.
Die drei Instanzvariablen für diese drei Eigenschaften oder Attribute nennen wir
String titel; String autor; int jahr;
Aufgabe 7.2 #3
1.) Bauen Sie diese drei Instanzvariablen jetzt in die Klasse Buch ein.
2.) Schreiben Sie einen Konstruktor für die Klasse Buch, der die drei Eigenschaften als Parameter erhält und dann den drei Instanzvariablen zuweist (keine Überprüfungen notwendig, damit die Sache einfach bleibt).
Wenn wir das Projekt jetzt kompilieren, meldet der BlueJ-Compiler eine Fehlermeldung. Wir haben die Oberklasse Buch mit einem Konstruktor versehen, die Unterklassen aber noch nicht. Wenn die Oberklasse einen Konstruktor besitzt, dann müssen auch die Unterklassen einen entsprechenden Konstruktor haben.
Wir probieren das einmal bei der Unterklasse Roman aus:
public class Roman extends Buch
{
public Roman()
{
}
}
Diese Maßnahme reicht jedoch nicht aus; der Compiler meldet weiterhin einen Fehler. Der Grund ist, dass Java in diesem Fall automatisch versucht, den parameterlosen Konstruktor der Oberklasse aufzurufen. Einen solchen Konstruktor gibt es in Buch aber nicht.
Der nächste naheliegende Versuch ist daher, dem Konstruktor der Unterklasse die gleiche Parameterliste zu geben wie dem Konstruktor der Oberklasse:
public class Roman extends Buch
{
public Roman(String titel, String autor, int jahr)
{
}
}
Auch jetzt tritt noch eine Compiler-Fehlermeldung auf. Zwar besitzt der Konstruktor nun die passenden Parameter, der Konstruktor der Oberklasse wird jedoch weiterhin nicht aufgerufen.
Erst durch den expliziten Aufruf des Oberklassenkonstruktors mit dem Schlüsselwort super verschwindet die Fehlermeldung:
public class Roman extends Buch
{
public Roman(String titel, String autor, int jahr)
{
super(titel,autor,jahr);
}
}
Mit dem Schlüsselwort super wird der Konstruktor der Oberklasse Buch aufgerufen. Dieser erwartet drei Parameter (zwei String-Werte und einen int-Wert) und erhält beim Aufruf genau diese drei Parameter.
Wird der Konstruktor der Oberklasse nicht explizit mit super(...) aufgerufen, versucht Java automatisch, den parameterlosen Konstruktor der Oberklasse zu verwenden. Existiert ein solcher Konstruktor nicht, führt dies zu einem Compilerfehler.
Merke:
Aufruf des Oberklassen-Konstruktors
Besitzt eine Oberklasse keinen parameterlosen Konstruktor, dann muss jeder Konstruktor einer Unterklasse explizit einen passenden Konstruktor der Oberklasse mit super(...) aufrufen. Andernfalls kann der Quelltext nicht kompiliert werden.
Aufgabe 7.2 #4
Statten Sie jetzt die restlichen Klassen des Projektes mit entsprechenden Konstruktoren aus.
Aufgabe 7.2 #5
Ergänzen Sie das Projekt um eine Testklasse, in der von jeder Klasse und Unterklasse genau ein Objekt angelegt wird.
Untersuchen Sie dann mit dem BlueJ-Objektinspektor (oder anderen Hilfsmitteln), ob die fünf Objekte korrekt erzeugt werden.
2. Polymorphie ↑
Wir wollen nun das wichtige Konzept der Polymorphie kennenlernen. Dazu statten wir jetzt jede der fünf Klassen des Projektes mit einer eigenen show()-Methode aus. Wir beginnen mit der Oberklasse Buch.
public class Buch
{
String titel, autor;
int jahr;
public Buch(String titel, String autor, int jahr)
{
this.titel = titel;
this.autor = autor;
this.jahr = jahr;
}
public void show()
{
System.out.println("---------------------------------");
System.out.println("Titel : " + titel);
System.out.println("Autor : " + autor);
System.out.println("Jahr : " + jahr);
System.out.println("---------------------------------");
System.out.println();
}
}
Aufgabe 7.2 #6
Ergänzen Sie jetzt das Testprogramm aus Übung #5 so, dass für jedes der fünf Objekte die Methode show() aufgerufen wird.
Hier ein Beispiel für eine solche Testklasse:
public class Test
{
Lehrbuch lb;
Lexikon lx;
Roman ro;
Fachbuch fb;
Buch bu;
public Test()
{
lb = new Lehrbuch ("Einführung in Java","Meier, Otto",2025);
lx = new Lexikon ("Lexikon der Informatik","Duden-Verlag",2012);
ro = new Roman ("Der Herr der Ringe","J.R. Tolkien",1964);
fb = new Fachbuch ("Prinzipien der OOP","Müller, Jonathan",2020);
bu = new Buch ("Das Wunderbuch","Schulze, Jens",2012);
lb.show();
lx.show();
ro.show();
fb.show();
bu.show();
}
}
Alle fünf show()-Methoden sollten jetzt fehlerfrei ausgeführt werden. Wenn beispielsweise lb.show() aufgerufen wird, kann das Lehrbuch-Objekt lb auf die in der Oberklasse Buch definierte show()-Methode zugreifen. Denn eine Unterklasse erbt bekanntlich alle öffentlichen Instanzvariablen und Methoden der Oberklasse. Daher IST ein Lehrbuch gleichzeitig ein Buch, und da wir für Buch eine show()-Methode implementiert hatten, haben wir damit auch für Lehrbuch und die anderen Unterklassen eine show()-Methode implementiert.
Von einem polymorphen Verhalten kann hier allerdings noch nicht die Rede sein, da ja alle fünf Klassen auf die gleiche Weise reagieren, wenn die show()-Methode aufgerufen wird.
Das ändert sich aber, sobald wir die Unterklassen mit eigenen spezifischen show()-Methoden ausstatten.
Aufgabe 7.2 #7
Ergänzen Sie die Klasse Roman wir folgt:
public class Roman extends Buch
{
String genre;
public Roman(String titel, String autor, int jahr, String genre)
{
super(titel,autor,jahr);
this.genre = genre;
}
public void show()
{
super.show();
System.out.println("Genre = " + genre);
}
}
Kompilieren Sie das Projekt und schauen Sie sich die Konsolenausgabe näher an.
Hier eine Beispiel-Konsolenausgabe:
--------------------------------- Titel : Der Herr der Ringe Autor : J.R. Tolkien Jahr : 1964 --------------------------------- Genre = Fantasy --------------------------------- Titel : Prinzipien der OOP Autor : Müller, Jonathan Jahr : 2020 --------------------------------- --------------------------------- Titel : Das Wunderbuch Autor : Schulze, Jens Jahr : 2012 ---------------------------------
Für den "Herr der Ringe"-Roman von Tolkien wird jetzt tatsächlich das Genre mit ausgegeben. Allerdings sieht die Ausgabe hier nicht optimal aus. Die show()-Methode der Oberklasse Buch hat den Titel, den Autoren und das Erscheinungsjahr ausgegeben, dann eine Trennlinie gezogen und schließlich einen Zeilenvorschub erzeugt.
Diese Buch.show()-Methode wurde dann von der Roman.show()-Methode aufgerufen:
super.show();
Anschließend wurde von Roman.show() noch das Genre des Romans ausgegeben - erst nach der Trennlinie und dem Zeilenvorschub.
Übung 7.2 #8
Statten Sie jetzt die anderen Unterklassen mit spezifischen show()-Methoden aus und optimieren Sie gleichzeitig die Optik der Konsolenausgabe.
Betrachten wir jetzt einmal eine solche optimierte Konsolenausgabe:
--------------------------------- Titel : Einführung in Java Autor : Meier, Otto Jahr : 2025 Fachgebiet = Informatik Teilgebiet = Programmierung --------------------------------- Titel : Lexikon der Informatik Autor : Duden-Verlag Jahr : 2012 Fachgebiet = Informatik Zahl der Einträge = 5600 --------------------------------- Titel : Der Herr der Ringe Autor : J.R. Tolkien Jahr : 1964 Genre = Fantasy --------------------------------- Titel : Prinzipien der OOP Autor : Müller, Jonathan Jahr : 2020 Fachgebiet = Informatik --------------------------------- Titel : Das Wunderbuch Autor : Schulze, Jens Jahr : 2012
Jede Unterklasse besitzt nun eine eigene Implementierung der Methode show(). Wird beispielsweise ein Objekt der Klasse Lexikon ausgegeben, so erscheinen zunächst über super.show() die Ausgaben der Oberklasse Buch (Titel, Autor, Erscheinungsjahr). Ergänzend dazu werden über Lexikon.show() die lexikonspezifischen Informationen ausgegeben.
Welche konkrete show()-Methode tatsächlich ausgeführt wird, entscheidet sich erst zur Laufzeit des Programms. Dieses Verhalten bezeichnet man als dynamische Methodensuche oder dynamisches Binden. Der Compiler überprüft beim Übersetzen ausschließlich die syntaktische Korrektheit des Programms sowie die Zugreifbarkeit von Methoden anhand des deklarierten Typs einer Variablen. Welche Implementierung einer überschriebenen Methode zur Laufzeit aufgerufen wird, ist für den Compiler nicht relevant.
Zur Veranschaulichung betrachten wir folgendes Experiment:
Ein kleines Experiment
Alle fünf Instanzvariablen sind hier vom Typ Buch deklariert. Dennoch werden ihnen Objekte unterschiedlicher Unterklassen zugewiesen.
In der Zeile 11 wird dann das Buch-Objekt lb aber als Lehrbuch initialisiert:
lb = new Lehrbuch("Einführung in Java", "Meier, Otto", 2025, "Informatik");
Der Compiler akzeptiert diese Anweisung ohne Beanstandung. Der Grund dafür ist das Substitutionsprinzip: Ein Objekt der Klasse Lehrbuch ist zugleich auch ein Objekt der Oberklasse Buch. Der verwendete Konstruktor gehört zwar nicht zur Klasse Buch, wohl aber zur Klasse Lehrbuch – und von dieser Klasse wird dann auch ein Objekt erzeugt.
Problematisch wird es erst beim folgenden Methodenaufruf:
lb.setTeilgebiet("Programmierung");
Hier meldet der Compiler einen Fehler ("Symbol nicht gefunden"). Entscheidend ist dabei nicht der tatsächliche Objekttyp zur Laufzeit, sondern der statische Typ der Variablen lb. Diese ist als Buch deklariert, und die Klasse Buch besitzt keine Methode setTeilgebiet(). Daher ist dieser Methodenaufruf aus Sicht des Compilers unzulässig.
Merke:
Deklarierter / tatsächlicher Objekttyp
- Der deklarierte Objekttyp einer Variablen bestimmt, auf welche Methoden der Compiler Zugriff erlaubt.
- Der tatsächliche Objekttyp zur Laufzeit entscheidet darüber, welche überschriebenen Methoden (z. B. show()) tatsächlich ausgeführt werden.
Wird also die Variable lb als Buch deklariert, so kann kein Zugriff auf die Lehrbuch-Methode setTeilgebiet() erfolgen. Der Compiler erkennt dies und meldet einen Fehler.
Wird eine Variable wie lb zwar als Buch deklariert, dann aber als Lehrbuch initialisiert, so wird zur Laufzeit die Lehrbuch.show()-Methode ausgeführt und nicht die Buch.show()-Methode.
Der Begriff der Polymorphie
Bisher haben wir um diesen wichtigen Begriff der OOP noch einen großen Bogen gemacht. Nach den jetzt besprochenen Beispielen und Experimenten sind wir aber so weit, dass wir uns mit diesem Fachbegriff näher beschäftigen können.
Ein Methodenaufruf wie show() kann bei den unterschiedlichen Objekten des Projektes zu unterschiedlichen Ergebnissen führen - abhängig davon, welches konkrete Objekt sich zur Laufzeit hinter der jeweiligen Variablen verbirgt.
Dass ein und derselbe Methodenaufruf bei Objekten verschiedener Klassen ein jeweils passendes Verhalten auslöst, bezeichnet man in der objektorientierten Programmierung als Polymorphie.
Polymorphie
Polymorphie (aus dem Griechischen "Vielgestaltigkeit") bezeichnet in der objektorientierten Programmierung die Fähigkeit von Objekten unterschiedlicher Klassen, über eine gemeinsame Schnittstelle (z. B. eine geerbte Methode) auf gleiche Weise angesprochen zu werden, wobei die tatsächlich ausgeführte Methode von der konkreten Objektklasse abhängt.
Nachdem wir uns jetzt kurz mit diesem wichtigen Thema beschäftigt haben, wollen wir erst mal mit unserem Bibliotheks-Projekt weitermachen. Sinn dieses Projektes ist ja die Hinführung zum Thema "ArrayList". Bevor wir diese wichtige Java-Klasse näher kennenlernen, wollen wir uns eine eigene ArrayList programmieren, die wir sinnvollerweise als "MyArrayList" bezeichnen.
3. Die Klasse MyArrayList ↑
Aufgabe 7.2 #9
Erstellen Sie die folgende Klasse in dem Bibliotheks-Projekt:
public class MyArrayList
{
private Buch[] liste = new Buch[10];
private int anzahl = 0;
public MyArrayList()
{
}
}
Dieses Vorgehen bildet das Verhalten einer echten ArrayList schon recht gut ab. Wenn wir ein Objekt der Klasse ArrayList anlegen, wird intern tatsächlich ein Array des betreffenden Datentyps angelegt, der zunächst nur 10 Elemente umfasst. Mit dem Objektinspektor von BlueJ kann man das sehr leicht überprüfen.
Aufgabe 7.2 #10
Erstellen Sie ein neues Projekt oder bauen Sie folgende Klasse in das bestehende Projekt ein:
import java.util.ArrayList;
public class ArrayListTest
{
ArrayList liste;
public ArrayListTest()
{
liste = new ArrayList<>();
liste.add("Hallo Welt");
}
}
Überprüfen Sie dann mit dem Objektinspektor, welche Eigenschaften das Objekt liste hat.
Das Ergebnis des Objektinspektors
Dieses Bild zeigt, dass die Instanzvariable liste eine Referenz-Variable ist (Darstellung als Pfeil).
Doppelklickt man auf diesen Pfeil, sieht man, dass das referenzierte Objekt aus drei Komponenten besteht (mittlere Box): Einem Array elementData aus Objekten der Klasse Object, einer Instanzvariable size und einer Instanzvariable modCount. Dabei steht size für die aktuelle Größe der ArrayList - hier 1, weil erst ein String in die Liste eingefügt wurde. Die Instanzvariable modCount zählt mit, wie oft die ArrayList modifiziert wurde.
Wenn wir nun auf die Referenz-Variable elementData doppelklicken, öffnet sich ein drittes Fenster, das uns den eigentlichen Array anzeigt, der der ArrayList zugrunde liegt. Hier sehen wir genau 10 Elemente, und das erste Elemente mit dem Index 0 hat den Wert "Hallo Welt". Hier ist also der mit liste.add() hinzugefügte String untergebracht.
Damit hätten wir schon einmal einen ersten Blick auf eine richtige ArrayList geworfen. Wir wollen nun aber mit unserer eigenen ArrayList weitermachen.
Aufgabe 7.2 #11
Statten Sie die Klasse MyArrayList mit einer eigenen add()-Methode aus. Diese Methode soll ein Objekt der Klasse Buch (oder ein Objekt einer der Unterklassen) entgegennehmen und in dem internen Speicher liste abspeichern. Wenn der interne Speicher voll ist (also bereits 10 Bücher enthält), dann soll die Methode mit return verlassen werden - Fehlermeldungen oder andere Hinweise sind hier nicht erforderlich (warum, das werden wir gleich sehen...).
Sie können mit folgender Testklasse überprüfen, ob Ihre add()-Methode korrekt arbeitet:
public class Test
{
private MyArrayList bib;
public Test()
{
bib = new MyArrayList();
bib.add(new Lehrbuch ("Einführung in Java","Meier, Otto",2025,"Informatik"));
bib.add(new Lexikon ("Lexikon der Informatik","Duden-Verlag",2012,"Informatik"));
bib.add(new Roman ("Der Herr der Ringe","J.R. Tolkien",1964,"Fantasy"));
bib.add(new Fachbuch ("Prinzipien der OOP","Müller, Jonathan",2020,"Informatik"));
bib.add(new Buch ("Das Wunderbuch","Schulze, Jens",2012));
}
}
Wir wollen die Klasse MyArrayList nun um eine get()-Methode ergänzen. Wie bei einer richtigen ArrayList soll die get()-Methode ein Objekt der Klasse Buch zurückliefern.
Aufgabe 7.2 #12
Ergänzen Sie die Klasse MyArrayList um eine solche get()-Methode:
public Buch get(int index)
Hier ist eine Fehlerüberprüfung sinnvoll, falls ein falscher Index übergeben wurde.
Speichern Sie das erhaltene Buch-Objekt dann in einer entsprechenden lokalen Variablen und lassen Sie sich das Buch dann mit der eigenen show()-Methode ausgeben.
Hier ist wieder eine Testklasse zum Überprüfen Ihrer Lösung:
public class Test
{
MyArrayList bib;
public Test()
{
bib = new MyArrayList();
bib.add(new Lehrbuch ("Einführung in Java","Meier, Otto",2025,"Informatik"));
bib.add(new Lexikon ("Lexikon der Informatik","Duden-Verlag",2012,"Informatik"));
bib.add(new Roman ("Der Herr der Ringe","J.R. Tolkien",1964,"Fantasy"));
bib.add(new Fachbuch ("Prinzipien der OOP","Müller, Jonathan",2020,"Informatik"));
bib.add(new Buch ("Das Wunderbuch","Schulze, Jens",2012));
Buch b;
for (int i=0; i<7; i++)
{
b = bib.get(i);
if (b != null) b.show();
}
}
}
Da in der ArrayList nur 5 Bücher gespeichert sind, liefern die beiden letzten Durchgänge der for-Schleife einen Fehler. Diesen Fehler muss Ihre get()-Methode abfangen. Im Fehlerfall wird dann nicht das Buch-Objekt zurückgeliefert, sondern der Wert null. Die b.show()-Methode der Testklasse prüft vorher, ob das zurückgelieferte Objekt b den Wert null hat.
Die Konsolenausgabe des Testprogramms zeigt dann wieder, dass zur Laufzeit des Programms die jeweils passende show()-Methode aufgerufen wird.
Eine richtige ArrayList wächst dynamisch. Anfangs wird sie mit einer Kapazität von 10 Elementen angelegt. Sollten mehr als 10 Elemente hinzugefügt werden, wird vorher die Kapazität verdoppelt, also auf 20 erhöht. Dieses Verhalten wollen wir jetzt in unserer eigenen ArrayList simulieren.
Aufgabe 7.2 #13
A) Ergänzen Sie die Klasse MyArrayList um eine private-Methode grow(), welche die Kapazität der ArrayList verdoppelt.
Vorgehen:
Intern einen doppelt so großen neuen Array anlegen, alle Werte des alten Array hineinkopieren und dann die Referenzvariable liste aktualisieren.
B) Verändern Sie die add()-Methode so, dass grow() aufgerufen wird, falls die vorhandene Liste bereits voll ist.
C) Ergänzen Sie die Klasse MyArrayList um eine Methode
public int size()
welche die Anzahl der enthaltenen Bücher zurückliefert.
Testen Sie die neuen Funktionen dann mit dem alten Testprogramm, allerdings müssen Sie jetzt mehr als 10 Bücher hinzufügen. Probieren Sie das mit dem folgenden Code:
public class Test
{
MyArrayList bib;
public Test()
{
bib = new MyArrayList();
bib.add(new Lehrbuch ("Einführung in Java","Meier, Otto",2025,"Informatik"));
bib.add(new Lexikon ("Lexikon der Informatik","Duden-Verlag",2012,"Informatik"));
bib.add(new Roman ("Der Herr der Ringe","J.R. Tolkien",1964,"Fantasy"));
bib.add(new Fachbuch ("Prinzipien der OOP","Müller, Jonathan",2020,"Informatik"));
bib.add(new Buch ("Das Wunderbuch","Schulze, Jens",2012));
bib.add(new Lehrbuch ("Datenstrukturen und Algorithmen","Klein, Martin",2022,"Informatik"));
bib.add(new Lexikon ("Computerlexikon","Springer-Verlag",2018,"Informatik"));
bib.add(new Roman ("1984","Orwell, George",1949,"Dystopie"));
bib.add(new Fachbuch ("Softwaretechnik kompakt","Becker, Laura",2019,"Informatik"));
bib.add(new Buch ("Eine kurze Geschichte der Zeit","Hawking, Stephen",1988));
bib.add(new Lehrbuch ("Grundlagen der Programmierung","Schmidt, Anna",2021,"Informatik"));
bib.add(new Lexikon ("Mathematisches Wörterbuch","Vieweg",2015,"Mathematik"));
bib.add(new Roman ("Der Prozess","Kafka, Franz",1925,"Literatur"));
bib.add(new Fachbuch ("Datenbanken verstehen","Weber, Thomas",2017,"Informatik"));
bib.add(new Buch ("Die Physiker","Dürrenmatt, Friedrich",1962));
Buch b;
System.out.println("Die Liste enthält " + bib.size() + " Bücher.");
for (int i=0; i < bib.size(); i++)
{
b = bib.get(i);
if (b != null) b.show();
}
}
}
Die Titel und Daten der Bücher habe ich mir übrigens von ChatGPT generieren lassen.
Damit kommen wir zum Schluss dieser wirklich langen Seite. Als Nächstes schauen wir uns den Aufbau und die Methoden einer richtigen ArrayList an - Einiges darüber haben wir ja schon auf dieser Seite besprochen, allzu viel Neues wird also nicht mehr kommen.
Seitenanfang
Weiter mit der Klasse ArrayList ...