+Alles zusammen
BuildTools
3 years ago
parent
4a49790666
commit
2aae6d889a
@ -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);
|
||||
}
|
||||
}
|
||||
@ -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());
|
||||
}
|
||||
}
|
||||
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
@ -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");
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue