"Information Hiding" und Datenkapselung im abstrakten Datentyp

Ein Bestandteil der Objektorientierung ist das "information Hiding" welches schon von den abstrakten Datentypen her bekannt ist. Der Zustand des Objekts wird durch seine Attribute bestimmt. Die Attribute sollen aber nicht beliebig geändert werden können. Die Methoden agieren als Wächter für die Zustandsübergänge und "bewachen" so zu sagen die Attribute des Objekts. Dies hat zwei wesentliche Vorteile

• Der Entwickler kann denn Zustand seines Objekts bzw. Datentyps immer genau kontrollieren
• Der Entwickler kann die interne Implementierung des Objekts an neue Anforderungen anpassen ohne, dass er dies mit den Benutzern des Objekts kommunizieren muss. Die Methoden bilden hierdurch eine Schnittstelle zwischen der Implementierung und der externen Sicht des Objekts

Methoden erfüllen in diesem Kontext mehrere Aufgaben:

• Sie lesen die internen, geschützten Datenstrukturen aus
• Sie ändern die internen Datenstrukturen
• Sie können komplexe Berechnungen durchführen
• Sie können wiederum andere Objekte manipulieren (von denen der Benutzer nichts weiß)

Information Hiding: Ein Teilsystem darf nichts von der Implementierung eines anderen Teilsystems wissen

Klasse

Nach Wikipedia:

Unter einer Klasse versteht man in der objektorientierten Programmierung ein abstraktes Modell bzw. einen „Bauplan“ für eine Reihe von ähnlichen Objekten.

Die Klasse dient als Bauplan für Abbildung von realen „Objekten“ in Softwareobjekten und enthält Attribute (Eigenschaften) und Methoden (Verhaltensweisen) der Objekte. Verallgemeinernd könnte man auch sagen, dass eine Klasse dem Datentyp eines Objekts entspricht.

Klassen

• sind eine Menge von gleichartigen, individuellen Objekten
• sind ein schematische Modell
• beschreiben
  • Eigenschaften (die Attribute einer Klasse)
  • Verhalten (Methoden)

Objekt

Nach Wikipedia:

Ein Objekt bezeichnet in der objektorientierten Programmierung (OOP) ein Exemplar eines bestimmten Datentyps oder einer bestimmten Klasse (auch „Objekttyp“ genannt). In diesem Zusammenhang werden Objekte auch als „Instanzen einer Klasse“ bezeichnet. Objekte sind also konkrete Ausprägungen („Instanzen“) eines Objekttyps.

class Person() {
   private String name;
   public void setName(String n) { name = n;}
   public String getName() { return name;}
}

/**
 * Einfache Implementierung der Fabrikmethode (Factory)
 */
public class Factory {
     /**
     * privater Konstruktor der nur innerhalb der Klasse
     * aufgerufen werden kann
     */
    private Factory() {
      // Individuelle Initialisierung erfolgt hier
    }
     /**
     * Erzeugen der Objekte.
     */    
   public static Factory getInstance() {
        // Vorarbeiten
        instanz = new Factory();
        // Nacharbeiten
        return instanz;
    }}

/**
 * Einfache Implementierung des Einzelstueck (Singleton
 */
public class Einzelstueck {
    private static final Einzelstueck instanz;
     /**
     * privater Konstruktor der nur innerhalb der Klasse
     * aufgerufen werden kann
     */
    private Einzelstueck() {
      // Individuelle Initialisierung erfolgt hier
    }
     /**
     * Erzeugen des einzigen Objekts falls noch keines existiert.
     * Rückgabe des Objekts falls es schon existiert
     * Diese Methode ist statisch. Sie kann auch ohne die Existenz einer Instanz aufgerufen werden.
     * Die Methode ist die einzige öffentliche Methode
     */    
   public static Einzelstueck getInstance() {
        if (instanz == null) {
            instanz = new Einzelstueck();
        }
        return instanz;
    }}

/**
* Threadsichere Implementierung des Entwurfsmuster Einzelstueck (Singleton)
*/
public class Einzelstueck {
    private static Einzelstueck instanz = new Einzelstueck();
     /**     
     * privater Konstruktor der nur innerhalb der Klasse
     * aufgerufen werden kann
     */
    private Einzelstueck() {
      // Individuelle Initialisierung erfolgt hier
    }
     /**
     * Diese Methode ist statisch. Sie kann auch ohne die Existenz einer Instanz aufgerufen werden.
     * Die Methode ist die einzige öffentliche Methode
     */
    public static Einzelstueck getInstance() {
        return instanz;
    }
}

class Kraftwagen {
   public String nummernschild;
   public double leergewicht;
   public int neupreis;

   /**
   * Ein selbstgewählter Konstruktor
   * @param kennzeichen Das Kennzeichen des Fahrzeugs
   */
   public Kraftwagen(String kennzeichen) {
       nummernschild = kennzeichen;
   }

   public void drucken() {
      System.out.println("Nummernschild: " + nummernschild);
      System.out.println("Leergewicht: " +  leergewicht );
      System.out.println("Neupreis: " +  neupreis );
   }
}

class Fuhrpark{
   public static void main( String[] args ) {
      Kraftwagen wagen1 = new Kraftwagen("M-O-4711");
      Kraftwagen wagen2 = new Kraftwagen("MA-Y-11");
      Kraftwagen wagen3 = new Kraftwagen("S-AY-7");
      wagen1.leergewicht = 890.0d;
      wagen1.neupreis = 20000;
   
      wagen2.leergewicht = 1050.0d;
      wagen2.neupreis = 15000;

      wagen3.leergewicht = 1250.0d;
      wagen3.neupreis = 28000;

      wagen1.drucken();
      wagen2.drucken();
      wagen3.drucken();

   }
}

Kraftwagen wagen1 = new Kraftwagen ("M-O-4711");
Kraftwagen wagen2 = wagen1;
Kraftwagen wagen3 = new Kraftwagen("S-AY-7");

      ...
      wagen1.leergewicht = 980.0d;
      wagen1.drucken();
      ...

class Kraftwagen {
   public String nummernschild;
   public double leergewicht;
   private int neupreis;

   public int getNeupreis() { return neupreis;}

   ...
}

class Fuhrpark{
   static int anzahlFahrzeuge;
   public static void main( String[] args ) {
      int a = Fuhrpark.anzahlFahrzeuge;   // Aufruf ausserhalb der Klasse Fuhrpark
          a = anzahlFahrzeuge;            // Aufruf innerhalb der Klasse Fuhrpark
      ...
   }
}

class Fuhrpark{
   private static int anzahlFahrzeuge;
   public  static int getAnzahlFahrzeuge() {return anzahlFahrzeuge;}
      ...
   }
}

import class AddressBuch;
class Person {
   private String nachName;
   private String vorName;
...
   public Person (String vn, String nn) {
      this.setNachName(nn);
      vorName  = vn;
      Adressbuch.eintragen(this);
      ...
   }
   public Person setNachName(String nn) {
      nachName = nn;
      return this;
   }
}

import class AddressBuch;
class Person {
   private String nachName;
   private String vorName;
...
   public Person (String vorName, String nachName) {
      this.nachName = nachName;
      this.vorName  = vorName;
      Adressbuch.eintragen(this);
      ...
   }
}

import class AddressBuch;
class Person {
   private String nachName;
   private String vorName;
...
   public Person (String vorName, String nachName) {
      this.nachName = nachName;
      this.vorName  = vorName;
      Adressbuch.eintragen(this);
      ...
   }
   public Person() {
      /* Rufe den Konstruktor Person(String vorName, String nachName) auf
         Dieser Kommentar ist das einzige Kommando welches vor einem this()
         Aufruf stehen darf! 
      */
      this("John","Doe");
   }
}

Punkt p1 = new Punkt (3.3D, 4.1D);

package s1.block5;

   class Punkt {
      private double x;
      private double y;

      public Punkt (double xKoord, double yKoord) {
         x = xKoord;
         y = yKoord;
      }
   }

package s1.block5;

class Punkt {
   private double x;
   private double y;

   public Punkt (double xKoord, double yKoord) {...}
   public Punkt (Punkt p) { this(p.x,p.y);}
...
}

...
Punkt p1 = new Punkt();        // Initialisierung mit Default-Konstruktor ist nicht möglich
...

class Punkt {
   private double x;
   private double y;

   public static Punkt createPunkt (double xKoord, double yKoord) {
      Punkt pp = new Punkt(xKoord, yKoord);
      return pp;
      }

   private Punkt (double xx, double yy) { x=xx; y=yy;}

}
...
Punkt p1 = Punkt.createPunkt(1.1D,2.2D); 
Punkt p2 = new Punkt(4.4D,5.5D);      // Fehler!!
...

package s1.block5;

class Punkt {
   private double x;
   private double y;

   public Punkt (double xKoord, double yKoord) {
      x = xKoord;
      y = yKoord;
      }
}
...
Punkt p2 = new Punkt(1.1,2.2);
...

Javapakete (englisch packages) erlauben das Zusammenfassen von Klassen und "Interfaces" (Schnittstellen) in logischen Gruppen. Das Gruppieren von Klassen und Schnittstellen (Interfaces) in Pakete erlaubt: Bildung von eigenen Namensräumen für Klassen und Schnittstellen (Interfaces) Definierter Export von Klassen, bzw. "Information Hiding" von Klassen die nicht exportiert werden sollen Definierter Import von Klassen von Fremdpaketen in eigene Klassen Javapakete werden mit dem Schlüsselwort package deklariert und mit Hilfe des Schlüsselworts import importiert.

Daumenregeln

• Der Paketname steht durch einen Punkt getrennt vor dem Klassennamen
• Pakete können auch wieder Pakete enthalten
• Eine Klasse mit all Ihren äusseren Paketen ist ein eindeutiger Name
• Klassen ohne einen Paketnamen liegen im Default-Package
  • Klassen ohne Paketnamen zu verwenden geht nicht mehr in neueren Java Versionen!
• Nutzt man einen Klassennamen ohne den Paketkontext, so kommt sie aus dem gleichen Paket

Diese Daumenregelen reichen nicht um die Klausur zu bestehen...

 

package DemoPackage;
...
class Demonstration1 {
...
}
...
class Demonstration2 {
...
}

package Demo;

class A {
   public static void main(String[] args) {
      B.printHelloWorld();
   }
}

class B {
   public static void printHelloWorld() {
      System.out.println("Hello World!");
   }
}

set classpath=.;D:\Paket1;D:\Paket2

java -help
...
-classpath <class search path of directories and zip/jar files>
                  A : separated list of directories, JAR archives,
                  and ZIP archives to search for class files. ...

package Demo;

...
 public class A {
...

}

package DemoConsumer;
...
import Demo.A;
...
class Consumer {
...
   A.eineMethode(); // Aufruf der Methode eineMethode() der Klassse A
...
}

package DemoConsumer;
...
import Demo.*;
...
class Consumer {
...
   A.eineMethode();   // Aufruf der Methode Demo.A.eineMethode()
   B.andereMethode(); // Aufruf der Methode Demo.B.andereMethode()
...
}

package DemoConsumer;
...
class Consumer {
...
   Demo.A.main(); Aufruf der Methode main() der Klassse A
   Demo.B.printHelloWorld();
...
}

package test;
import java.lang.Math;
...
class calc {
   public void main(String[] args) {
      float x = Math.PI;
      float y = Math.cos(2*x);
   }
}

package test;
import static java.lang.Math.*;
...
class calc {
   public void main(String[] args) {
      float x = PI;
      float y = cos(2*x);
   }
}

5.4.1 Übung: Vektorrechnung Ein Vektor im zweidimensionalen Raum kann durch 2 reelle Zahlen dargestellt werden. Erstellen Sie eine Klasse "Vektor", die Operationen(Methoden) für die Addition von Vektoren, die Multiplikation eines Vektors mit einem Skalar, die Bildung des Skalarprodukts zweier Vektoren (d.h. die Summe der Produkte der entsprechenden Komponenten) anbietet. Schreiben Sie auch einen geeigneten Konstruktor und implementieren Sie eine Ausgabemethode drucken(). Normalisieren Sie die Vektoren nach jeder Berechnung, so dass ihr Betrag den Wert 1 hat.

5.4.2 Übung: Komplexe Zahlen

Eine komplexe Zahl (z.B. 3.2 + i1.75) besteht aus einem reellen und einem imaginären Teil, beide vom Typ double. Erstellen Sie eine Klasse Complex, die komplexe Zahlen implementiert. Als Operationen (Methoden) sollen die vier Grundrechenarten sowie ein geeigneter Konstruktor angeboten werden. Hinweis:

Für jede

z1 = a + bi a,b ∈ ℝ
z2 = c + di c,d ∈ ℝ  
z1 + z2 = (a + ib) + (c + id) = (a + c) + i(b + d)
z1 - z2 = (a + ib) - (c + id) = (a - c) + i(b - d)
z1 * z2 = (a + ib) * (c + id) = (a*c - b*d) + i(a*d + b*c)
z1 / z2 = (a + ib) / (c + id) = (a*c + b*d)/(c*c + d*d) + i(b*c - a*d)/(c*c + d*d)

Benutzen Sie die Klasse Main als Hauptprogramm um auf die Klasse Complex zuzugreifen:

package s1.block5; public class Main { public static void main(String[] args) { Complex a = new Complex (1.0,2.0); Complex b = new Complex (3.0,4.0); Complex c,d,e,f; c = a.add(b); d = a.sub(b); e = a.mul(b); f = a.div(b); System.out.println (" a = " + a.toString()); System.out.println (" b = " + b.toString()); System.out.println (" c = " + c.toString()); System.out.println (" d = " + d.toString()); System.out.println (" e = " + e.toString()); System.out.println (" f = " + f.toString()); } }

Die Klasse Complex soll neben den Methoden add(), sub(), mul(), div() auch eine Methode toString() besitzen, die eine Zeichenkette mit dem Wert der komplexen Zahl im Format "(1.1 + i 2.2)" für einen Realteil von 1.1 und einem Imaginärteil von 2.2 ausgibt.

5.4.3 Übung: Modellierung der Datenkapselung

Erweitern Sie eine Klasse Flugzeug.java von einer einfachen Klasse mit einem öffentlichen Attribut zu einer objektorientierten Klasse mit geschützten Attributen und Zugriffsmethoden.

Vorsicht: Der unten aufgeführte Quellcode liegt nicht im default package. Der Quellcode liegt in package block5! Achten Sie auf das korrekte Paket beim Anlegen der Klassen.

 

1. Kopieren Sie sich die beiden Klassen Flugzeug.java und FlugzeugTest.java auf Ihren Rechner. Die Klasse FlugzeugTest dient zum Testen und Starten der Anwendung.
2. (Schritt 1-5) Implementieren die notwendigen Attribute als geschützte Attribute. Die Namen der Attribute sind auch in der drucken() Methode zu finden
3. (Schritt 6) Implementieren Sie die Methode zur Berechnung des aktuellen Gewichts
4. (Schritt 7): Entfernen Sie die Kommentare in der drucken() Methode.
5. (Schritt 8): Implementieren Sie einen Konstruktor für die Klasse Flugzeug. Der Konstruktor soll die Eingaben auf unvernünftige Werte prüfen und die Eingaben korrigieren (Werte kleiner Null, Maximalgewicht kleiner Leergewicht etc.)
6. (Schritt 9):  Schalten Sie im Hauptprogramm FlugzeugTest.main() den Aufruf der Methode phase1() frei und testen Sie das Programm durch den Aufruf der Klasse FlugzeugTest
7. (Schritt 10-13): Implementieren Sie alle benötigten Methoden (siehe Diagramm)
8. (Schritt 14): Schalten Sie im Hauptprogramm FlugzeugTest.main() den Aufruf der Methode phase2() frei und testen Sie das Programm durch den Aufruf der Klasse FlugzeugTest
9. (Schritt 15): Schalten Sie im Hauptprogramm FlugzeugTest.main() den Aufruf der Methode phase3() frei und testen Sie das Programm durch den Aufruf der Klasse FlugzeugTest. Analysieren Sie die Umsteigeimplementierung in phase3(). Testen Sie einige Sonderfälle durch Veränderung der Passagierzahlen. Beispiel: Was geschieht wenn das defekte Flugzeug mehr Passagiere hat als das Ersatzflugzeug?
10. (Schritt 16): Implementieren Sie die Methode phase4() und schalten Sie im Hauptprogramm FlugzeugTest.main() den Aufruf der Methode phase4() frei. Testen Sie das Programm durch den Aufruf der Klasse FlugzeugTest.
    • Implementieren Sie in Phase das Umsteigen von einem Airbus mit 560 Passagieren in zwei kleinere Jumbo Jets.
    • Verändern Sie die Ausgangssituation derart, dass in den Jumbo Jets schon zu viele Passagiere eingestiegen sind und nicht alle Passagiere des Airbus untergebracht werden können. Werden stehen gelassene Passagiere auf der Konsole gemeldet?

Gegeben:

Klasse Flugzeug

package block5;
public class Flugzeug {

public String kennzeichen; // Ein Attribut vom Typ einer Zeichenkette
// 1. Privates Attribut zur Verwaltung der Passagierkapazität
// Tipp: Untersuchen Sie die Druckmethode zur Wahl der
// Variablennamen (1-5)!

// 2. Privates Attribut zur Verwaltung der aktuellen Pasagiere

// 3. Leergewicht in privates Attribut ändern
// Ein Attribut vom Typ einer Ganzzahl
// 4. Maximales Gewicht des Flugzeugs

// 5. Öffentliche Konstante für durchschn. Passagiergewicht
/**
* 8. Konstruktor implementieren
* Konstruktor der Klasse Flugzeug
* @param kennz Kennzeichen des Flugzeugs
* @param kapazitaet Passagierkapazität
* @param leergew Leergewicht in kg
* @param maxgew Maximalgewicht in kg
*/
/**
* einsteigen()
* 10. Fügt einen Passagier zum aktuellen Flugzeug hinzu
*/
/**
* aussteigen()
* 11. Entfernt einen Passagier des aktuellen Flugzeugs
*/

/**
* anzahlPassagiere()
* 12. Ausgabe der aktuellen Anzahl der Passagiere
* @return aktuelle Anzahl der Passagiere
*/

/**
* gewicht()
* 6. Berechnen des aktuellen Gewichts
* @return aktuelles Gewicht
*/

/**
* passagierkapazität()
* 13. Ausgabe der maximalen Anzahl der Passagiere
* @return Maximale Anzahl der Passagiere
*/

/**
* Eine Methode zum Drucken der Attributbelegung des Objekts
* Die Methode erfordert keine Eingaben. Sie erzeugt keine
* Aufgaben
*/
public void drucken() {
// 7. Vervollständigen der Druckmethode
System.out.println("*****************************");
System.out.println("Kennzeichen: " + kennzeichen);
//System.out.println("Leergewicht: " + leergewicht + "kg");
//System.out.println("Maximalgewicht: " + maxgewicht + "kg");
//System.out.println("Aktuelles Gewicht : " + gewicht() + "kg");
//System.out.println("Passagiere: " + passagiere);
//System.out.println("Maximal Anzahl P.: " + maxPassagiere);
System.out.println("*****************************");
}

}

Klasse FlugzeugTest.java

package block5;

public class FlugzeugTest {
public static Flugzeug jumbo;
public static Flugzeug a380;

/**
* Die Methode main() wir zum Starten des Programms benutzt
* @param args Übergabe von Konsolenparameter. Hier nicht genutzt
*/
public static void main(String[] args) {
//phase1(); // 9. Phase 1 testen
//phase2(); // 14. Phase 2 testen
//phase3(); // 15. Phase 3 testen
//phase4();
}

/* Entfernen zum Testen von Phase 1
public static void phase1() {
System.out.println(" Phase 1: 2 Flugzeuge");
// Erzeugen zweier Objekte
jumbo = new Flugzeug("D-ABYT",360,191000,400000);
a380 = new Flugzeug("D-AIMD",560,286000,500000);

// Drucken der beiden Objekte auf der Konsole
jumbo.drucken();
a380.drucken();
}
*/
/* Entfernen zum Testen von Phase 2
public static void phase2() {

// 7. Testen des vorangehenden Hauptprogramms
System.out.println(" Phase 2: Einsteigen mit Überbuchung");

System.out.println("Ein Passagier in Jumbo einsteigen");
jumbo.einsteigen();
jumbo.drucken();
System.out.println("300 Passagiere in Jumbo einsteigen");
for (int i=0; i<300; i++) jumbo.einsteigen();
jumbo.drucken();
System.out.println("200 Passagiere aus Jumbo aussteigen");
for (int i=0; i<200; i++) jumbo.aussteigen();
jumbo.drucken();
System.out.println("200 Passagiere aus Jumbo aussteigen");
for (int i=0; i<200; i++) jumbo.aussteigen();
jumbo.drucken();

}
*/
/* Entfernen zum Testen von Phase 3
public static void phase3() {

System.out.println(" Phase 3: Jumbo Flugzeugdefekt");
Flugzeug jumboAlt = new Flugzeug("D-ABYU",360,191000,400000);
Flugzeug a380Neu = new Flugzeug("D-AIME",560,286000,500000);
jumboAlt.drucken();
a380Neu.drucken();

System.out.println("300 Passagiere in JumboAlt einsteigen");
for (int i=0; i<300; i++) jumboAlt.einsteigen();
System.out.println("100 Passagiere in Airbus 380 Neu einsteigen");
for (int i=0; i<100; i++) a380Neu.einsteigen();
jumboAlt.drucken();
a380Neu.drucken();
System.out.println("Jumbo ist defekt. Alle in Airbus umsteigen");
while (jumboAlt.anzahlPassagiere()> 0) {
jumboAlt.aussteigen();
a380Neu.einsteigen();
}
System.out.println("Alle umgestiegen. Bereit zum Start");
jumboAlt.drucken();
a380Neu.drucken();
}
*/
/* Entfernen zum Testen von Phase 4
public static void phase4() {

System.out.println(" Phase 3: A380 Flugzeugdefekt mit 560 Passagieren");
Flugzeug jumbo1 = new Flugzeug("D-ABYV",360,191000,400000);
Flugzeug jumbo2 = new Flugzeug("D-ABYW",360,191000,400000);
Flugzeug a380Defekt = new Flugzeug("D-AIME",560,286000,500000);
jumbo1.drucken();
jumbo2.drucken();
a380Defekt.drucken();
System.out.println("50 Passagiere in Jumbo 1 und 2 einsteigen");
// 17. Lassen Sie 200 Passagiere in jeden Jumbo einsteigen
// Hiermit ist nicht mehr Platz für alle Airbuspassagiere
// Testen Sie den Fall der Überbuchung
for (int i=0; i<50; i++) {
jumbo1.einsteigen();
jumbo2.einsteigen();
}
System.out.println("560 Passagiere in Airbus 380 (defekt) einsteigen");
for (int i=0; i<560; i++) a380Defekt.einsteigen();
jumbo1.drucken();
jumbo2.drucken();
a380Defekt.drucken();

System.out.println("Airbus ist defekt. Alle in Jumbos umsteigen");
// 16. Implementieren Sie das Evakuieren des Airbus
// Beide Jumbos sollen falls notwendig benutzt werden
// Drucken Sie eine Warnung aus falls Sie einen Passagier
// nicht umsteigen lassen.

System.out.println("Airbus evakuiert. Bereit zum Start");
jumbo1.drucken();
jumbo2.drucken();
a380Defekt.drucken();
}
*/

}

5.4.4 Klassenvariablen (static variables)

Die Übung baut auf der vorherigen Übung aus. Bitte benutzen Sie die Musterlösung falls Sie die vorherige Übung nicht gelöst haben.

Implementieren Sie einen Zähler für jedes Flugzeugobjekt der Klasse Flugzeug welches erzeugt wird.

Empfohlenes Vorgehen:

• Implementieren Sie eine statische, geschützte Variable in der Klasse Flugzeug
• Inkrementieren Sie diese Variable bei jedem Konstruktoraufruf der Klasse Flugzeug
• Erweitern Sie die Methode drucken() und geben Sie die aktuelle Gesamtzahl von Flugzeugen aus
• Implementieren Sie eine öffentliche, statische Methode anzahlFlugzeuge() die den Zähler ausgibt
• Benutzen Sie das existierende Programm in der Klasse FlugzeugTest zum Testen Ihrer Implementierung

Lernziel: Unterscheiden der Variablen die objektspezifisch sind und derer die klassenspezifisch sind.

5.4.5 Überladene Methoden

Die Übung baut auf der vorherigen Übung aus. Bitte benutzen Sie die Musterlösung falls Sie die vorherige Übung nicht gelöst haben.

Implementieren sie überladene Methoden um das Einsteigen und Aussteigen in der Klasse Flugzeug zu vereinfachen. Die neuen Methoden haben

• die gleichen Namen wie die Methoden zum Ein- und Aussteigen eines einzelnen Passagiers,
• sie haben einen Übergabeparameter der die Anzahl der Passagiere zum Ein- und Aussteigen angibt
• es werden nur nicht negative Werte beachtet
• die Operation wird nur ausgeführt falls ALLE Passagiere in der aktuellen Anforderung ein- oder aussteigen können.

 Testen Sie die Implementierung mit der Klasse FlugzeugTest:

• Kopieren Sie die Methoden phase3() und phase4(). Benennen Sie diese um in phase3a(), phase4a()
• Ändern Sie die Implementierung deart, dass anstatt der for-Schleifen einzelne Aufrufe der neuen Methoden durchgeführt werden
  • Tipp: Ändern Sie die Flugzeugkennzeichen. Es werden neue Objekte angelegt. Es ist daher nützlich nicht zwei Flugzeuge mit dem gleichen Kennzeichen zu benutzen.
• Fügen die Methoden phase3a() und phase4a() in die main() Methode ein.
   

 

5.4.6 Teamübung: Fuhrparkmanagement

Die folgende Übung kann in einem Team von drei Parteien ausgeführt werden. Jede Partei implementiert eine Klasse. Die Übung findet in den folgenden Phasen statt.

1. Jedes Team entwirft die entsprechende Klasse und stellt die Klasse und alle öffentlichen Methoden und Variablen vor
2. Jedes Team implementiert seine Klasse und schreibt in der eigenen main() Methode einige Tests.
3. Alle Teams integrieren die Klassen zu einer lauffähigen Anwendung und testen sie
4. Jeweils 2 Teams stellen die Implementierungen wechselseitig vor und kontrollieren sie.

Anforderung an alle: Implementieren Sie sinnvolle Konstruktoren

Klasse 1: Kraftwagen

Anforderungen

• verwalten von
  • Verkaufspreis
  • Einkaufspreis
  • Kennzeichen
• Schutz der Variablen gegen inkonsistente Änderungen mit Hilfe von Zugriffs- und Auslesemethoden
• Methode drucken() zum Drucken der Attribute eines Wagens
• Zugriffsmethoden (Lesen/Schreiben) die alle drei Attribute kapseln und einfache Konsistenzchecks durchführen
• Implementierung eines Konstruktors der alle drei Parameter erfasst
  • Konsistenzcheck für die Preise: Ist der Verkaufspreis niedriger als der Einkaufspreis so werden die Werte getauscht.
• Zum Testen
  • Methode public static void main(String[] args) Anlegen von mehreren Kraftwagen mit verschiedenen Werten. Testen der Konsistenzprüfungen und Ausgaben der Werte

Klasse 2: Verkaeufer

Anforderungen

• verwalten von mindestens 2 Kraftwagen pro Verkäufer
• Verkäuferattribute und Methoden
  • Name
  • bisher gemachter Gewinn
  • gebundene Mittel (Summe aller Einkaufspreise aller Wagen)
  • Verkauf eines Wagens zu gegebenem Preis
    • Austragen aus dem Fahrzeugbestand
    • Pflegen des Gewinn
  • Aufnehmen eines Wagens in den persönlichen Bestand
    • Existierende Wagen im Bestand können ersatzlos ersetzt werden
  • Abfrage der Anzahl der Wagen im Bestand
  • Abfrage eines Kraftwagens aus dem Bestand
  •  Abfrage der gebundenen Mittel
  • Abfrage des geplanten Umsatzes
  • Methode drucken() zum Ausdrucken aller Daten des Verkäufers und aller Daten des Fahrzeugbestands
• Warnen bei Verkauf eines Wagen unter Einkaufspreis (Konsolenausgabe)
• Konstruktor zum Anlegen eines Verkäufers mit einem Namen. Der Namen darf nicht mehr geändert werden.
• Zum Testen:
  • Methode public static void main(String[] args) : Anlegen von drei Verkaeufern mit verschiedenen Werten und Fahrzeugen.
  • Verkauf diverser Fahrzeuge und Abfrage des Status mit Hilfe der Methode drucken()
  • Testen gegen diverse Fehlerfälle beim Verkauf

Klasse 3: Haendler

Anforderungen

• Verwalten von mindestens 3 Verkäufern
• Methoden
  • Einstellen von drei Verkäufern mit gegebenem Namen
  • Geschäftseröffnung mit Einstellen von 6 Fahrzeugen und beliebige Verteilung auf 3 Verkäufer.
  • Zugriff auf jeden der drei Verkäufer
  • gesamter Wert des Fuhrparks
  • gesamter Gewinn
  • gesamter Umsatz
  • verkaufe Fahrzeug für gegebenen Verkäufer (index) und Wagen des Verkäufers (index) zu gegebenen Preis
  • stelle neues Fahrzeug für Verkäufer (index) auf einer bestimmten Position des Verkäufers ein
  • suche des Verkäufers mit den größten Gewinn
  • Methode drucken() zur Ausgabe aller Daten des Unternehmens
• Zum Testen im Hauptprogramm public static void main(String[] args)
  • Ausdruck des Zustandes des gesamten Unternehmens
  • Berechnen der geplanten Erlöse des Fuhrparks
  • Berechnen des gesamten Werts der Flotte
  • Verkäufer mit dem meisten Umsätzen finden
  • Verkauf eines Wagens
  • Einstellen eines neuen Wagens

Hinweis: Die Spezifikation ist nicht vollständig. Das Team muss auf die folgenden Dinge selbst achten:

• Zeitplanung (Integrationstests benötigen viel Zeit!)
• Übergang der Phasen (inklusive notwendige Rückschritte)
• Gegenseitige Überprüfung der Spezifikation und sinngemässe Ergänzung
  • Man darf sich von anderen Klassen zusätzliche Methoden wünschen wenn es sinnvoll ist.. Man sollte dann auch zur Implementierung beitragen...
• Gegenseitige Hilfe bei der Implementierung ist erlaubt und erwünscht (Die einzelnen Teilaufgaben können unterschiedlich aufwendig sein!)

5.4.7 Mehrere Konstruktoren

Benutzen Sie das Beispiel der Klasse Flugzeug und der Klasse FlugzeugTest aus der Übung 5.4.5 Überladenen Methode.

Fügen zur Klasse Flugzeug einen weiteren Konstruktor hinzu. Der Konstruktor soll im Gegensatz zum existierenden Konstruktor keinen Parameter zur Passagierkapazität besitzen.

• Berechnen Sie die Passagierkapazität aus der Differenz des Maximal- und Leergewicht. Teilen Sie die Differenz durch das durchschnittliche Passagiergewicht.
• Sie müssen nicht alle Zuweisungen und Kontrollen des alten Konstruktors neu implementieren!
• Rufen Sie den alten Konstruktor mit dem this() Schlüsselwort auf.

Der Dokumentationskommentar zum zu implementierenden Konstruktor

     /**
     * Konstruktur der Klasse Flugzeug
     * Berechnet Passagierkapazität automatisch
     * @param kennz     Kennzeichen des Flugzeugs
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */

Hinweis:

1. Die Konstante PASSAGIERGEWICHT muss bei der Deklaration in der Klasse Flugzeug mit dem Schlüsselwort static versehen werden. Man darf zu diesem Zeitpunkt im Konstruktor noch keine Objektvariablen verwenden.
2. Vorsicht beim Kopieren. Die Klasse Flugzeug befindet sich im Paket block5. Kopieren Sie die Klasse Flugzeug in das Paket block6 oder verwenden Sie import Anweisungen!

Testen Sie das Programm mit der Routine phase6a() der Klasse FlugzeugTest:

package block6;
 
public class FlugzeugTest {
 
    /**
     * Die Methode main() wir zum Starten des Programms benutzt
     * @param args Übergabe von Konsolenparameter. Hier nicht genutzt
     */
 
    public static void main(String[] args) {
        phase6a(); 
        
    }
   
   /**
     * Testen des überladenen Konstruktors
     */
    public static void phase6a() {        
        Flugzeug b737_500 = new Flugzeug("D-ABIAA", 31900, 52000);
        Flugzeug b737_300 = new Flugzeug("D-ABIAB", 12815, 56470);
        System.out.println("Kapazität Boing 737-300: " + b737_300.passagierkapazitaet());
        System.out.println("Kapazität Boing 737-500: " + b737_500.passagierkapazitaet());
    }
}

Warum ist die automatisch berechnete Sitzkapazität der Boing 737 viel zu groß?

Was wurde bei der Modellierung der Klasse nicht berücksichtigt?

5.4.8 Flughafen Beispiel

Klasse Flugzeug

package block6;

/**
* Die Klasse Flugzeug dient zur Modellierung von Flugzeugen
* und vielem mehr...
* @author stsch
* @version 2.0
* @see Flughafen
*/
public class Flugzeug {

final static double durchschnittsgewicht = 75;
String kennzeichen;
/**
* aktuelle Anzahl der Passagiere
*/
int passagiere;

public int getPassagiere() {
return passagiere;
}

public void setPassagiere(int passagiere) {
this.passagiere = passagiere;
}
/**
* das aktuelle Gewicht. Bitte nicht mit rumspielen
*/
private double maximalesGewicht;
double minimalGewicht;

/**
* Konstruktor mit Kennzeichen vom Leitwerk. Z.Bsp. D-ABYD
* @param kennz Das amtliche Kennzeichen des Flugzeugs
*/
public Flugzeug(String kennz) {
kennzeichen = kennz;
System.out.println("Hallo, ich baue ein Flugzeug mit Namen " + kennzeichen);
}

/**
* Konstruktor mit Kennzeichen vom Leitwerk. Z.Bsp. D-ABYD
* @param minGewicht Minimalgewicht
* @param maxGewicht Maximalgewicht
*/
Flugzeug(String kennzei, double minGewicht, double maxGewicht) {
this(kennzei);
System.out.println("Hallo, ich baue ein Flugzeug mit Gewicht");
maximalesGewicht = maxGewicht;
// Kontrolle des Minimalgewichts
if ((minGewicht > 0) && (minGewicht <= maximalesGewicht)) {
minimalGewicht = minGewicht;
} else {
minimalGewicht = 5;
}
// Eine schwachsinnige Initialisierung
passagiere = 1;

}

public double maxG() {

/*
Das ist ein mehrzeiliger Kommentar
Hier auch noch
*/
double x = 17.1D;
x = Double.MAX_VALUE -10000D;
x = Double.MIN_VALUE;
if ( x == Double.POSITIVE_INFINITY) {
System.out.println("Oops. Unendlich");
}

return maximalesGewicht;
}

public void einsteigen() {
passagiere++;
}

public void einsteigen(int einsteiger) {
passagiere = passagiere + einsteiger;
}

/**
* aktuelles Gewicht des Flugzeug
* @return das aktuelle Gewicht in Kilogramm
*/
double gewicht() {
double ergebnis;
ergebnis = 1000 + passagiere * durchschnittsgewicht;
return ergebnis;
}

}

Klasse Flughafen

package block6;

/**
*
* @author stsch
*/
public class Flughafen {

String name;
Flugzeug gate1;
Flugzeug gate2;
Flugzeug gate3;
Flugzeug gate4;
Flugzeug gate5;
Flugzeug gate6;

public static void main(String[] args) {
Flughafen pb;
pb = new Flughafen();
pb.name = "Paderborn";

Flugzeug lh1 = new Flugzeug("D-A123");
lh1.passagiere = 23;

Flugzeug lh2 = new Flugzeug("D-A456",3333.0D,100000D);
lh2.passagiere = 11;

pb.gate1 = lh1;
lh1.einsteigen();
lh1.einsteigen();
double meinGewicht = lh1.gewicht();
lh1.gewicht();

pb.gate2 = lh2;
lh2.einsteigen(88);

System.out.println("Mein Flughafen: " + pb.name);
System.out.println("Gate 1: " + pb.gate1.kennzeichen +
", Passagiere: " + pb.gate1.passagiere +
", akt. Gew.: " + pb.gate1.gewicht());
System.out.println("Gate 2: " + pb.gate2.kennzeichen +
", Passagiere: " + pb.gate2.passagiere);

if (pb.gate3 == null) {
System.out.println("Gate 3: leer");
} else {
System.out.println("Gate 3: " + pb.gate3.kennzeichen);
}

Flughafen fra;
fra = new Flughafen();
fra.name = "Rhein/Main";

}

}
 

 

5.5.1 Vektorrechnung

package s1.block5;
public class Vektor {
private double x;
    private double y;
Vektor(double xx, double yy) {
        x = xx;
        y = yy;
        normalisierung();
    }
public void normalisierung() {
        double laenge = Math.sqrt(x*x+y*y);
        x = x/laenge;
        y = y/laenge;
    }
public void addition(Vektor v) {
        x = v.x + x;
        y = v.y + y;
        normalisierung();
    }
    public void multi(double skalar) {
        x = x * skalar;
        y = y * skalar;
        // normalisierung();
    }
    public void skalarprodukt(Vektor v) {
        x = x * v.x;
        y = y * v.y;
        normalisierung();
    }
    public void drucken() {
        System.out.println("(" + x + "," + y + ")");
    }
public static void main(String[] args) {
        Vektor a = new Vektor(1.0, 2.0);
        Vektor b = new Vektor(2.0, 1.0);
        Vektor c = new Vektor(3.0, 3.0);
a.drucken();
        b.drucken();
        c.drucken();
a.addition(b);
        a.drucken();
        a.multi(10);
        a.drucken();
        b.skalarprodukt(c);
        b.drucken();
    }
}

5.5.2 Komplexe Zahlen

package s1.block5;
public class Complex {

    private double re; // Realteil der Zahl
    private double im; // Imaginaerteil der Zahl (i)

    public Complex(double r, double i) {
        re = r;
        im = i;
    }

    public Complex add(Complex z) {
        Complex k = new Complex(re+z.re,im+z.im);
        return k;
    }

    public Complex sub(Complex z) {
        Complex k = new Complex(re-z.re,im-z.im);
        return k;
    }

    public Complex mul(Complex z) {
        Complex k = new Complex(re*z.re-im*z.im,re*z.im+im*z.re);
        return k;
    }

    public Complex div(Complex z) {
        Complex k = new Complex((re*z.re+im*z.im)/(z.im*z.im+z.im*z.im),
                                (im*z.re-im*z.im)/(z.im*z.im+z.im*z.im));
        return k;
    }

     public String toText() {
        String s = "(" + re + " + i" + im + ")";
        return s;
    }
}

5.5.3 Übung: Modellierung der Datenkapselung

Klasse FlugzeugTest.java

package s1.block5;
public class FlugzeugTest {
    public static Flugzeug jumbo;
    public static Flugzeug a380;


    /**
     * Die Methode main() wir zum Starten des Programms benutzt
     * @param args Übergabe von Konsolenparameter. Hier nicht genutzt
     */
    public static void main(String[] args) {
        phase1(); // 9.  Phase 1 testen
        phase2(); // 14. Phase 2 testen
        phase3(); // 15. Phase 3 testen
        phase4();
    }

    public static void phase1() {
        System.out.println(" Phase 1: 2 Flugzeuge");
        // Erzeugen zweier Objekte
        jumbo = new Flugzeug("D-ABYT",360,191000,400000);
        a380 = new Flugzeug("D-AIMD",560,286000,500000);

        // Drucken der beiden Objekte auf der Konsole
        jumbo.drucken();
        a380.drucken();
    }

    public static void phase2() {
        // 7. Testen des vorangehenden Hauptprogramms
        System.out.println(" Phase 2: Einsteigen mit Überbuchung");
        System.out.println("Ein Passagier in Jumbo einsteigen");
        jumbo.einsteigen();
        jumbo.drucken();
        System.out.println("300 Passagiere in Jumbo einsteigen");
        for (int i=0; i<300; i++) jumbo.einsteigen();
        jumbo.drucken();
        System.out.println("200 Passagiere aus Jumbo aussteigen");
        for (int i=0; i<200; i++) jumbo.aussteigen();
        jumbo.drucken();
        System.out.println("200 Passagiere aus Jumbo aussteigen");
        for (int i=0; i<200; i++) jumbo.aussteigen();
        jumbo.drucken();  
    }

    public static void phase3() {
        System.out.println(" Phase 3: Jumbo Flugzeugdefekt");
        Flugzeug jumboAlt = new Flugzeug("D-ABYU",360,191000,400000);
        Flugzeug a380Neu = new Flugzeug("D-AIME",560,286000,500000);
        jumboAlt.drucken();
        a380Neu.drucken();

        System.out.println("300 Passagiere in JumboAlt einsteigen");
        for (int i=0; i<300; i++) jumboAlt.einsteigen();
        System.out.println("100 Passagiere in Airbus 380 Neu einsteigen");
        for (int i=0; i<100; i++) a380Neu.einsteigen();
        jumboAlt.drucken();
        a380Neu.drucken();
        System.out.println("Jumbo ist defekt. Alle in Airbus umsteigen");
        while (jumboAlt.anzahlPassagiere()> 0) {
            jumboAlt.aussteigen();
            a380Neu.einsteigen();
        }
        System.out.println("Alle umgestiegen. Bereit zum Start");
        jumboAlt.drucken();
        a380Neu.drucken();
    }

    public static void phase4() {        
        System.out.println(" Phase 4: A380 Flugzeugdefekt mit 560 Passagieren");
        Flugzeug jumbo1 = new Flugzeug("D-ABYV",360,191000,400000);
        Flugzeug jumbo2 = new Flugzeug("D-ABYW",360,191000,400000);
        Flugzeug a380Defekt = new Flugzeug("D-AIME",560,286000,500000);
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
        System.out.println("50 Passagiere in Jumbo 1 und 2 einsteigen");
        // 17. Lassen Sie 200 Passagiere in jeden Jumbo einsteigen
        //     Hiermit ist nicht mehr Platz für alle Airbuspassagiere
        //     Testen Sie den Fall der Überbuchung
        for (int i=0; i<50; i++) {
            jumbo1.einsteigen();
            jumbo2.einsteigen();
        }
        System.out.println("560 Passagiere in Airbus 380 (defekt) einsteigen");
        for (int i=0; i<560; i++) a380Defekt.einsteigen();
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();

        System.out.println("Airbus ist defekt. Alle in Jumbos umsteigen");
        // 16. Implementieren Sie das Evakuieren des Airbus
        //     Beide Jumbos sollen benutzt werden falls notwendig
        //     Drucken Sie eine Warnung aus falls Sie einen Passagier
        //     nicht umsteigen lassen.
        while (a380Defekt.anzahlPassagiere()> 0) {
            if (jumbo1.anzahlPassagiere() < jumbo1.passagierkapazität()) {
                a380Defekt.aussteigen();
                jumbo1.einsteigen();
            }
            else // Jumbo 1 is voll...
            if (jumbo2.anzahlPassagiere() < jumbo2.passagierkapazität()) {
                a380Defekt.aussteigen();
                jumbo2.einsteigen();
            }
            else // Beide Jumbos sind voll
            {
            a380Defekt.aussteigen();
            System.out.println("Ein Passagier bleibt zurück...");
            }

        }
        System.out.println("Airbus evakuiert. Bereit zum Start");
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
    }
}

Klasse Flugzeug.java

package s1.block5;
public class Flugzeug {
    public String kennzeichen; // Ein Attribut vom Typ einer Zeichenkette
    // 1. Privates Attribut zur Verwaltung der Passagierkapazität
    //     Tipp: Untersuchen Sie die Druckmethode zur Wahl der
    //           Variablennamen (1-5)!
    private int maxPassagiere;
    // 2. Privates Attribut zur Verwaltung der aktuellen Pasagiere
    private int passagiere;
    // 3. Leergewicht in privates Attribut ändern
    public int leergewicht; // Ein Attribut vom Type einer Ganzzahl
    // 4. Maximales Gewicht des Flugzeugs
    private int maxgewicht;
    // 5. Öffentliche Konstante für durchschn. Passagiergewicht
    public final static int PASSAGIERGEWICHT = 85;

     /**
     * 8. Konstruktor implementieren
     * Konstruktur der Klasse Flugzeug
     * @param kennz     Kennzeichen des Flugzeugs
     * @param kapazitaet Passagierkapazität
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
    public Flugzeug(String kennz, int kapazitaet, int leergew, int maxgew) {
        kennzeichen = kennz;
        // Prüfen ob Kapazität größere Null ist
        if (kapazitaet >= 0) {
            maxPassagiere = kapazitaet;
        } else {
            maxPassagiere = 0;
        }
        // Prüfen ob Leergewicht größer Null ist
        if (leergew > 0) {
            leergewicht = leergew;
        } else {
            leergewicht = 0;
        }
        // Prüfen ob Maximalgewicht größer-gleich Leergeicht ist.
        if (maxgew > leergewicht) {
            maxgewicht = maxgew;
        } else {
            maxgewicht = leergewicht; // Viel Spass...
        }
    }

     /**
     * 10. Fügt einen Passagier zum aktuellen Flugzeug hinzu
     */
    public void einsteigen() {
        if (passagiere < maxPassagiere) {
            passagiere++;
        }
    }

     /**
     * 11. Entfernt einen Passagier des aktuellen Flugzeugs 
     */
    public void aussteigen() {
        if (passagiere > 0) {
            passagiere--;
        }
    }

    /** 
     * 12. Ausgabe der aktuellen Anzahl der Passagiere
     * @return aktuelle Anzahl der Passagiere 
     */
    public int anzahlPassagiere() {return passagiere;}


    /**
     * 6. Berechnen des aktuellen Gewichts
     * @return aktuelles Gewicht
     */
    public int gewicht() {
    return (leergewicht+ passagiere*PASSAGIERGEWICHT);}

    /** 
     * 13. Ausgabe der maximalen Anzahl der Passagiere
     * @return Maximale Anzahl der Passagiere 
     */
    public int passagierkapazitaet() {return maxPassagiere;}

     /**
     * Eine Methode zum Drucken der Attributbelegung des Objekts
     * Die Methode erfordert keine Eingaben. Sie erzeugt keine
     * Ausgaben
     */
    public void drucken() {
        // 7. Vervollständigen der Druckmethode
        System.out.println("*****************************");
        System.out.println("Kennzeichen:        " + kennzeichen);
        System.out.println("Leergewicht:        " + leergewicht + "kg");
        System.out.println("Maximalgewicht:     " + maxgewicht + "kg");
        System.out.println("Aktuelles Gewicht : " + gewicht() + "kg");
        System.out.println("Passagiere:         " + passagiere);
        System.out.println("Maximal Anzahl P.:  " + maxPassagiere);
        System.out.println("*****************************");
    }

    public int passagierkapazität() {return maxPassagiere;}
}

5.5.4 Lösung: Statische Klassenattribute

Klasse Flugzeug

Erweitert um die statische Variable

package s1.block5;
public class Flugzeug {
public String kennzeichen; // Ein Attribut vom Typ einer Zeichenkette
    // 1. Privates Attribut zur Verwaltung der Passagierkapazität
    //     Tipp: Untersuchen Sie die Druckmethode zur Wahl der
    //           Variablennamen (1-5)!
    private int maxPassagiere;
    // 2. Privates Attribut zur Verwaltung der aktuellen Pasagiere
    private int passagiere;
    // 3. Leergewicht in privates Attribut ändern
    public int leergewicht; // Ein Attribut vom Type einer Ganzzahl
    // 4. Maximales Gewicht des Flugzeugs
    private int maxgewicht;
    // 5. Öffentliche Konstante für durchschn. Passagiergewicht
    public final int PASSAGIERGEWICHT = 85;

// Anzahl aller erzeugten Flugzeuge
    private static int objekte;

     /**
     * 8. Konstruktor implementieren
     * Konstruktur der Klasse Flugzeug
     * @param kennz     Kennzeichen des Flugzeugs
     * @param kapazitaet Passagierkapazität
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
    public Flugzeug(String kennz, int kapazitaet, int leergew, int maxgew) {
        kennzeichen = kennz;
objekte++;
        // Prüfen ob Kapazität größere Null ist
        if (kapazitaet >= 0) {
            maxPassagiere = kapazitaet;
        } else {
            maxPassagiere = 0;
        }
        // Prüfen ob Leergewicht größer Null ist
        if (leergew > 0) {
            leergewicht = leergew;
        } else {
            leergewicht = 0;
        }
        // Prüfen ob Maximalgewicht größer-gleich Leergeicht ist.
        if (maxgew > leergewicht) {
            maxgewicht = maxgew;
        } else {
            maxgewicht = leergewicht; // Viel Spass...
        }
    }

     /**
     * 10. Fügt einen Passagier zum aktuellen Flugzeug hinzu
     */
    public void einsteigen() {
        if (passagiere < maxPassagiere) {
            passagiere++;
        }
    }

     /**
     * 11. Entfernt einen Passagier des aktuellen Flugzeugs 
     */
    public void aussteigen() {
        if (passagiere > 0) {
            passagiere--;
        }
    }

    /** 
     * 12. Ausgabe der aktuellen Anzahl der Passagiere
     * @return aktuelle Anzahl der Passagiere 
     */
    public int anzahlPassagiere() {return passagiere;}


    /**
     * 6. Berechnen des aktuellen Gewichts
     * @return aktuelles Gewicht
     */
    public int gewicht() {
    return (leergewicht+ passagiere*PASSAGIERGEWICHT);}

    /** 
     * 13. Ausgabe der maximalen Anzahl der Passagiere
     * @return Maximale Anzahl der Passagiere 
     */
    public int passagierkapazitaet() {return maxPassagiere;}

/**
     * 
     * @return Anzahl aller erzeugten Objekte der Klasse Flugzeug 
     */
    public int anzahlFlugzeuge() {return objekte;}
 
     /**
     * Eine Methode zum Drucken der Attributbelegung des Objekts
     * Die Methode erfordert keine Eingaben. Sie erzeugt keine
     * Ausgaben
     */
    public void drucken() {
        // 7. Vervollständigen der Druckmethode
        System.out.println("*****************************");
        System.out.println("Kennzeichen:        " + kennzeichen);
        System.out.println("Leergewicht:        " + leergewicht + "kg");
        System.out.println("Maximalgewicht:     " + maxgewicht + "kg");
        System.out.println("Aktuelles Gewicht : " + gewicht() + "kg");
        System.out.println("Passagiere:         " + passagiere);
        System.out.println("Maximal Anzahl P.:  " + maxPassagiere);
System.out.println("******************** " + objekte + " Flugz.");
    }

    public int passagierkapazität() {return maxPassagiere;}
}

5.5.5 Überladene Methoden

Klasse Flugzeug

package s1.block5;
public class Flugzeug {

    public String kennzeichen; // Ein Attribut vom Typ einer Zeichenkette
 
    // 1. Privates Attribut zur Verwaltung der Passagierkapazität
//     Tipp: Untersuchen Sie die Druckmethode zur Wahl der
    //           Variablennamen (1-5)!
    private int maxPassagiere;
    // 2. Privates Attribut zur Verwaltung der aktuellen Pasagiere
    private int passagiere;
    // 3. Leergewicht in privates Attribut ändern
    public int leergewicht; // Ein Attribut vom Type einer Ganzzahl
    // 4. Maximales Gewicht des Flugzeugs
    private int maxgewicht;
    // 5. Öffentliche Konstante für durchschn. Passagiergewicht
    public final int PASSAGIERGEWICHT = 85;

    // Anzahl aller erzeugten Flugzeuge
    private static int objekte;

     /**
     * 8. Konstruktor implementieren
     * Konstruktur der Klasse Flugzeug
     * @param kennz     Kennzeichen des Flugzeugs
     * @param kapazitaet Passagierkapazität
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
    public Flugzeug(String kennz, int kapazitaet, int leergew, int maxgew) {
        kennzeichen = kennz;
        objekte++;
        // Prüfen ob Kapazität größere Null ist
        if (kapazitaet >= 0) {
            maxPassagiere = kapazitaet;
        } else {
            maxPassagiere = 0;
        }
        // Prüfen ob Leergewicht größer Null ist
        if (leergew > 0) {
            leergewicht = leergew;
        } else {
            leergewicht = 0;
        }
        // Prüfen ob Maximalgewicht größer-gleich Leergeicht ist.
        if (maxgew > leergewicht) {
            maxgewicht = maxgew;
        } else {
            maxgewicht = leergewicht; // Viel Spass...
        }
    }

     /**
     * 10. Fügt einen Passagier zum aktuellen Flugzeug hinzu
     */
    public void einsteigen() {
        if (passagiere < maxPassagiere) {
            passagiere++;
        }
    }

/**
     * 
     * @param anzahl Anzahl der Passagiere die einsteigen sollen
     */
    public void einsteigen(int anzahl) {
        if ((anzahl >0) && (passagiere+anzahl) <= maxPassagiere) {
            passagiere+= anzahl;
        }
    }

     /**
     * 11. Entfernt einen Passagier des aktuellen Flugzeugs 
     */
    public void aussteigen() {
        if (passagiere > 0) {
            passagiere--;
        }
    }

/**
     * 
     * @param anzahl Anzahl der Passagiere die aussteigen sollen
     */
    public void aussteigen(int anzahl) {
        if ((anzahl >0) && (passagiere-anzahl) >=0) {
            passagiere-= anzahl;
        }
    }

    /** 
     * 12. Ausgabe der aktuellen Anzahl der Passagiere
     * @return aktuelle Anzahl der Passagiere 
     */
    public int anzahlPassagiere() {return passagiere;}


    /**
     * 6. Berechnen des aktuellen Gewichts
     * @return aktuelles Gewicht
     */
    public int gewicht() {
    return (leergewicht+ passagiere*PASSAGIERGEWICHT);}

    /** 
     * 13. Ausgabe der maximalen Anzahl der Passagiere
     * @return Maximale Anzahl der Passagiere 
     */
    public int passagierkapazitaet() {return maxPassagiere;}

    /**
     * 
     * @return Anzahl aller erzeugten Objekte der Klasse Flugzeug 
     */
    public static int anzahlFlugzeuge() {return objekte;}

    /**
     * Eine Methode zum Drucken der Attributbelegung des Objekts
     * Die Methode erfordert keine Eingaben. Sie erzeugt keine
     * Ausgaben
     */
    public void drucken() {
        // 7. Vervollständigen der Druckmethode
        System.out.println("*****************************");
        System.out.println("Kennzeichen:        " + kennzeichen);
        System.out.println("Leergewicht:        " + leergewicht + "kg");
        System.out.println("Maximalgewicht:     " + maxgewicht + "kg");
        System.out.println("Aktuelles Gewicht : " + gewicht() + "kg");
        System.out.println("Passagiere:         " + passagiere);
        System.out.println("Maximal Anzahl P.:  " + maxPassagiere);
        System.out.println("******************** " + objekte + " Flugz.");
    }

    public int passagierkapazität() {return maxPassagiere;}
}

Klasse FlugzeugTest

package s1.block5;
public class FlugzeugTest {
public static Flugzeug jumbo;
    public static Flugzeug a380;

     /**
     * Die Methode main() wir zum Starten des Programms benutzt
     * @param args Übergabe von Konsolenparameter. Hier nicht genutzt
     */
    public static void main(String[] args) {
        phase1(); // 9.  Phase 1 testen
        phase2(); // 14. Phase 2 testen
        phase3(); // 15. Phase 3 testen
        phase4();
phase3a();
        phase4a();
    }
public static void phase1() {
        System.out.println(" Phase 1: 2 Flugzeuge");
        // Erzeugen zweier Objekte
        jumbo = new Flugzeug("D-ABYT", 360, 191000, 400000);
        a380 = new Flugzeug("D-AIMD", 560, 286000, 500000);

        // Drucken der beiden Objekte auf der Konsole
        jumbo.drucken();
        a380.drucken();
    }
public static void phase2() {

        // 7. Testen des vorangehenden Hauptprogramms
        System.out.println(" Phase 2: Einsteigen mit Überbuchung");

        System.out.println("Ein Passagier in Jumbo einsteigen");
        jumbo.einsteigen();
        jumbo.drucken();
        System.out.println("300 Passagiere in Jumbo einsteigen");
        for (int i = 0; i < 300; i++) {
            jumbo.einsteigen();
        }
        jumbo.drucken();
        System.out.println("200 Passagiere aus Jumbo aussteigen");
        for (int i = 0; i < 200; i++) {
            jumbo.aussteigen();
        }
        jumbo.drucken();
        System.out.println("200 Passagiere aus Jumbo aussteigen");
        for (int i = 0; i < 200; i++) {
            jumbo.aussteigen();
        }
        jumbo.drucken();
}
public static void phase3() { 
        System.out.println(" Phase 3: Jumbo Flugzeugdefekt");
        Flugzeug jumboAlt = new Flugzeug("D-ABYU", 360, 191000, 400000);
        Flugzeug a380Neu = new Flugzeug("D-AIME", 560, 286000, 500000);
        jumboAlt.drucken();
        a380Neu.drucken();

        System.out.println("300 Passagiere in JumboAlt einsteigen");
        for (int i = 0; i < 300; i++) {
            jumboAlt.einsteigen();
        }
        System.out.println("100 Passagiere in Airbus 380 Neu einsteigen");
        for (int i = 0; i < 100; i++) {
            a380Neu.einsteigen();
        }
        jumboAlt.drucken();
        a380Neu.drucken();
        System.out.println("Jumbo ist defekt. Alle in Airbus umsteigen");
        while (jumboAlt.anzahlPassagiere() > 0) {
            jumboAlt.aussteigen();
            a380Neu.einsteigen();
        }
        System.out.println("Alle umgestiegen. Bereit zum Start");
        jumboAlt.drucken();
        a380Neu.drucken();
    }
public static void phase4() {
        System.out.println(" Phase 4: A380 Flugzeugdefekt mit 560 Passagieren");
        Flugzeug jumbo1 = new Flugzeug("D-ABYV", 360, 191000, 400000);
        Flugzeug jumbo2 = new Flugzeug("D-ABYW", 360, 191000, 400000);
        Flugzeug a380Defekt = new Flugzeug("D-AIME", 560, 286000, 500000);
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
        System.out.println("50 Passagiere in Jumbo 1 und 2 einsteigen");
        // 17. Lassen Sie 200 Passagiere in jeden Jumbo einsteigen
        //     Hiermit ist nicht mehr Platz für alle Airbuspassagiere
        //     Testen Sie den Fall der Überbuchung
        for (int i = 0; i < 50; i++) {
            jumbo1.einsteigen();
            jumbo2.einsteigen();
        }
        System.out.println("560 Passagiere in Airbus 380 (defekt) einsteigen");
        for (int i = 0; i < 560; i++) {
            a380Defekt.einsteigen();
        }
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();

        System.out.println("Airbus ist defekt. Alle in Jumbos umsteigen");
        // 16. Implementieren Sie das Evakuieren des Airbus
        //     Beide Jumbos sollen falls notwendig benutzt werden
        //     Drucken Sie eine Warnung aus falls Sie einen Passagier
        //     nicht umsteigen lassen.
        while (a380Defekt.anzahlPassagiere() > 0) {
            if (jumbo1.anzahlPassagiere() < jumbo1.passagierkapazitaet()) {
                a380Defekt.aussteigen();
                jumbo1.einsteigen();
            } else // Jumbo 1 is voll...
            if (jumbo2.anzahlPassagiere() < jumbo2.passagierkapazitaet()) {
                a380Defekt.aussteigen();
                jumbo2.einsteigen();
            } else // Beide Jumbos sind voll
            {
                a380Defekt.aussteigen();
                System.out.println("Ein Passagier bleibt zurück...");
            }
        }
        System.out.println("Airbus evakuiert. Bereit zum Start");
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
    }
   public static void phase3a() {
        System.out.println(" Phase 3a: Jumbo Flugzeugdefekt");
        Flugzeug jumboAlt = new Flugzeug("D-ABYA", 360, 191000, 400000);
        Flugzeug a380Neu = new Flugzeug("D-AIMF", 560, 286000, 500000);
        jumboAlt.drucken();
        a380Neu.drucken();
 
        System.out.println("300 Passagiere in JumboAlt einsteigen");
        jumboAlt.einsteigen(300);
        System.out.println("100 Passagiere in Airbus 380 Neu einsteigen");
        a380Neu.einsteigen(100);
        jumboAlt.drucken();
        a380Neu.drucken();
        System.out.println("Jumbo ist defekt. Alle in Airbus umsteigen");
        int warteRaum = jumbo.anzahlPassagiere();
        jumboAlt.aussteigen(jumbo.anzahlPassagiere());
        // Zu diesem Zeitpunkt hat man ohne warteRaum die Passagiere des
        // Jumbos vergessen!
        a380Neu.einsteigen(warteRaum);
        System.out.println("Alle umgestiegen. Bereit zum Start");
        jumboAlt.drucken();
        a380Neu.drucken();
    }
    public static void phase4a() {
 
        System.out.println(" Phase 4a: A380 Flugzeugdefekt mit 560 Passagieren");
        Flugzeug jumbo1 = new Flugzeug("D-ABYX", 360, 191000, 400000);
        Flugzeug jumbo2 = new Flugzeug("D-ABYY", 360, 191000, 400000);
        Flugzeug a380Defekt = new Flugzeug("D-AIMG", 560, 286000, 500000);
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
        System.out.println("50 Passagiere in Jumbo 1 und 2 einsteigen");
        jumbo1.einsteigen(50);
        jumbo2.einsteigen(50);
        System.out.println("560 Passagiere in Airbus 380 (defekt) einsteigen");
        a380Defekt.einsteigen(560);
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
 
        System.out.println("Airbus ist defekt. Alle in Jumbos umsteigen");
        // 16. Implementieren Sie das Evakuieren des Airbus
        //     Beide Jumbos sollen falls notwendig benutzt werden
        //     Drucken Sie eine Warnung aus falls Sie einen Passagier
        //     nicht umsteigen lassen.
        // Alle aus Airbus in den Warteraum
        int warteRaum = a380.anzahlPassagiere();
        int freiJumbo1 = jumbo1.passagierkapazitaet() - jumbo1.anzahlPassagiere();
        a380Defekt.aussteigen(a380.anzahlPassagiere());
        if (warteRaum <= freiJumbo1) { // Alle Passagiere passen in jumbo1
            jumbo1.einsteigen(warteRaum);
        } else { // Nur ein Teil der Passagiere kann mitgenommen werden
            jumbo1.einsteigen(freiJumbo1);  // Jumbo ist voll
            warteRaum -= freiJumbo1; // warteRaum reduziert
            // Nutzen des zweiten Jumbo...
            int freiJumbo2 = jumbo2.passagierkapazitaet() - jumbo2.anzahlPassagiere();
            if (warteRaum <= freiJumbo2) { // Alle Passagiere passen in jumbo2
                jumbo2.einsteigen(warteRaum);
            } else { // Nur ein Teil der Passagiere kann mitgenommen werden
                jumbo2.einsteigen(freiJumbo2); // jumbo2 ist jetzt voll
                warteRaum -= freiJumbo2; // warteRaum reduziert
                System.out.println(warteRaum + " Passagiere können nicht umbebucht werden.");
            }
        }
        System.out.println("Airbus evakuiert. Bereit zum Start");
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
    }
}

Flughafen

package s1.block5;
public class Flughafen {
    String name;
    public Flugzeug gate1;
    Flugzeug gate2;
    Flugzeug gate3;
    public Flugzeug gate4;
    Flugzeug gate5;
    Flugzeug gate6;
    double treibstoffLager;
public static void main(String[] args) {
        Flughafen pad = new Flughafen();
        pad.name="Paderborn";
        pad.treibstoffLager = 1000000;

        // Boeing 747, https://de.wikipedia.org/wiki/Boeing_747#747-400
        Flugzeug lh1 = new Flugzeug("ABTL",450000,200,200);
        lh1.einsteigen();
double aktGewicht=lh1.gewicht();
        System.out.println("gewicht" + aktGewicht);
lh1.drucken();
pad.gate1 = lh1;
        pad.gate2 = lh1;
        System.out.println("Boarding für lh1 nach Mannheim...");
        pad.gate1.einsteigen();
        pad.gate1.einsteigen();
        pad.gate2.einsteigen();
        lh1.einsteigen();
lh1.drucken();
// Airbus A380 https://de.wikipedia.org/wiki/Airbus_A380#A380-800
        Flugzeug lh2 = new Flugzeug("ABTL",500000,100,200);
lh2.einsteigen();
lh2.drucken();
pad.gate2 = lh2;
System.out.println("*** Unser Flughafen ***");
        System.out.println("Flughafen " + pad.name);
        System.out.println("Am Gate 1: " + pad.gate1.kennzeichen);
        System.out.println("Am Gate 2: " + pad.gate2.kennzeichen);
        System.out.println("Am Gate 3: " + pad.gate3);
        System.out.println("Treibstoff: " + pad.treibstoffLager);
        System.out.println("***********************");
// Hänge Flugzeug um. mover bewegt Flugzeug
        // von Gate 1 nach Gate 3
Flugzeug mover = pad.gate1;
        pad.gate1=null;
System.out.println("*** Unser Flughafen ***");
        System.out.println("Flughafen " + pad.name);
        System.out.println("Am Gate 1: " + pad.gate1);
        System.out.println("Am Gate 2: " + pad.gate2.kennzeichen);
        System.out.println("Am Gate 3: " + pad.gate3);
        System.out.println("Treibstoff: " + pad.treibstoffLager);
        System.out.println("***********************");
pad.gate3= mover;
        mover=null;
System.out.println("*** Unser Flughafen ***");
        System.out.println("Flughafen " + pad.name);
        System.out.println("Am Gate 1: " + pad.gate1);
        System.out.println("Am Gate 2: " + pad.gate2.kennzeichen);
        System.out.println("Am Gate 3: " + pad.gate3.kennzeichen);
        System.out.println("Treibstoff: " + pad.treibstoffLager);
        System.out.println("***********************");
    }
}
 

5.5.6 Fuhrparkmanagement

Klasse Kraftwagen

package s1.block5;
public class Kraftwagen {
private double verkaufsPreis;
    private double einkaufsPreis;
    private String kennzeichen;
public Kraftwagen(double ek, double vk, String nummernSchild) {
// Initialisierung der Variablen mit einfachen Konsistenzprüfungen
        verkaufsPreis = (ek < vk) ? vk : ek;
        einkaufsPreis = (ek < vk) ? ek : vk;
        kennzeichen = nummernSchild;
    }
public double get_Epreis() {
        return einkaufsPreis;
    }
public void set_Epreis(double pr) {
        einkaufsPreis = pr;
    }
public double get_Vpreis() {
        return verkaufsPreis;
    }
public void set_Vpreis(double pr) {
verkaufsPreis = pr;
    }
public String get_kennzeichen() {
        return kennzeichen;
    }
public void set_kennzeichen(String s) {
        kennzeichen = s;
    }

    public void drucken() {
        System.out.println("Einkaufspreis: " + einkaufsPreis);
        System.out.println("Verkaufspreis: " + verkaufsPreis);
        System.out.println("Kennzeichen: " + kennzeichen);
    }
public static void Main (String args) {
}
}

Klasse Verkaeufer

package s1.block5;
public class Verkaeufer {
private String name;
    private double gewinn;
    private double gebundeneMittel;
    private Kraftwagen[] meineWagen;
public Verkaeufer(String nam) {
        meineWagen = new Kraftwagen[2];
        name = nam;
        gewinn = 0.0;
    }
public String get_name(){return name;}
public void neuerWagen(int pos, Kraftwagen w) {
        if ((pos >= 0) && (pos < 2)) {
            meineWagen[pos] = w;
        }
}
public Kraftwagen imBestand(int pos) {
        if ((pos >= 0) && (pos < 2)) {
            return meineWagen[pos];
        } else {
            return null;
        }
    }
public Kraftwagen verkaufeFahrzeug(int pos, double erloes) {
        Kraftwagen result;
        if (erloes < meineWagen[pos].get_Vpreis()) {
            System.out.println("Wagen mit Kennzeichen " +
                    meineWagen[pos].get_kennzeichen() +
                    " sollte unter Einkaufspreis verkauft werden.");
            result = null;
        } else {
            gewinn += erloes-meineWagen[pos].get_Epreis();
            result = meineWagen[pos];
            meineWagen[pos] = null; // Wagen gehört nicht mehr zum Bestand
        }
        return result;
    }
public int fahrzeugeInFlotte() {
        int result = 0;
        int i = 0;
        while (i < meineWagen.length) {
            if (meineWagen[i] != null) {
                result++;
            }
            i++;
        }
        return result;
    }
public double gebundeneMittel() {
        double result = 0.0;
        for (int i = 0; i < meineWagen.length; i++) {
            if (meineWagen[i] != null) {
                result += meineWagen[i].get_Epreis();
            }
        }
        return result;
    }
public double geplanterUmsatz() {
        double result = 0.0;
        for (int i = 0; i < meineWagen.length; i++) {
            if (meineWagen[i] != null) {
                result += meineWagen[i].get_Vpreis();
            }
        }
        return result;
    }
public double get_gewinn() {return gewinn;}
public void drucken() {
        Kraftwagen w1 = imBestand(0);
        Kraftwagen w2 = imBestand(1);
System.out.println("<*** Verkäufername : " + name + " ***>");
        System.out.println("Erlös bisher: " + gewinn);
        System.out.println("Gebundene Mittel: " + gebundeneMittel());
        System.out.println("Geplanter Umsatz: " + geplanterUmsatz());
        System.out.println("Fahrzeuge in Flotte: " + fahrzeugeInFlotte());
        if (w1 != null) w1.drucken();
        if (w2 != null) w2.drucken();
        System.out.println("<*********************************>");
    }
public static void main(String[] args) {
        Kraftwagen w1 = new Kraftwagen(20000.00, 30000.00, "M-S 1234");
        Kraftwagen w2 = new Kraftwagen(10000.00, 15000.00, "B-A 5678");
        Kraftwagen w3 = new Kraftwagen(5000.00, 10000.00, "D-T 8901");
Verkaeufer v1 = new Verkaeufer("Hans");
        v1.neuerWagen(0, w1);
        v1.neuerWagen(1, w2);
        v1.drucken();
Kraftwagen verkWagen = v1.verkaufeFahrzeug(0, 50000);
        System.out.println("Verkaufter Wagen: " + verkWagen.get_kennzeichen());
        v1.drucken();
    }
}

Klasse Haendler

package s1.block5;
/**
 *
 * @author s@scalingbits.com
 */
public class Haendler {
    private Verkaeufer[] team;
    private String name;
public Haendler(String n ) {
        name = n;
        team = new Verkaeufer[3];
    }
public void einstellenTeam(String name1, String name2, String name3) {
        team[0] = new Verkaeufer(name1);
        team[1] = new Verkaeufer(name1);
        team[2] = new Verkaeufer(name1);
    }

    public void geschäftsEröffnung(Kraftwagen[] k) {
        team[0].neuerWagen(0, k[0]);
        team[1].neuerWagen(0, k[1]);
        team[2].neuerWagen(0, k[2]);
        team[0].neuerWagen(1, k[3]);
        team[1].neuerWagen(1, k[4]);
        team[2].neuerWagen(1, k[5]);
    }
public double gesamtGewinn() {
        double g =0;
        for (int i=0; i<team.length; i++) {
            g += team[i].get_gewinn();
        }
        return g;
    }
public double gesamtWertFuhrpark() {
        double g =0;
        for (int i=0; i<team.length; i++) {
            g += team[i].gebundeneMittel();
        }
        return g;
    }
public double geplanterUmsatz() {
        double g =0;
        for (int i=0; i<team.length; i++) {
            g += team[i].geplanterUmsatz();
        }
        return g;
    }
public Verkaeufer getVerkaeufer(int pos) {
        return team[pos];
    }
public Kraftwagen verkaufeFahrzeug(int indexVerk, int indexWagen, double preis) {
        Verkaeufer v = team[indexVerk];
        return v.verkaufeFahrzeug(indexWagen, preis);
    }
public void einstellenFahrzeug(int indexVerk, int indexWagen, Kraftwagen k) {
        Verkaeufer v = team[indexVerk];
        v.neuerWagen(indexWagen, k);
    }
public void drucken() {
        System.out.println("*** Name Händler: " + name + " ***");
        System.out.println("Gesamter Wert der Flotte: " + gesamtWertFuhrpark());
        System.out.println("Gesamter Gewinn: " + gesamtGewinn());
        for (int i=0; i< team.length; i++) team[i].drucken();
    }
public Verkaeufer besterVerkaeufer() {
        Verkaeufer bestSeller = team[0];
        for (int i=1; i<team.length; i++)
            if (team[i].get_gewinn() > bestSeller.get_gewinn())
                bestSeller = team[i];
        return bestSeller;
    }
public static void main(String[] args){
        Kraftwagen[] flotte= new Kraftwagen[8];
        flotte[0] = new Kraftwagen(11111.11,22222.22,"A-A-11");
        flotte[1] = new Kraftwagen(22222.22,22222.22,"B-A-22");
        flotte[2] = new Kraftwagen(33333.33,44444.22,"C-A-33");
        flotte[3] = new Kraftwagen(44444.44,50000.22,"D-A-44");
        flotte[4] = new Kraftwagen(55555.55,60000.22,"E-A-55");
        flotte[5] = new Kraftwagen(66666.66,88888.22,"F-A-66");
        flotte[6] = new Kraftwagen(77777.77,80000.00,"G-A-77");
        flotte[7] = new Kraftwagen(88888.88,90000.00,"G-A-88");
Haendler h = new Haendler("Gebrauchtwagen-Schmidt");
        h.einstellenTeam("Achim", "Bolle", "Caesar");
        h.geschäftsEröffnung(flotte);
        h.drucken();
        h.verkaufeFahrzeug(0, 0, 40404.04);
        h.einstellenFahrzeug(0, 0, flotte[7]);
        Verkaeufer v = h.besterVerkaeufer();
        System.out.println("Größter Gewinn von " + v.get_name());
        h.drucken();
}
}

5.5.7 Mehrere Konstruktoren

Klasse Flugzeug

package block6;
/**
 * Eine Flugzeug mit Gewicht und Passagieren
 * Am besten mit {@link block6.FlugzeugTest#main FlugzeugTest} testen
 * @author sschneid
 */
public class Flugzeug {
    public String kennzeichen; // Ein Attribut vom Typ einer Zeichenkette
    private int maxPassagiere;
    private int passagiere;
    public int leergewicht; // Ein Attribut vom Type einer Ganzzahl
    private int maxgewicht;
    public static final int PASSAGIERGEWICHT = 85;  
    // Anzahl aller erzeugten Flugzeuge
    private static int objekte;

     /**
     *  
     * Konstruktur der Klasse Flugzeug
     * @param kennz     Kennzeichen des Flugzeugs
     * @param kapazitaet Passagierkapazität
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
    public Flugzeug(String kennz, int kapazitaet, int leergew, int maxgew) {
        kennzeichen = kennz;
        objekte++;
        // Prüfen ob Kapazität größere Null ist
        if (kapazitaet >= 0) {
            maxPassagiere = kapazitaet;
        } else {
            maxPassagiere = 0;
        }
        // Prüfen ob Leergewicht größer Null ist
        if (leergew > 0) {
            leergewicht = leergew;
        } else {
            leergewicht = 0;
        }
        // Prüfen ob Maximalgewicht größer-gleich Leergeicht ist.
        if (maxgew > leergewicht) {
            maxgewicht = maxgew;
        } else {
            maxgewicht = leergewicht; // Viel Spass...
        }
    }

    /**
     * Konstruktur der Klasse Flugzeug
     * Berechnet Passagierkapazität automatisch
     * @param kennz     Kennzeichen des Flugzeugs
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
public Flugzeug(String kennz, int leergew, int maxgew) {
        this(kennz,(maxgew-leergew)/PASSAGIERGEWICHT,leergew,maxgew);
    }

     /**
     * Fügt einen Passagier zum aktuellen Flugzeug hinzu
     */
    public void einsteigen() {
        if (passagiere < maxPassagiere) {
            passagiere++;
        }
    }

    /**
     * @param anzahl Anzahl der Passagiere die einsteigen sollen
     */
    public void einsteigen(int anzahl) {
        if ((anzahl >0) && (passagiere+anzahl) <= maxPassagiere) {
            passagiere+= anzahl;
        }
    }

     /**
     * Entfernt einen Passagier des aktuellen Flugzeugs 
     */
    public void aussteigen() {
        if (passagiere > 0) {
            passagiere--;
        }
    }

    /**
     * Entfernt Passagiere des aktuellen Flugzeugs
     * @param anzahl Anzahl der Passagiere die aussteigen sollen
     */
    public void aussteigen(int anzahl) {
        if ((anzahl >0) && (passagiere-anzahl) >=0) {
            passagiere-= anzahl;
        }
    }

    /** 
     * Ausgabe der aktuellen Anzahl der Passagiere
     * @return aktuelle Anzahl der Passagiere 
     */
    public int anzahlPassagiere() {return passagiere;}


    /**
     * Berechnen des aktuellen Gewichts
     * @return aktuelles Gewicht
     */
    public int gewicht() {
    return (leergewicht+ passagiere*PASSAGIERGEWICHT);}

    /** 
     * Ausgabe der maximalen Anzahl der Passagiere
     * @return Maximale Anzahl der Passagiere 
     */
    public int passagierkapazitaet() {return maxPassagiere;}

    /**
     * 
     * @return Anzahl aller erzeugten Objekte der Klasse Flugzeug 
     */
    public static int anzahlFlugzeuge() {return objekte;}

    /**
     * Eine Methode zum Drucken der Attributbelegung des Objekts
     * Die Methode erfordert keine Eingaben. Sie erzeugt keine
     * Ausgaben
     */
    public void drucken() {
        // 7. Vervollständigen der Druckmethode
        System.out.println("*****************************");
        System.out.println("Kennzeichen:        " + kennzeichen);
        System.out.println("Leergewicht:        " + leergewicht + "kg");
        System.out.println("Maximalgewicht:     " + maxgewicht + "kg");
        System.out.println("Aktuelles Gewicht : " + gewicht() + "kg");
        System.out.println("Passagiere:         " + passagiere);
        System.out.println("Maximal Anzahl P.:  " + maxPassagiere);
        System.out.println("******************** " + objekte + " Flugz.");
    }
}

 

.

Am Ende dieses Blocks können Sie: ....die wichtigsten Aspekte der Objektorientierung anwenden und erklären. ...an einfachen Beispielen das Konzept der Datenkapselung in Java anwenden indem Sie eine Klasse mit öffentlichen Attributen mit Hilfe von Methoden kapseln. ...den Unterschied einer Klasse zu einem Objekt in Java eklären ...Objektvariablen benutzen und erkennen ob Objektvariablen auf das gleiche oder ein anderes Objekt zeigen ...Klassenvariablen und Klassenmethoden anhand des Schlüsselwort static erkennen. ...den Unterschied von Klassenvariablen und Klassenmethoden zu normalen Methoden (Objektmethoden) und Variablen(Objektvariablen) erklären .... den Begriff der Datenkapselung erläutern und anwenden ... Beispiele für die Trennung von Zuständigkeiten nennen ... den Begriff der Schichtenarchitektur erklären ... die this Referenz nutzen und erklären ... Konstruktoren mit Parametern benutzen und überladene Konstruktoren erkennen und die Aufrufreihenfolge der Konstruktoren interpretieren ... das Entwurfsmuster eines Singleton (Einzelstücks) in Java mit Hilfe von Konstruktoren implementieren ... den Unterschied zwischen Instanziieren und Initialisieren erklären

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zu objekt orientierten Programmierung beantworten. Die Fragen benötigen zum Teil das Wissen der nachfolgenden Blöcke.

Feedback

Zur Umfrage