From 2aae6d889a523cada9bec878ea8fdc1e3fc90abb Mon Sep 17 00:00:00 2001 From: BuildTools Date: Tue, 15 Dec 2020 21:03:30 +0100 Subject: [PATCH] +Alles zusammen --- src/com/company/lösungen/Ebook.java | 227 +++++++++++++++ src/com/company/lösungen/fahrtbuch.java | 115 ++++++++ src/com/company/lösungen/gewässer.java | 137 +++++++++ src/com/company/lösungen/meeting.java | 163 +++++++++++ src/com/company/lösungen/onlineShop.java | 202 ++++++++++++++ src/com/company/lösungen/toDoList.java | 207 ++++++++++++++ src/com/company/lösungen/websiteGen.java | 325 ++++++++++++++++++++++ src/com/company/lösungen/zooo.java | 136 +++++++++ 8 files changed, 1512 insertions(+) create mode 100644 src/com/company/lösungen/Ebook.java create mode 100644 src/com/company/lösungen/fahrtbuch.java create mode 100644 src/com/company/lösungen/gewässer.java create mode 100644 src/com/company/lösungen/meeting.java create mode 100644 src/com/company/lösungen/onlineShop.java create mode 100644 src/com/company/lösungen/toDoList.java create mode 100644 src/com/company/lösungen/websiteGen.java create mode 100644 src/com/company/lösungen/zooo.java diff --git a/src/com/company/lösungen/Ebook.java b/src/com/company/lösungen/Ebook.java new file mode 100644 index 0000000..2fbf2cc --- /dev/null +++ b/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); + } +} diff --git a/src/com/company/lösungen/fahrtbuch.java b/src/com/company/lösungen/fahrtbuch.java new file mode 100644 index 0000000..0b5bc4b --- /dev/null +++ b/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()); + } +} diff --git a/src/com/company/lösungen/gewässer.java b/src/com/company/lösungen/gewässer.java new file mode 100644 index 0000000..9c1a6ef --- /dev/null +++ b/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); + } + +} diff --git a/src/com/company/lösungen/meeting.java b/src/com/company/lösungen/meeting.java new file mode 100644 index 0000000..f333ea3 --- /dev/null +++ b/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); + } + +} diff --git a/src/com/company/lösungen/onlineShop.java b/src/com/company/lösungen/onlineShop.java new file mode 100644 index 0000000..ce76ad0 --- /dev/null +++ b/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(); + } +} diff --git a/src/com/company/lösungen/toDoList.java b/src/com/company/lösungen/toDoList.java new file mode 100644 index 0000000..668f089 --- /dev/null +++ b/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); + } +} diff --git a/src/com/company/lösungen/websiteGen.java b/src/com/company/lösungen/websiteGen.java new file mode 100644 index 0000000..ae7b11d --- /dev/null +++ b/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 "

In " + this.getName() + " ist es " + this.getWetter() + + ".

"; + } + + // 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 + "

Dies trifft auch für die Stadtteile " + + stadtteile + " zu.

"; + + // 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 = "

Die Wetter-Webseite

"; + + // 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 + "" + name + ""; + + // 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 + "

"; + + // 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 = ""; + + // Füge Navigationsleiste hinzu + output = output + this.getNavigation(); + + // Füge Überschrift hinzu + output = output + "

Das Wetter für " + stadt.getName() + "

"; + + output = output + stadt.getContent(); + + // Füge HTML-Fußzeile hinzu + output = output + ""; + + // 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(); + } +} diff --git a/src/com/company/lösungen/zooo.java b/src/com/company/lösungen/zooo.java new file mode 100644 index 0000000..d634858 --- /dev/null +++ b/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"); + } +}