Skip to Content

8.6 Übungen

Duke als Boxer

(Lizenz)

8.6.1 Aufruf von überschriebenen Methoden

Implementieren sie die Klasse TopClass mit den folgenden Eigenschaften

  • statische, geschütztes (protected) Attribut zaehlerTop zum Zählen der erzeugten Instanzen der Klasse TopClass
  • parameterlosen Konstruktor der den Instanzenzähler inkrementiert.
  • eine statische geschützte Methode getZaehler() die das Attribut zaehlerTop ausgibt.

Implementieren Sie die Klasse LowClass welche aus TopClass abgeleitet mit den folgenden Eigenschaften 

  • statische, geschütztes (protected) Attribut zaehler zum Zählen der erzeugten Instanzen der Klasse LowClass
  • parameterlosen Konstruktor der den Instanzenzähler inkrementiert
  • eine statische geschützte Methode getZaehler() die das Attribut zaehler ausgibt.
  • eine Methode test() die
    • die lokale Methode getZaehler() aufruft und das Ergebnis auf der Konsole ausgibt
    • die Methode getZaehler() der Oberklasse aufruft und das Ergebnis auf der Konsole ausgibt

Implementieren Sie ein Hauptprogramm, dass folgende Befehle ausführt

  • Anlegen eines Feldes der Klasse TopClass mit n Elementen
  • Anlegen eines Feldes der Klasse LowClass mit n Elementen
  • Erzeugen von jeweils n Elementen der Klasse TopClass und Einfügen in das zugehörige Feld
  • Aufruf der getZaehler() Methode der Klasse TopClass und Ausgabe des Wertes auf der Konsole
  • Erzeugen von jeweils n Elementen der Klasse LowClass und Einfügen in das zugehörige Feld
  • Aufruf der getZaehler() Methode der Klasse LowClass und Ausgabe des Wertes auf der Konsole
  • Aufruf der getZaehler() Methode der Klasse TopClass und Ausgabe des Wertes auf der Konsole
UML Diagramm TopClass, LowClass

Zu beobachten:

  • Wieviel Instanzen welcher Klasse (TopClass, LowClass) wurden erzeugt?
  • Wieviel Instanzen wurden insgesamt erzeugt?
  • Was geschieht wenn das Attribut zaehler der Klasse LowClass gelöscht wird?

Klasse MainTop zum Testen

package block9;
/**
*
* @author sschneid
*/
public class MainTop {
private static int size = 3;
public static void main(String[] args) {
TopClass[] feldT = new TopClass[size];
LowClass[] feldL = new LowClass[size]; for ( int i=0; i<size; i++) feldT[i]= new TopClass(); for ( int i=0; i<size; i++) {

feldL[i]= new LowClass();
feldL[i].test();
}
System.out.println(TopClass.getZaehler() + " Instanzen TopClass generiert, "+
LowClass.getZaehler() + " Instanzen LowClass generiert");
}
}

8.6.2 Vererbung und Assoziation

Implementieren Sie eine Klasse Point mit den folgenden Eigenschaften:

  • private Fliesskommaattribute für x und y Koordinate
  • öffentlicher Konstruktor mit x und x als Parameter
  • öffentliche setXY(x,y) Methode
  • Auslesemethoden getX(), getY()
  • print() Methode die eine Zeichenkette mit allen Werten liefert
  • überschreiben die die toString() Methode von Object so das sie alle Werte für Point ausgibt.

Implementieren Sie eine Klasse CircleIsPoint die die Eigenschaften der Klasse Point hat und zusätzlich einen Radius verwalten kann mit folgenden Eigenschaften:

  • erbt von Point
  • das des Zentrum des Kreises sind die (x,y) Koordinaten von Point 
  • privates Fliesskomma Attribut für den Radius radius
  • getRadius() und setRadius(r) Methoden zum Pflegen des Attributs
  • öffentlicher Konstruktor für (x,y) Zentrum und Radius
  • print() Methode die eine Zeichenkette mit allen Werten liefert
  • überschreiben die die toString() Methode von Object so das sie alle Werte für Point ausgibt.

Implementieren Sie eine Klasse CircleHasPoint die die Eigenschaften der Klasse Point hat und zusätzlich einen Radius verwalten kann mit folgenden Eigenschaften:

  • erbt nicht von Point
  • benutzt privates Attribut vom Referenztyp auf Point
  • das des Zentrum des Kreises sind die (x,y) Koordinaten von Point 
  • alle öffentlichen Methoden sind identisch zu CircleIsPoint!

 Was unterscheidet beide Implementierungen? Welche ist die bessere Implementierung?

Point und Circle, Delegation versus Assoziation

Klasse Main

Die drei obigen Klassen sollten mit der folgenden main() Methode funktionieren:

package block9;
public class Main {

    public static void main(String[] args) {
        Point p1 = new Point (2.2, 3.3);
        Point p2 = new Point (2.22, 3.33);
        CircleIsPoint cip1 = new CircleIsPoint(4.4,5.5,6.6);

        p1.print();
        cip1.print();

        CircleHasPoint chp1 = new CircleHasPoint(44.4,55.5,66.6);
        chp1.print();
    }
}

8.6.3 Flughafenbeispiel

UML Diagramm Flughafenbeispiel mit Vererbung

Klasse Flughafen

package airline.block8;

 

/**
*
* @author Otto Lilienthal
*/
public class Flughafen {
String name;
Passagierflugzeug[] gate;
Flugzeug[] parkposition;
double treibstoffLager;

/**
* Anlegen eines Flughafens
* @param anzahlGates Anzahl der Gates eines Flugzeugs
* @param anzahlParkposition Anzahl der Parkpositionen
*/
public Flughafen(int anzahlGates, int anzahlParkposition) {
gate = new Passagierflugzeug[anzahlGates];
parkposition = new Flugzeug[anzahlParkposition];
treibstoffLager = 10000000D;
}

/**
* Betanken eines Flugzeugs aus dem Treibstofflage
* Flugzeug wird nicht betankt wenn das Volumen im Tank nicht ausreicht!
* @param kg zu tankendes Volumen
* @param f Flugzeug welches betankt werden soll
*/
public void tanken(double liter, Flugzeug f) {
if ((liter <= treibstoffLager) && (liter >=0)) {
treibstoffLager -= liter;
f.tanken(liter);
}
else
System.out.println("Nicht genug Treibstoff im Depot zum Tanken");
}

/**
* Drucke den Zustand des Flughafens auf die Konsole
*/
public void drucken() {
System.out.println("*** Unser Flughafen ***");
System.out.println("Flughafen " + name);
for (int i =0;i<gate.length;i++)
System.out.println("Am Gate " + i + ": " + gate[i]);
for (int i =0;i<parkposition.length;i++)
System.out.println("Auf Parkposition " + i + ": " + parkposition[i]);
System.out.println("Treibstoff: " + treibstoffLager);
System.out.println("***********************");
}

/**
* Baue einen Flughafen und teste alle Klassen
* @param args nicht benoetigt
*/
public static void main(String[] args) {

Flughafen pad = new Flughafen(6, 10);
pad.name="Paderborn";
pad.treibstoffLager = 1000000;

pad.drucken();

// Boeing 747, https://de.wikipedia.org/wiki/Boeing_747#747-400
Passagierflugzeug lh1 = new Passagierflugzeug(40000, 400000);
lh1.kennzeichen ="D-ABTL";
lh1.einsteigen(3);
System.out.println("Unsere Gesellschaft" + Flugzeug.meineLG());

double aktuellesGewicht = lh1.gewicht();
System.out.println("aktuelle Gewicht von lh1: " + aktuellesGewicht);

pad.gate[1] = lh1;

// Airbus A380 https://de.wikipedia.org/wiki/Airbus_A380#A380-800
Passagierflugzeug lh2 = new Passagierflugzeug(40000, 400000, "D-AIMA");

// 11 +1 +4 Passagiere steigen ein
lh2.einsteigen(11);
lh2.einsteigen();
lh2.einsteigen(4);
// 5 Passagiere wollen wieder austteigen
lh2.aussteigen(5);

// lh2 wird an Gate 2 angedockt
pad.gate[2] = lh2;

Frachtflugzeug meinFrachter = new Frachtflugzeug(10000D,300000D,"N-1997A");
meinFrachter.laden(1000D);
meinFrachter.entladen(500D);
// Betanke mein Flugzug
pad.tanken(200D,meinFrachter);
pad.parkposition[2] = meinFrachter;
pad.parkposition[3] = new Passagierflugzeug(100000D,500000D,"D-AAAA");

// Hier steht ein Frachtflugzeug. Das ist bekannt!!
// Durch den "Cast" kann man man die Methode laden() für f aufrufen
Frachtflugzeug f = (Frachtflugzeug) pad.parkposition[2];
f.laden(500D);
System.out.println(pad.parkposition[2].kennzeichen + " "
+ pad.parkposition[2].gewicht());


// Hier wird die überladene Methode gewicht() aufgerufen
// Das Programm ruft hier zwei verschiedene Methoden auf
// welche Methode aufgerufen wird wird erst zur Laufzeit entschieden!
System.out.println("Gewicht Parkposition 2 " + pad.parkposition[2].gewicht());
System.out.println("Gewicht Parkposition 3 " + pad.parkposition[3].gewicht());

System.out.println("Flughafen " + pad.name);
System.out.println("Am Gate 1: " + pad.gate[1].kennzeichen +
" Passagiere: " + pad.gate[1].getPassagiere() +
" akt. Gewicht: " + pad.gate[1].gewicht());
System.out.println("Am Gate 2: " + pad.gate[2].kennzeichen +
" Passagiere: " + pad.gate[2].getPassagiere() +
" akt. Gewicht: " + pad.gate[2].gewicht());
pad.drucken();

}
}

 

Klasse Flugzeug

package airline.block8;

/**
* Das ist ein Flugzeug des 8.ten Blocks
* @author Otto Lilienthal
*/
public class Flugzeug {

/**
* Kennzeichen des Flugzeugs
*/
String kennzeichen;
final double maximalesGewicht;
final double leerGewicht;
private double tankinhalt;

/**
* Initialiseren eines Flugzeugs mit Leer- und Maximalgewicht
* @param minGewicht Minimalgewicht in kg
* @param maxGewicht Maximalgewicht in kg
*/
public Flugzeug(double minGewicht, double maxGewicht) {
System.out.println("Ich baue jetzt ein Flugzeug");
if (minGewicht > 0) leerGewicht = minGewicht;
else leerGewicht = 0;
if ((maxGewicht > 0) && (maxGewicht>=leerGewicht))
maximalesGewicht = maxGewicht;
else maximalesGewicht = leerGewicht;
tankinhalt = 0;
}

/**
* Initialiseren eines Flugzeugs mit Leer- und Maximalgewicht, Kennzeichen
* @param minGewicht Minimalgewicht in kg
* @param maxGewicht Maximalgewicht in kg
* @param kennz Kennzeichen
*/
public Flugzeug(double minGewicht, double maxGewicht, String kennz) {
this(minGewicht,maxGewicht);
kennzeichen = kennz;
}

/**
* berechnet das aktuelle Gewicht des Flugzeugs
* @return aktuelle Gewicht
*/
public double gewicht() {
//double g = leerGewicht+passagiere*durchschnittsgewicht;
return leerGewicht+ tankinhalt;
}

/**
* betanken eines Flugzeugs. Vorsicht: Hier wird das Gewicht eingegeben
* @param t kg Treibstoff
*/
public void tanken(double t) {
if (t >= 0)
tankinhalt += t;
else
System.out.println("Versuch mit negativer Literanzahl: " +t);
}

/**
* Aktuelle Tankfüllung in kg
* Vorsicht: Es geht hier um das Gewicht des Treibsstoffs
* @return Gewicht des aktuellen Treibstoffs
*/
public double tankfuellung() {return tankinhalt;}

/**
* Die Fluggesellschaft der Flugzeuge. Dies ist eine static Variable
* D.h. alle Flugzeuge gehören zu einer Fliggesellschaft
* @return Name der Fluggesellschaft
*/
public static String meineLG() { return "Lufthansa";}

}

 

 

Klasse Frachtflugzeug


package airline.block8;

/**
*
* @author Otto Lilienthal
*/
public class Frachtflugzeug extends Flugzeug {

private double ladung;

/**
* Initialisieren eines Frachtflugzeugs mit Initial- und Maximalgewicht,
* Kennzeichen
* @param leer Leergewicht
* @param max Maximalgewicht
* @param kennz Kennzeichen
*/
public Frachtflugzeug(double leer, double max, String kennz) {
super(leer, max, kennz);
ladung = 0;
}

/**
* Laden von Fracht in kg
* @param l zu ladende Fracht in kg
*/
public void laden(double l) {
if (gewicht() + ladung <= maximalesGewicht) {
ladung += l;
} else {
System.out.println("Kann nicht " + l + " kg laden...");
}
}

/**
* Entladen von Fracht in kg
* @param l zu entladende Fracht in kg
*/
public void entladen(double l) {
if (ladung >= l) {
ladung -= l;
} else {
System.out.println("Kann nicht " + l + " kg entladen (Ist zuviel)");
}
}

/**
* Gewicht eines Frachtflugzeugs in kg
* @return Gewicht in kg
*/
@Override
public double gewicht() {
return super.gewicht() + ladung;
}

}

 

Klasse Passagierflugzeug 

package airline.block8;

/**
*
* @author stsch
*/
public class Passagierflugzeug extends Flugzeug {

final static double durchschnittsgewicht = 75;
private int passagiere;
int maxPassagiere = 100;

/**
* gibt die aktuelle Anzahl der Passagiere zurück
* @return Anzahl der Passagiere
*/
public int getPassagiere() {
return passagiere;
}

/**
* Initialisert ein Flugzeug mit Minimal- und Maximalgewicht
* @param minGewicht Minimalgewicht in kg
* @param maxGewicht Maximalgewicht in kg
*/
public Passagierflugzeug(double minGewicht, double maxGewicht) {
super(minGewicht,maxGewicht);
passagiere = 0;

}

/**
* Initialisiert ein Flugzeug mit Minimal- und Maximalgewicht und Kennzeichen
* @param minGewicht Minimalgewicht in kg
* @param maxGewicht Maximalgewicht in kg
* @param kennz Kennzeichen des Flugzeugs
*/
public Passagierflugzeug(double minGewicht, double maxGewicht, String kennz) {
super(minGewicht,maxGewicht,kennz);
passagiere = 0;
}

/**
* Einsteigen eines einzelnen Passagiers
*/
public void einsteigen() {
if (passagiere >= maxPassagiere) { // Zuviele Einsteiger
System.out.println("Fehler: Einsteigen verweigert ");
} else { // passt schon
passagiere++;
}
}

/**
* Einsteigen einer vorgegebenen Anzahl Passagiere.
* und sie funktioniert auch!
* Wenn zuviele einsteigen möchten, darf keiner einsteigen!
* @param einsteiger Anzahl der Passagiere die einsteigen.
*/
public void einsteigen(int einsteiger) {
if (passagiere+einsteiger > maxPassagiere) {
System.out.println("Fehler: Einsteigen verweigert ");
} else {
System.out.println("Ich lasse " + einsteiger + " Passagiere eingestiegen");
einsteigen(); // Einer steigt ein
if (einsteiger > 1)
einsteigen(einsteiger-1); //Der Rest steigt ein
}
}

/**
* Aussteigen einer Anzahl von Pasagieren
* @param aussteiger ANzahl der aussteigenden Passagiere
*/
public void aussteigen(final int aussteiger) {
if (passagiere >= aussteiger) {
passagiere -= aussteiger;
} else {
System.out.println("Fehler: Flugzeug ist leer... ");
}
} // Ende der Methode aussteigen

/**
* berechnet das aktuelle Gewicht des Flugzeugs
* @return aktuelles Gewicht
*/
@Override
public double gewicht() {
return super.gewicht()+passagiere*durchschnittsgewicht;
}

}


 

 



book | by Dr. Radut