+Alles zusammen

src/com/company/lösungen/Ebook.java

@@ -0,0 +1,227 @@
+package com.company.lösungen;
+
+public class Ebook {
+    // Öffentliche Klasse zur Repräsentation eines E-Books
+    public class Ebook {
+        // Deklaration privater Variablen
+        private MediaAsset[] assets;
+        private String author;
+        private int year;
+
+        // Öffentlicher Konstruktor, der zur Angabe von
+        // Autor und Jahreszahl verpflichtet
+        public Ebook(String author, int year) {
+            this.assets = new MediaAsset[100];
+            this.author = author;
+            this.year = year;
+        }
+
+        // Getter-Methode zur Rückgabe der Seitenanzahl
+        public int numPages() {
+            float sum = 0.0f;
+
+            // Gehe Assets-Array durch
+            for (int i = 0; i < assets.length; i = i + 1) {
+                // Ist Eintrag in Array vorhanden, dann Summe errechnen
+                if (assets[i] != null) {
+                    sum = sum + assets[i].numPages();
+                }
+            }
+
+            return Math.round(sum);
+        }
+
+        // Methode, über die ein MediaAsset hinzugefügt werden kann
+        // Das Asset muss an die Methode übergeben werden.
+        public void addAsset(MediaAsset asset) {
+            // Gehe Assets-Array durch
+            for (int i = 0; i < assets.length; i = i + 1) {
+                // Ist kein Eintrag in Array vorhanden, dann einmal hinzufügen
+                if (assets[i] == null) {
+                    assets[i] = asset;
+
+                    // Springe aus Schleife
+                    break;
+                }
+            }
+        }
+
+        // Methode, die eine String-Repräsentation dieses
+        // E-Books zurückliefert.
+        public String toString() {
+            String output = "Ebook: " + author + " (" + year + ")\nSeiten: " +
+                    numPages() + "\n-------\n";
+
+            // Gehe Array-Inhalte durch
+            for (int i = 0; i < assets.length; i = i + 1) {
+                // Füge toString-Ausgabe hinzu
+                if (assets[i] != null) {
+                    output = output + assets[i].toString();
+                }
+            }
+
+            return output;
+        }
+    }
+
+    // Klasse zur Beschreibung eines MediaAsset
+    public class MediaAsset {
+        // Deklaration privater Variablen
+        private String file;
+        private int size;
+        private String language;
+
+        // Konstruktor, der zur Angabe diverser Informationen verpflichtet
+        public MediaAsset(String file, int size, String language) {
+            this.file = file;
+            this.size = size;
+            this.language = language;
+        }
+
+        // Methode zur Rückgabe der Seitenanzahl ist hierbei nicht möglich
+        public float numPages() {
+            // Ein undefiniertes Asset trägt nicht zur Seitenzahl bei
+            return 0.0f;
+        }
+
+        // Methode zur Repräsentation des Assets
+        public String toString() {
+            return file + " (" + numPages() + " Seiten)\n";
+        }
+    }
+
+    // Öffentliche Klasse zur Repräsentation eines TextAssets, die
+// von der Klasse MediaAsset ableitet.
+    public class TextAsset extends MediaAsset {
+        // Deklaration privater Variablen
+        private int numChars;
+
+        // Konstruktor, der zur Angabe von Werten für Dateinamen, -größe,
+        // Sprache sowie Anzahl an Zeichen verpflichtet
+        public TextAsset(String file, int size, String language, int numChars) {
+            // Aufruf der Basisklasse und Übergabe der Werte
+            super(file, size, language);
+
+            // Spezifische Werte werden lokal gespeichert
+            this.numChars = numChars;
+        }
+
+        // Methode zur Abfrage der Anzahl an Seiten
+        public float numPages() {
+            return numChars / 2000.0f;
+        }
+    }
+
+    // Öffentliche Klasse zur Repräsentation eines PictureAssets, die
+// von der Klasse MediaAsset ableitet.
+    public class PictureAsset extends MediaAsset {
+        // Deklaration privater Variablen
+        private int w;
+        private int h;
+
+        // Öffentlicher Konstruktor, der zur Angabe der folgenden Werte
+        // verpflichtet
+        public PictureAsset(
+                String file,
+                int size,
+                String language,
+                int w,
+                int h
+        ) {
+            // Aufruf und Übergabe der von der Basisklasse verwalteten Werte
+            super(file, size, language);
+
+            // Übrige Werte werden lokal festgehalten
+            this.w = w;
+            this.h = h;
+        }
+
+        // Methode zur Berechnung und Rückgabe der Anzahl von Seiten
+        public float numPages() {
+            float height = h * (960 / (float)w);
+            if (height > 600) {
+                return 1.0f;
+            }
+            else {
+                return 0.5f;
+            }
+        }
+    }
+
+
+    // Öffentliche Klasse zur Repräsentation eines PictureAssets, die
+// von der Klasse MediaAsset ableitet.
+    public class AudioAsset extends MediaAsset {
+        // Deklaration privater Variablen
+        private int duration;
+
+        // Öffentlicher Konstruktor, der zur Angabe der folgenden Werte
+        // verpflichtet
+        public AudioAsset(String file, int size, String language, int duration) {
+            // Aufruf und Übergabe der von der Basisklasse verwalteten Werte
+            super(file, size, language);
+
+            // Übrige Werte werden lokal festgehalten
+            this.duration = duration;
+        }
+
+        // Methode zur Berechnung und Rückgabe der Anzahl von Seiten
+        public float numPages() {
+            return 0.0f;
+        }
+    }
+
+
+    // Öffentliche Klasse zur Repräsentation eines VideoAssets, die
+// von der Klasse MediaAsset ableitet.
+    public class VideoAsset extends MediaAsset {
+        // Deklaration privater Variablen
+        private int duration;
+        private int w;
+        private int h;
+
+        // Konstruktor, der zur Angabe der folgenden Werte verpflichtet
+        public VideoAsset(
+                String file,
+                int size,
+                String language,
+                int duration,
+                int w,
+                int h
+        ) {
+            // Aufruf und Übergabe der von der Basisklasse verwalteten Werte
+            super(file, size, language);
+
+            // Übrige Werte werden lokal festgehalten
+            this.duration = duration;
+            this.w = w;
+            this.h = h;
+        }
+
+        // Methode zur Berechnung und Rückgabe der Anzahl von Seiten
+        public float numPages() {
+            float height = h * (960 / (float)w);
+            if (height > 600) {
+                return 1.0f;
+            }
+            else {
+                return 0.5f;
+            }
+        }
+    }
+
+    // Startpunkt des Hauptprogramms
+// Hier werden die implementierten Klassen zu Demonstrations- und
+// Testzwecken instanziiert und verwendet.
+    public void setup() {
+        Ebook testBook = new Ebook("Stephan Wiefling", 2017);
+        testBook.addAsset(new TextAsset("Aufgabe 1", 12, "Deutsch", 3444));
+        testBook.addAsset(new AudioAsset("Audio 1", 12, "Deutsch", 95));
+        testBook.addAsset(
+                new VideoAsset("Video 1", 12, "Deutsch", 95, 800, 800)
+        );
+        testBook.addAsset(new PictureAsset("Bild 1", 12, "Deutsch", 2000, 600));
+        testBook.addAsset(new TextAsset("Aufgabe 2", 12, "Deutsch", 7655));
+        System.out.println(testBook);
+    }
+}

src/com/company/lösungen/fahrtbuch.java

@@ -0,0 +1,115 @@
+package com.company.lösungen;
+
+public class fahrtbuch {
+    // Basisklasse für alle Fahrzeuge
+    public class Fahrzeug {
+        private float kmSatz;
+
+        // Konstruktor, der vorgibt, dass ein
+        // Kilometersatz angegeben werden muss
+        public Fahrzeug(float kmSatz) {
+            this.kmSatz = kmSatz;
+        }
+
+        // Getter zur Rückgabe des Kilometersatzes
+        public float getKmSatz() {
+            return kmSatz;
+        }
+    }
+
+    // Klasse Fahrrad, die von der Klasse Fahrzeug erbt
+    public class Fahrrad extends Fahrzeug {
+        // Rufe Superklasse auf und setze Fahrpreis auf 1,00 EUR fest
+        public Fahrrad() {
+            super(1.00f);
+        }
+    }
+
+    public class Motorroller extends Fahrzeug {
+        // Rufe Superklasse auf und setze Fahrpreis auf 2,00 EUR fest
+        public Motorroller() {
+            super(2.00f);
+        }
+    }
+
+    public class Kleintransporter extends Fahrzeug {
+        // Rufe Superklasse auf und setze Fahrpreis auf 5,50 EUR fest
+        public Kleintransporter() {
+            super(5.50f);
+        }
+    }
+
+
+    // Klasse, die eine Fahrt repräsentiert
+    public class Fahrt {
+        private Fahrzeug fahrzeug;
+        private float km;
+
+        // Konstruktor, der die Angabe eines Fahrzeugs
+        // und die gefahrenen Kilometer vorschreibt.
+        public Fahrt(Fahrzeug fahrzeug, float km) {
+            this.fahrzeug = fahrzeug;
+            this.km = km;
+        }
+
+        // Methode zur Berechnung des Fahrpreises
+        // (Kilometersatz * Kilometer)
+        public float getPrice() {
+            return fahrzeug.getKmSatz() * km;
+        }
+    }
+
+
+    // Klasse, die ein Fahrtenbuch repräsentiert
+    public class Fahrtenbuch {
+        private Fahrt[] fahrten;
+
+        // Konstruktor, der die Fahrten initialisiert
+        public Fahrtenbuch() {
+            this.fahrten = new Fahrt[0];
+        }
+
+        // Öffentliche Methode zum Hinzufügen einer Fahrt,
+        // die als Fahrtobjekt an die Methode übergeben wird
+        public void addFahrt(Fahrt fahrt) {
+            Fahrt[] fahrtenNew = new Fahrt[fahrten.length + 1];
+
+            for (int i = 0; i < fahrten.length; i = i + 1) {
+                fahrtenNew[i] = fahrten[i];
+            }
+
+            fahrtenNew[fahrtenNew.length - 1] = fahrt;
+            fahrten = fahrtenNew;
+        }
+
+        // Getter-Methode, die den Preis zurückliefert
+        public float getPrice() {
+            // Gesamtpreis
+            float price = 0.0f;
+
+            // Gehe jede Fahrt durch
+            for (int i = 0; i < fahrten.length; i = i + 1) {
+                // Berechne Preis
+                price = price + fahrten[i].getPrice();
+            }
+
+            return price;
+        }
+    }
+
+    // Startpunkt des Hauptprogramms
+// Hier werden die implementierten Klassen zu Demonstrations- und
+// Testzwecken instanziiert und verwendet.
+    public void setup() {
+        // Erstelle Fahrtenbuch
+        Fahrtenbuch fb = new Fahrtenbuch();
+
+        // Füge Fahrten hinzu
+        fb.addFahrt(new Fahrt(new Fahrrad(), 3f));
+        fb.addFahrt(new Fahrt(new Motorroller(), 7.12f));
+        fb.addFahrt(new Fahrt(new Kleintransporter(), 56.11f));
+
+        // Berechne Gesamtpreis
+        System.out.println(fb.getPrice());
+    }
+}

src/com/company/lösungen/gewässer.java

@@ -0,0 +1,137 @@
+package com.company.lösungen;
+
+public class gewässer {
+    // Öffentliche, abstrakte Klasse zur Basisimplementierung eines
+// Gewässers. Die Klasse ist nicht instanziierbar; es können also
+// keine Objekte dieser Klasse direkt erzeugt werden.
+    public abstract class Gewaesser {
+        // Deklaration privater Variablen
+        private String name;
+        private boolean schiffbar;
+        private float schadstoffbelastung;
+
+        // Öffentlicher Konstruktor, der die Angabe des Namens,
+        // der Schiffbarkeit sowie der Schadstoffbelastung erfordert.
+        public Gewaesser(
+                String name,
+                boolean schiffbar,
+                float schadstoffbelastung
+        ) {
+            this.name = name;
+            this.schiffbar = schiffbar;
+            this.schadstoffbelastung = schadstoffbelastung;
+        }
+
+        // Getter-Methode zur Abfrage, in welches andere Gewässer
+        // dieses mündet. Diese Methode wird in ableitenden Klassen
+        // überschrieben.
+        public Gewaesser getMuendetIn() {
+            return null;
+        }
+
+        // Getter-Methode zur Rückgabe des Gewässernamens
+        public String getName() {
+            return name;
+        }
+
+        // Öffentliche Methode zum Generieren eines repräsentativen
+        // Strings.
+        public String toString() {
+            return name;
+        }
+    }
+
+    // Öffentliche Klasse, die ein Meer repräsentiert und dazu von
+// der abstrakten Klasse Gewässer ableitet.
+    public class Meer extends Gewaesser {
+        // Deklaration privater Variablen
+        private int flaeche;
+
+        // Konstruktor, der Name, Schadstoffbelastung sowie Fläche
+        // einfordert
+        public Meer(String name, float schadstoffbelastung, int flaeche) {
+            // und damit den Konstruktor der Basisklasse (Gewaesser) aufruft.
+            // Da ein Meer immer schiffbar ist, wird beim Aufruf des Basisklassen-
+            // konstruktors für schiffbar direkt der Wert 'true' gesetzt.
+            super(name, true, schadstoffbelastung);
+
+            // und zusätzlich noch die Fläche in der selbst erzeugten Variablen
+            // speichert. Denn die Basisklasse hat hierfür keine Variable vor-
+            // gesehen.
+            this.flaeche = flaeche;
+        }
+    }
+
+    // Klasse, die einen Fluss repräsentiert und von der Klasse Gewaesser
+// ableitet.
+    public class Fluss extends Gewaesser {
+        // Deklaration privater Variablen, die typisch für einen
+        // Fluss sind
+        private int laenge;
+        private Gewaesser muendetIn;
+
+        // Öffentlicher Konstruktor, der die benötigten Werte
+        // entgegennimmt. Ein Fluss mündet in einem anderen
+        // Gewässer und wird zusätzlich verlangt.
+        public Fluss(
+                String name,
+                boolean schiffbar,
+                float schadstoffbelastung,
+                int laenge,
+                Gewaesser muendetIn
+        ) {
+            // Aufruf und Übergabe der Werte an den Konstruktor der
+            // Basisklasse Gewaesser
+            super(name, schiffbar, schadstoffbelastung);
+
+            // Speichern der zusätzlichen Parameter, die für einen
+            // Fluss charakteristisch sind.
+            this.laenge = laenge;
+            this.muendetIn = muendetIn;
+        }
+
+        // Öffentliche Methode, um das nächste erreichbare Meer
+        // zu bestimmen.
+        public Gewaesser bestimmeMeer() {
+            // Gehe ins nächste Gewässer
+            Gewaesser gewaesser = this.muendetIn;
+
+            // Solange wir noch weitere Gewässer haben,
+            while (gewaesser.getMuendetIn() != null) {
+                // gehe Gewässerkette solange durch, bis wir auf Meer stoßen
+                // (also kein muendetIn mehr vorhanden ist)
+                gewaesser = gewaesser.getMuendetIn();
+            }
+
+            return gewaesser;
+        }
+
+        // Überschreiben der Basisklassenmethode, die
+        // hier aber einen konkreten Wert zurückliefert
+        public Gewaesser getMuendetIn() {
+            return muendetIn;
+        }
+
+        // Öffentliche Methode zur Repräsentation eines Flusses
+        public String toString() {
+            return super.name + ", mündet in " + getMuendetIn().getName() + ", endet" +
+                    " in " + bestimmeMeer();
+        }
+    }
+
+    // Startpunkt des Hauptprogramms
+// Hier werden die implementierten Klassen zu Demonstrations- und
+// Testzwecken instanziiert und verwendet.
+    public void setup() {
+        Meer nordsee = new Meer("Nordsee", 12.2f, 842000);
+        Fluss elbe = new Fluss("Elbe", true, 12.3f, 1094, nordsee);
+        Fluss moldau = new Fluss("Moldau", true, 12.3f, 430, elbe);
+        Fluss berounka = new Fluss("Berounka", false, 12.3f, 138, moldau);
+        Fluss havel = new Fluss("Havel", true, 12.3f, 334, elbe);
+
+        System.out.println(berounka);
+        System.out.println(moldau);
+        System.out.println(havel);
+    }
+
+}

src/com/company/lösungen/meeting.java

@@ -0,0 +1,163 @@
+package com.company.lösungen;
+
+public class meeting {
+    // Klasse zur Repräsentation eines Meeting-Protokolls
+    public class MeetingMinutes {
+        // Deklaration privater Variablen
+        private String date;
+        private String timeframe;
+        private String room;
+        private String[] participants;
+        private Item[] items;
+
+        // Konstruktor, der die benötigten Daten per
+        // Vorschrift beim Anlegen eines neuen Objekts
+        // erforderlich macht.
+        public MeetingMinutes(
+                String date,
+                String timeframe,
+                String room,
+                String[] participants
+        ) {
+            this.date = date;
+            this.timeframe = timeframe;
+            this.room = room;
+            this.participants = participants;
+
+            // Leere Liste erzeugen
+            this.items = new Item[0];
+        }
+
+        // Methode zum Hinzufügen eines Item-Objekts
+        public void add(Item item) {
+            // Erzeuge vergrößertes Array
+            Item[] newItems = new Item[items.length + 1];
+
+            // Kopiere Elemente rüber
+            for (int i = 0; i < items.length; i = i + 1) {
+                newItems[i] = items[i];
+            }
+
+            // Belege letztes Element mit neuem Item
+            newItems[newItems.length - 1] = item;
+
+            // Ersetze alte mit neuer Liste
+            items = newItems;
+        }
+
+        // Methode zur Repräsentation eines Meetings
+        public String toString() {
+            String output = "Meeting: " + date + " (" + timeframe + "), " + room + "\n";
+            output = output + "Participants: ";
+
+            // Gehe Teilnehmerliste durch
+            for (int i = 0; i < participants.length; i = i + 1) {
+                output = output + participants[i];
+
+                // Komma bis zum letzten Element setzen
+                if (i < participants.length - 1) {
+                    output = output + ", ";
+                }
+            }
+            output = output + "\n-----------\n";
+
+            // Alle Diskussionspunkte durchgehen
+            for (int i = 0; i < items.length; i = i + 1) {
+                output = output + items[i].toString() + "\n";
+            }
+
+            return output;
+        }
+    }
+
+    // Abstrakte Klasse Item
+    public abstract class Item {
+        // Deklaration privater Variablen
+        String content;
+
+        // Konstruktor, der den Content verlangt
+        public Item(String content) {
+            this.content = content;
+        }
+
+        // Methode zur Repräsentation des Items
+        public String toString() {
+            return this.content;
+        }
+    }
+
+    // Öffentliche Klasse zur Repräsentation eines Diskussionsbeitrags.
+// Es wird von der Klasse Item geerbt.
+    public class DiscussionItem extends Item {
+        // Der Konstruktor erwartet den Inhalt
+        public DiscussionItem(String content) {
+            // und übergibt diesen an die Basisklasse
+            super(content);
+        }
+
+        // Überschreiben der Repräsentation mit der spezifischen Version
+        // für einen Diskussionsbeitrag.
+        public String toString() {
+            return "Discussion: " + super.toString();
+        }
+    }
+
+    // Klasse, die eine Entscheidung repräsentiert und von der Klasse
+// Item erbt.
+    public class DecisionItem extends Item {
+        // Konstruktor, der den Content verlangt
+        public DecisionItem(String content) {
+            // und die Basisklasse damit aufruft
+            super(content);
+        }
+
+        // Überschreiben der Repräsentation mit der spezifischen Version
+        // für einen Entscheidungsbeitrag.
+        public String toString() {
+            return "Decision: " + super.toString();
+        }
+    }
+
+    // Klasse zur Repräsentation einer Aktion, die von der Klasse
+// Item ableitet.
+    public class ActionItem extends Item {
+        // Öffentlicher Konstruktor, der zur Angabe des Inhalts verpflichtet.
+        public ActionItem(String content) {
+            // und an die Basisklasse weiterleitet
+            super(content);
+        }
+
+        // Überschreiben der Repräsentation mit der spezifischen Version
+        // für einen Aktionsbeitrag.
+        public String toString() {
+            return "Action: " + super.toString();
+        }
+    }
+
+    // Startpunkt des Hauptprogramms
+// Hier werden die implementierten Klassen zu Demonstrations- und
+// Testzwecken instanziiert und verwendet.
+    public void setup() {
+        String[] participants = {
+                "Luigi Lo Iacono",
+                "Michael Schneider",
+                "Stephan Wiefling"
+        };
+
+        MeetingMinutes meeting = new MeetingMinutes(
+                "10.10.2017",
+                "10-12 Uhr",
+                "R123",
+                participants
+        );
+
+        meeting.add(new DiscussionItem("Veröffentlichung Buch"));
+        meeting.add(new DecisionItem("Dem Antrag wurde einstimmig zugestimmt."));
+        meeting.add(
+                new ActionItem("Bis zum nächsten Meeting muss Kapitel 9 fertig gestellt sein.")
+        );
+
+        System.out.println(meeting);
+    }
+
+}

src/com/company/lösungen/onlineShop.java

@@ -0,0 +1,202 @@
+package com.company.lösungen;
+
+public class onlineShop {
+    // Öffentliche Klasse zur Repräsentation eines Artikels
+    public class Article {
+        // Deklaration privater Variablen
+        private int articleNumber;
+        private float price;
+
+        // Konstruktor, der die Artikelnummer und den Preis
+        // erforderlich macht.
+        public Article(int articleNumber, float price) {
+            this.articleNumber = articleNumber;
+            this.price = price;
+        }
+
+        // Getter-Methode, die den Preis zurückliefert.
+        public float getPrice() {
+            return price;
+        }
+    }
+
+    // Öffentliche Klasse, die ein Buch repräsentiert.
+// Die Klasse erbt von der Klasse Artikel
+    public class Book extends Article {
+        // Deklaration eigener privater Variablen
+        private String author;
+        private String title;
+        private int year;
+
+        // Der Mehrwertsteuersatz für Bücher (7 %) wird durch die
+        // statische Konstante VAT repräsentiert.
+        public static final float VAT = 0.07f;
+
+        // Öffentlicher Konstruktor mit der Vorschrift
+        // zum Anlegen eines Buchobjekts.
+        public Book(
+                int articleNumber,
+                float price,
+                String author,
+                String title,
+                int year
+        ) {
+            // Aufruf des Konstruktors der Basisklasse Article
+            super(articleNumber, price);
+
+            // Zusätzlich werden die charakterisierenden
+            // Eigenschaften eines Buchs gesetzt.
+            this.author = author;
+            this.title = title;
+            this.year = year;
+        }
+
+        // Öffentliche Methode zur Berechnung des Bruttopreises
+        public float getPrice() {
+            // Rufe für Nettopreis die Methode in der Superklasse auf
+            // und addiere die für Bücher geltende Mehrwertsteuer
+            return round((super.getPrice() + super.getPrice() * Book.VAT) * 100) / 100.0;
+        }
+
+        // Öffentliche Methode, die einen geeigneten String generiert
+        // und zurückliefert.
+        public String toString() {
+            return "Buch - " + author + ": " + title + " (" + year + ")";
+        }
+    }
+
+    // Klasse, die eine DVD repräsentiert und von der Klasse
+// Article ableitet.
+    class DVD extends Article {
+        // Deklaration privater Variablen, die spezifisch für eine
+        // DVD sind
+        private String name;
+        private String duration;
+        private int countryCode;
+
+        // Statische Konstante für Mehrwertsteuersatz für DVDs (19 %)
+        public static final float VAT = 0.19f;
+
+        // Öffentlicher Konstruktor der Klasse DVD. Zum Generieren eines
+        // Objekts der Klasse DVD werden die angegebenen Werte verlangt.
+        public DVD(
+                int articleNumber,
+                float price,
+                String name,
+                String duration,
+                int countryCode
+        ) {
+            // Aufruf des Basisklassenkonstruktors
+            super(articleNumber, price);
+
+            // Zusätzliche Daten werden in den internen Variablen abgelegt.
+            this.name = name;
+            this.duration = duration;
+            this.countryCode = countryCode;
+        }
+
+        // Öffentliche Methode zur Berechnung des Bruttopreises
+        public float getPrice() {
+            // Rufe für Nettopreis die Methode in der Superklasse auf
+            // und addiere die für Bücher geltende Mehrwertsteuer
+            return round((super.getPrice() + super.getPrice() * DVD.VAT) * 100) / 100.0;
+        }
+
+        // Öffentliche Methode, die einen DVD-repräsentativen String
+        // zurückliefert.
+        public String toString() {
+            return "DVD - " + name;
+        }
+    }
+
+    // Klasse, die einen Warenkorb realisiert
+    public class ShoppingCart {
+        // Deklaration privater Variablen
+        private Article[] cart;
+
+        // Öffentlicher Konstruktor, der den internen
+        // Warenkorb initialisiert
+        public ShoppingCart() {
+            // Noch leerer Warenkorb
+            this.cart = new Article[0];
+        }
+
+        // Öffentliche Methode zum Hinzufügen eines Artikels
+        // zum Warenkorb. Der Artikel wird in Form eines
+        // Article-Objekts realisiert. Da sowohl Bücher als
+        // auch DVDs von der Klasse Article erben, sind beide
+        // Typen hier erlaubt und werden dafür auf die Basis-
+        // implementierung zurückgecastet.
+        public void addToCart(Article article) {
+            // Vergrößere Array um ein Element
+            Article[] cartNew = new Article[cart.length + 1];
+
+            // Kopiere alle Artikel rüber
+            for (int i = 0; i < cart.length; i = i + 1) {
+                cartNew[i] = cart[i];
+            }
+
+            // Setze neuen Artikel ans Ende der Liste
+            cartNew[cartNew.length - 1] = article;
+
+            // Übernehme neue Liste
+            cart = cartNew;
+        }
+
+        // Öffentliche Methode, die eine Rechnung auf der
+        // Konsole druckt
+        public void showBill() {
+            // Gesamtpreis
+            float sum = 0.0f;
+
+            // Jeden Artikel durchgehen
+            for (int i = 0; i < cart.length; i = i + 1) {
+                Article article = cart[i];
+
+                // Gebe Namen und Preis aus
+                System.out.println(article + "\t " + article.getPrice() + " Euro");
+
+                // Addiere zu Gesamtpreis
+                sum = sum + article.getPrice();
+            }
+            System.out.println("------------------------------------");
+
+            // Gebe Gesamtpreis aus
+            System.out.println("Gesamtpreis: " + str(sum) + " Euro");
+        }
+    }
+
+    // Startpunkt des Hauptprogramms
+// Hier werden die implementierten Klassen zu Demonstrations- und
+// Testzwecken instanziiert und verwendet.
+    public void setup() {
+        Book book = new Book(
+                122767676,
+                32.71f,
+                "Luigi Lo Iacono",
+                "WebSockets",
+                2015
+        );
+
+        DVD dvd1 = new DVD(
+                122767676,
+                14.95f,
+                "Spiel mir das Lied vom Tod",
+                "99:12",
+                1
+        );
+        DVD dvd2 = new DVD(
+                122767676,
+                8.40f,
+                "Casablanca, Classic Collection",
+                "99:12",
+                1
+        );
+
+        ShoppingCart wk = new ShoppingCart();
+        wk.addToCart(book);
+        wk.addToCart(dvd1);
+        wk.addToCart(dvd2);
+        wk.showBill();
+    }
+}

src/com/company/lösungen/toDoList.java

@@ -0,0 +1,207 @@
+package com.company.lösungen;
+
+public class toDoList {
+    // Öffentliche Klasse zur Repräsentation eines Listeneintrags
+    public class ListItem {
+        // Deklaration privater Variablen
+        private String entry;
+        private boolean checked;
+
+        // Öffentlicher Konstruktor, der einen Eintrag als String
+        // erwartet und als nicht überprüft voreinstellt.
+        public ListItem(String entry) {
+            this.entry = entry;
+            this.checked = false;
+        }
+
+        // Getter-Methode zur Abfrage des Entry-Strings
+        public String getEntry() {
+            return entry;
+        }
+
+        // Getter-Methode zur Abfrage des Überprüfungsstatus
+        public boolean getChecked() {
+            return checked;
+        }
+
+        // Setter-Methode mit dem Status als Parameter
+        public void setChecked(boolean checked) {
+            this.checked = checked;
+        }
+
+        // Öffentliche Methode zur Repräsentation eines
+        // beschreibenden ListItem
+        public String toString() {
+            return getEntry() + " (" + getChecked() + ")";
+        }
+    }
+
+
+    // Öffentliche Klasse zur Verwaltung einer To-do-Liste
+    public class TodoList {
+        // Deklaration privater Variablen
+        private ListItem[] list;
+
+        // Öffentlicher Konstruktor mit der Initialisierung
+        // der internen Liste.
+        public TodoList() {
+            this.list = new ListItem[0];
+        }
+
+        // Öffentliche Methode zum Hinzufügen eines neuen
+        // ListItems-Objekts.
+        public void addItem(ListItem item) {
+            // Array vergrößern
+            ListItem[] listNew = new ListItem[list.length + 1];
+
+            // Elemente kopieren
+            for (int i = 0; i < list.length; i = i + 1) {
+                listNew[i] = list[i];
+            }
+
+            // letztes Element setzen
+            listNew[listNew.length - 1] = item;
+
+            // Liste übernehmen
+            this.list = listNew;
+        }
+
+        // Öffentliche Methode zum Setzen des Status eines
+        // Listeneintrags
+        public void checkItem(String entry) {
+            // Gehe Liste durch
+            for (int i = 0; i < list.length; i = i + 1) {
+                // Wenn Eintrag mit Gesuchtem übereinstimmt, dann abhaken.
+                if (list[i].getEntry().equals(entry)) {
+                    list[i].setChecked(true);
+
+                    // Springe aus Schleife
+                    break;
+                }
+            }
+        }
+
+        // Methode zur Repräsentation aller Einträge in der
+        // To-do-Liste. Das Ergebnis wird von der Methode zurück-
+        // gegeben.
+        public String toString() {
+            // Rückgabestring
+            String output = "";
+
+            // Gehe jedes Element durch
+            for (int i = 0; i < list.length; i = i + 1) {
+                // Packe toString-Methode in Rückgabe
+                // und füge Zeilenumbruch hinzu
+                output = output + list[i].toString() + "\n";
+            }
+            return output;
+        }
+    }
+
+    // Öffentliche Klasse zur Repräsentation eines Einkaufslisten-
+// eintrags. Hierzu wird von der Klasse ListItem abgeleitet und
+// die für einen Einkaufslisteneintrag charakterisierenden Merkmale
+// hinzugefügt.
+    public class ShoppingItem extends ListItem {
+        // Deklaration privater Variablen
+        private String entry;
+        private int amount;
+
+        // Öffentlicher Konstruktor, der einen Eintrag als String sowie
+        // die Menge dieses Eintrags verlangt
+        public ShoppingItem(String entry, int amount) {
+            // Aufruf des Basisklassenkonstruktors
+            super(entry);
+
+            // zusätzlich wird noch die Menge festgehalten
+            this.amount = amount;
+        }
+
+        // Öffentliche Methode zur Repräsentation eines
+        // aussagekräftigen Strings für einen Einkaufslisteneintrag
+        public String toString() {
+            // rufe toString-Methode der Superklasse auf
+            return amount + "x " + getEntry() + " (" + getChecked() + ")";
+        }
+    }
+
+    // Klasse zur Verwaltung einer Shoppingliste
+    public class ShoppingList {
+        // Deklaration der privaten Variablen
+        private ListItem[] list;
+
+        // Öffentlicher Konstruktor, der die Liste initialisiert
+        public ShoppingList() {
+            this.list = new ListItem[0];
+        }
+
+        // Öffentliche Methode, die einen Listeneintrag in Form
+        // eines ListItem-Objekts entgegennimmt, um diesen dann
+        // in die Einkaufsliste zu setzen
+        public void addItem(ListItem item) {
+            // Array vergrößern
+            ListItem[] listNew = new ListItem[list.length + 1];
+
+            // Elemente kopieren
+            for (int i = 0; i < list.length; i = i + 1) {
+                listNew[i] = list[i];
+            }
+
+            // letztes Element setzen
+            listNew[listNew.length - 1] = item;
+
+            // Liste übernehmen
+            this.list = listNew;
+        }
+
+        // Öffentliche Methode zum Setzen des Status eines
+        // Eintrags, der an die Methode übergeben wird.
+        public void checkItem(String entry) {
+            // Gehe Liste durch
+            for (int i = 0; i < list.length; i = i + 1) {
+                // Wenn Eintrag mit Gesuchtem übereinstimmt,
+                // dann abhaken
+                if (list[i].getEntry().equals(entry)) {
+                    list[i].setChecked(true);
+
+                    // Springe aus Schleife
+                    break;
+                }
+            }
+        }
+
+        // Öffentliche Methode zur Repräsentation der Shoppingliste.
+        public String toString() {
+            // Rückgabestring
+            String output = "";
+
+            // gehe jedes Element durch
+            for (int i = 0; i < list.length; i = i + 1) {
+                // Packe toString Methode in Rückgabe
+                // und füge Zeilenumbruch hinzu
+                output = output + list[i].toString() + "\n";
+            }
+            return output;
+        }
+    }
+
+    // Startpunkt des Hauptprogramms
+// Hier werden die implementierten Klassen zu Demonstrations- und
+// Testzwecken instanziiert und verwendet.
+    public void setup() {
+        TodoList tdl = new TodoList();
+        tdl.addItem(new ListItem("Erster Eintrag"));
+        tdl.addItem(new ListItem("Zweiter Eintrag"));
+        tdl.checkItem("Zweiter Eintrag");
+        System.out.println(tdl);
+
+        ShoppingList sl = new ShoppingList();
+        sl.addItem(new ShoppingItem("Aepfel", 3));
+        sl.addItem(new ShoppingItem("Birnen", 1));
+        sl.addItem(new ShoppingItem("Toastbrot", 2));
+        sl.addItem(new ShoppingItem("Birnenbaum", 2));
+        System.out.println(sl);
+        sl.checkItem("Birnen");
+        System.out.println(sl);
+    }
+}

src/com/company/lösungen/websiteGen.java

@@ -0,0 +1,325 @@
+package com.company.lösungen;
+
+public class websiteGen {
+    // Konstanten, mit denen wir die Wetterlage beschreiben
+    static final int SONNE = 0,
+            BEWOELKT = 1,
+            REGEN = 2;
+
+    // Abstrakte Klasse zur Repräsentation einer Stadt.
+// Von dieser Klasse kann keine Instanz (= Objekt) erzeugt werden.
+    public abstract class Stadt {
+        // Deklaration privater Variablen
+        private String name;
+        private int wetter;
+
+        // Konstruktor, der zur Angabe eines Städtenamens und des
+        // Wetters auffordert
+        public Stadt(String name, int wetter) {
+            this.name = name;
+            this.wetter = wetter;
+        }
+
+        // Getter-Methode zur Rückgabe des Städtenamens
+        public String getName() {
+            return this.name;
+        }
+
+        // Getter-Methode zur Rückgabe des Wetters als String
+        public String getWetter() {
+            if (this.wetter == REGEN) {
+                return "regnerisch";
+            }
+            else if (this.wetter == BEWOELKT) {
+                return "bewölkt";
+            }
+            else if (this.wetter == SONNE) {
+                return "sonnig";
+            }
+
+            // Unbekannter Wert
+            return "Unbekannt";
+        }
+
+        // Getter-Methode zur Rückgabe des Webseiten-Inhalts
+        // für den Webseiten-Generator.
+        public String getContent() {
+            return "<p>In " + this.getName() + " ist es " + this.getWetter() +
+                    ".</p>";
+        }
+
+        // Getter-Methode zur Rückgabe der URL zur Wetterseite
+        public String getURL() {
+            // Wandle Namen in Kleinbuchstaben um
+            String name = this
+                    .getName()
+                    .toLowerCase();
+
+            // Wandle Leerzeichen im Namen in Bindestriche um
+            name = name.replace(" ", "-");
+
+            // Wandle Umlaute um
+            name = name.replace("ä", "ae");
+            name = name.replace("ü", "ue");
+            name = name.replace("ö", "oe");
+
+            // Gebe umgewandelte URL zurück
+            return name + ".html";
+        }
+    }
+
+    // Öffentliche Klasse für die Großstadt leitet
+// von der Klasse Stadt ab.
+    public class Grossstadt extends Stadt {
+        private String[] stadtteile;
+
+        // Konstruktor erwartet ebenfalls einen Städtenamen und das
+        // Wetter, aber zusätzlich noch Stadtteile
+        public Grossstadt(String name, int wetter, String[] stadtteile) {
+            // Städtename und Wetter werden an die Basisklasse
+            // übergeben
+            super(name, wetter);
+
+            // Stadtteile werden noch gesetzt
+            this.stadtteile = stadtteile;
+        }
+
+        // Getter-Methode zur Rückgabe des Webseiten-Inhalts
+        // für den Webseiten-Generator
+        public String getContent() {
+            // Hier speichern wir unsere Webseite als HTML-Code.
+            // Wir übernehmen zunächst den Code von der Überklasse.
+            String output = super.getContent();
+
+            String stadtteile = "";
+            // Gehe die Stadtteile durch
+            for (int i = 0; i < this.stadtteile.length; i = i + 1) {
+                if (i == (this.stadtteile.length - 1)) {
+                    // Wir sind beim letzten Eintrag:
+                    // Füge "und" vor dem Stadtteilnamen hinzu
+                    stadtteile = stadtteile + " und ";
+                }
+
+                // Füge Namen des Stadtteils hinzu
+                stadtteile = stadtteile + this.stadtteile[i];
+
+                // Wenn wir noch nicht am Ende sind
+                if (i < (this.stadtteile.length - 2)) {
+                    // Füge Komma und Leerzeichen hinzu
+                    stadtteile = stadtteile + ", ";
+                }
+            }
+
+            // Füge den Hinweis zu den Stadtteilen hinzu
+            output = output + "<p>Dies trifft auch für die Stadtteile " +
+                    stadtteile + " zu.</p>";
+
+            // Gebe generierten HTML-Code zurück
+            return output;
+        }
+
+        // Getter-Methode zur Rückgabe der URL zur Wetterseite
+        public String getURL() {
+            // Generiere URL und gebe sie zurück.
+            // Rufe dabei die URL-Generierungsmethode aus der
+            // Oberklasse auf.
+            return "wetter_grossstadt_" + super.getURL();
+        }
+    }
+
+    // Öffentliche Klasse für die Großstadt leitet
+// von der Klasse Stadt ab.
+    public class Kleinstadt extends Stadt {
+        // Konstruktor erwartet ebenfalls einen Städtenamen und das
+        // Wetter
+        public Kleinstadt(String name, int wetter) {
+            // Städtename und Wetter werden an die Basisklasse
+            // übergeben
+            super(name, wetter);
+        }
+
+        // Getter-Methode zur Rückgabe des Webseiten-Inhalts
+        // für den Webseiten-Generator
+        public String getContent() {
+            return super.getContent();
+        }
+
+        // Getter-Methode zur Rückgabe der URL zur Wetterseite
+        public String getURL() {
+            // Generiere URL und gebe sie zurück.
+            // Rufe dabei die URL-Generierungsmethode aus der
+            // Oberklasse auf.
+            return "wetter_kleinstadt_" + super.getURL();
+        }
+    }
+
+    // Öffentliche Klasse für den Webseitengenerator
+    public class WebseitenGenerator {
+        // Deklaration privater Variablen
+        private Stadt[] staedte;
+
+        // Anzahl der Einträge im Array
+        private int numEntries = 0;
+
+        public WebseitenGenerator() {
+            this.staedte = new Stadt[0];
+        }
+
+        // Methode zum Hinzufügen einer Stadt
+        public void addStadt(Stadt stadt) {
+            // Erzeuge temporären Array mit einem Eintrag mehr
+            Stadt[] staedteTemp = new Stadt[numEntries + 1];
+
+            // Kopiere die alten Werte in den neuen Array
+            for (int i = 0; i < numEntries; i = i + 1) {
+                staedteTemp[i] = this.staedte[i];
+            }
+
+            // Füge den neuen Eintrag an der letzten Position hinzu
+            staedteTemp[numEntries] = stadt;
+
+            // Setze die neue Liste
+            staedte = staedteTemp;
+
+            // Erhöhe die Anzahl der Einträge um eins
+            numEntries = numEntries + 1;
+        }
+
+        // Methode zum Erstellen und Ausgeben der Navigationsleiste
+        // unserer Wetterwebseite
+        public String getNavigation() {
+            // Hier speichern wir unsere Navigationsleiste als HTML-Code.
+            // Wir beginnen mit dem Paragrafen-HTML-Tag
+            String output = "<h1>Die Wetter-Webseite</h1><p>";
+
+            // Gehe alle Städte durch
+            for (int i = 0; i < this.staedte.length; i = i + 1) {
+                // Hole die URL zur Datei
+                String url = this
+                        .staedte[i]
+                        .getURL();
+
+                // Hole den Städtenamen
+                String name = this
+                        .staedte[i]
+                        .getName();
+
+                // Füge HTML-Link zur Ausgabe hinzu
+                output = output + "<a href='" + url + "'>" + name + "</a>";
+
+                // Füge Trenner hinzu, wenn wir noch nicht am Ende der
+                // Liste sind
+                if (i < this.staedte.length - 1) {
+                    output = output + " | ";
+                }
+            }
+
+            // Schließe den Paragrafen-Tag
+            output = output + "</p>";
+
+            // Gebe generierte Navigationsleiste zurück
+            return output;
+        }
+
+        // Methode zum Erstellen und Ausgeben der HTML-Seite
+        // für eine bestimmte Stadt
+        public String generatePage(int index) {
+            // Hole die Stadt aus dem Array
+            Stadt stadt = this.staedte[index];
+
+            // Hier speichern wir unsere Webseite als HTML-Code
+            // Setze HTML-Kopf
+            String output = "<html><body>";
+
+            // Füge Navigationsleiste hinzu
+            output = output + this.getNavigation();
+
+            // Füge Überschrift hinzu
+            output = output + "<h2>Das Wetter für " + stadt.getName() + "</h2>";
+
+            output = output + stadt.getContent();
+
+            // Füge HTML-Fußzeile hinzu
+            output = output + "</body></html>";
+
+            // Gebe HTML-Code zurück
+            return output;
+        }
+
+        // Methode zum Erstellen und Ausgeben der Wetterwebseite
+        // mit allen Webseiten
+        public void generateWebsites() {
+            // Generiere Index-Dokument
+            // Öffne Datei für die Hauptseite
+            PrintWriter output = createWriter("index.html");
+
+            // Generiere HTML-Code für Datei, in der Hauptseite nehmen
+            // wir nur die Navigationsleiste
+            String htmlCode = this.getNavigation();
+
+            // Speichere HTML-Code in Datei
+            output.print(htmlCode);
+
+            // Schließe Datei
+            output.close();
+
+            // Gehe alle Städte durch
+            for (int i = 0; i < this.staedte.length; i = i + 1) {
+                // Öffne Datei mit URL-Dateinamen
+                output = createWriter(this.staedte[i].getURL());
+
+                // Generiere HTML-Code für Datei
+                htmlCode = this.generatePage(i);
+
+                // Speichere HTML-Code in Datei
+                output.print(htmlCode);
+
+                // Schließe Datei
+                output.close();
+            }
+
+            System.out.println("Webseiten generiert");
+        }
+    }
+
+    // Startpunkt des Hauptprogramms
+// Hier werden die implementierten Klassen zu Demonstrations- und
+// Testzwecken instanziiert und verwendet.
+    public void setup() {
+        // Definiere Köln
+        String[] stadtteileKoeln = {
+                "Ehrenfeld",
+                "Raderthal",
+                "Nippes",
+                "Poll",
+                "Esch",
+                "Pesch",
+                "Kalk"
+        };
+        Grossstadt koeln = new Grossstadt("Köln", SONNE, stadtteileKoeln);
+
+        // Definiere Daaden
+        Kleinstadt daaden = new Kleinstadt("Daaden", BEWOELKT);
+
+        // Definiere Bonn
+        String[] stadtteileBonn = {
+                "Poppelsdorf",
+                "Südstadt",
+                "Beuel",
+                "Duisdorf",
+                "Graurheindorf"
+        };
+        Grossstadt bonn = new Grossstadt("Bonn", REGEN, stadtteileBonn);
+
+        // Initialisiere den Webseitengenerator
+        WebseitenGenerator generator = new WebseitenGenerator();
+
+        // Füge die Städte hinzu
+        generator.addStadt(koeln);
+        generator.addStadt(daaden);
+        generator.addStadt(bonn);
+
+        // Generiere die Webseiten
+        generator.generateWebsites();
+    }
+}

src/com/company/lösungen/zooo.java

@@ -0,0 +1,136 @@
+package com.company.lösungen;
+
+public class zooo {
+    // Klasse, die einen Besucher repräsentiert
+    public class Visitor {
+        // Deklaration privater Variablen
+        private double prize;
+
+        // Konstruktor, der die Angabe eines Preises
+        // erforderlich macht
+        public Visitor(double prize) {
+            this.prize = prize;
+        }
+
+        // Getter-Methode zur Abfrage des Preises
+        public double getPrize() {
+            return prize;
+        }
+
+        // Getter-Methode zur Rückgabe der Anzahl von Personen
+        public int getCount() {
+            return 0;
+        }
+    }
+
+    // Öffentliche Klasse, die eine Personengruppe repräsentiert
+// und von der Klasse Visitor erbt
+    public class Group extends Visitor {
+        // Deklaration privater Variablen
+        private int size;
+
+        // Konstruktor mit der Angabe der Gruppengröße
+        public Group(int size) {
+            // Aufruf der Basisklasse
+            super(50.0);
+
+            // Speichern der Gruppengröße lokal
+            this.size = size;
+        }
+
+        // Getter-Methode zur Rückgabe der Gruppengröße
+        public int getCount() {
+            return size;
+        }
+    }
+
+    // Öffentliche Klasse, die ein Kind repräsentiert
+// und von der Klasse Visitor erbt
+    public class Child extends Visitor {
+        public Child() {
+            // Aufruf der Basisklasse
+            super(0.0);
+        }
+
+        // Getter-Methode zur Rückgabe der Gruppengröße
+        public int getCount() {
+            return 1;
+        }
+    }
+
+
+    // Öffentliche Klasse, die einen Erwachsenen repräsentiert
+// und von der Klasse Visitor erbt
+    public class Adult extends Visitor {
+        public Adult() {
+            // Aufruf der Basisklasse
+            super(15.0);
+        }
+
+        // Getter-Methode zur Rückgabe der Gruppengröße
+        public int getCount() {
+            return 1;
+        }
+    }
+
+    // Öffentliche Klasse, die den Eingang repräsentiert
+    public class Entrance {
+        // Deklaration privater Variablen
+        private Visitor[] visitors;
+        private int visitorCount;
+
+        // Öffentlicher Konstruktor, der die Gesamtzahl an
+        // Gästen erwartet.
+        public Entrance(int size) {
+            visitors = new Visitor[size];
+        }
+
+        // Methode zum Hinzufügen von Besucher(n) vom
+        // Typ 'Visitor'. Instanzen aller von Visitor abgeleiteten
+        // Klassen können hier übergeben werden.
+        public void addVisitor(Visitor v) {
+            visitors[visitorCount++] = v;
+        }
+
+        // Methode zur Ermittlung der gesamten Einnahmen
+        public double computeTurnover() {
+            double to = 0.0;
+
+            // Gehe jeden Besucher durch
+            for (int i = 0; i < visitorCount; i = i + 1) {
+                // Addiere Preis von Besucher zum Gesamtpreis
+                to = to + visitors[i].getPrize();
+            }
+
+            return to;
+        }
+
+        // Methode, die die Gesamtzahl an Besuchern bestimmt
+        // sowie zurückliefert.
+        public int computeVisitors() {
+            int v = 0;
+
+            // Gehe jeden Besucher durch
+            for (int i = 0; i < visitorCount; i = i + 1) {
+                // Addiere Besucheranzahl zur Gesamtzahl
+                v = v + visitors[i].getCount();
+            }
+
+            return v;
+        }
+    }
+
+    // Startpunkt des Hauptprogramms
+// Hier werden die implementierten Klassen zu Demonstrations- und
+// Testzwecken instanziiert und verwendet.
+    public void setup() {
+        Entrance entrance = new Entrance(100);
+        entrance.addVisitor(new Group(6));
+        entrance.addVisitor(new Adult());
+        entrance.addVisitor(new Child());
+        entrance.addVisitor(new Child());
+
+        System.out.println("Besucher: " + entrance.computeVisitors());
+        System.out.println("Umsatz: " + entrance.computeTurnover() + " Euro");
+    }
+}