erstellt: 30.09.99; überarbeitet: 07.03.00; übersetzt: 15.06.03; überarbeitet 03.02.04, 18.01.05, 11.07.06, 19.01.11, 11.12.18, 21.07.21, 29.06.22, 27.03.23, 07.02.24, 26.11.24; deutsche Übersetzung Heinrich Gailer

Wir füllen die Lücken aus

In dieser Aufgabe werden wir das Entwerfen von Objekten aus anderen Objekten üben. Zuerst werden wir die Klasse GlasMarmelade definieren. Objekte dieser Klasse repräsentieren Gläser von eingemachten Früchten. Dann werden einige dieser Gläser in eine Vorratskammer gestellt.

1. Entwurf der Klasse GlasMarmelade. Objekte dieser Klasse werden ein Glas von eingemachten Früchten repräsentieren, so wie sie unsere Großmutter in jedem Herbst gemacht hat. Wir überlegen uns drei Werte, die wir über ein Marmeladenglas wissen möchten.

Denken wir jetzt an ein paar Methoden, die auf ein GlasMarmelade-Objekt angewendet werden können. Es ist fast immer eine gute Idee eine Möglichkeit zu haben die Daten eines Objekts auszugeben:

Das ist ein sehr einfaches Beispiel und es wäre nicht ungewöhnlich, wenn wir an etwas Anderes gedacht haben, um die Lücken auszufüllen.

2. Klasse dokumentieren. Füllen wir jetzt die Lücken für die Klassendefinition aus:

public class 

// Eine Klasse, die ein Marmeladenglas modelliert.

// Konstruktor


// wir brauchen sinnvolle Parameternamen
// für jeden der drei Werte
public GlasMarmelade ( String ,
            String ,
            int      )

// Instanzmethoden

// überprüfen, ob das Glas leer ist
public boolean  

// etwas Marmelade entnehmen
// und auf den Toast auftragen
public void  auftragen 

// Informationen über das Glas ausgeben
public void ausgeben()

3. Das Design überprüfen. Um das Design zu überprüfen, schreiben wir ein kleines Programm, das die Klasse verwendet. Natürlich kann das Programm nicht kompiliert werden bis die Klasse geschrieben ist, aber wir können dadurch ein Gefühl dafür bekommen ob das Klassendesign vernünftig ist.

public class GlasMarmeladeTester
{

  public static void main ( String[] args )
  {
       glas = new
        ("Erdbeer", "3.7.23", 300);

     glas.ausgeben();

     if ( glas. )
       System.out.println("Das Glas ist leer.");
     else
     {
       glas.;
       System.out.println(
         "Auftragen von 10 Gramm Marmelade.");
       glas.ausgeben();
     }

  }
}

Wir könnten einige Zweifel haben ob dies ein vernünftiges Programm ist. Vielleicht wäre es eine gute Idee die auftragen() Methode eine Mitteilung ausgeben zu lassen, jedes Mal wenn sie verwendet wird.

4. Wir füllen den Datentyp für jede Instanzvariable aus.

public class GlasMarmelade
{
  // Instanzvariablen
   inhalt;
   datum;
   menge;

  // Konstruktor

  // Instanzmethoden

}

Hinweis: In einem richtigen Programm würde für die Variable datum der Datentyp Date verwendet werden. Aber wir halten das Beispiel einfach.

5. Wir vervollständigen den Konstruktor. Der Konstruktor wird die Instanzvariablen des zu konstruierenden Objekts initialisieren.

public class GlasMarmelade
{
  // Instanzvariablen
  private String inhalt; // Art der Frucht im Glas
  private String datum;  // Abfülldatum
  private int    menge;  // Menge der Marmelade im Glas

  // Konstruktor
  public GlasMarmelade(
    String inhalt, String datum, int menge)
  {
     . inhalt = inhalt;
     . datum = datum;
     . menge = menge;
  }

  // Instanzmethoden

}

6. Wir vervollständigen die Methoden. Wenn der Anwender mehr Marmelade auftragen möchte als verfügbar ist, tragen wir nur die Menge auf, die im Glas übrig ist.

public class GlasMarmelade
{
  // Instanzvariablen
  private String inhalt; // Art der Frucht im Glas
  private String datum;  // Datum des Abfüllens
  private int    menge;  // Menge der Marmelade im Glas


  // Konstruktor
  public GlasMarmelade(
    String inhalt, String datum, int menge)
  {
    this.inhalt = inhalt;
    this.datum  = datum;
    this.menge  = menge;
  }

  // Instanzmethoden
  public boolean istLeer()
  {
     return (  ==  );
  }

  public void ausgeben()
  {
     System.out.println (  +
       " " +  +
       " " +  + " Gramm" );
  }

  public void auftragen(int gramm)
  {
     if ( !istLeer() )
     {
         if ( gramm <= menge )
         {
             System.out.println("Auftragen von  " +
                + " Gramm " + inhalt );

             menge = menge - ;

         }
         else
         {
             System.out.println("Auftragen von " +
                + " Gramm von " + inhalt );

             menge = ;
         }
     }
     else
       System.out.println("Keine Marmelade im Glas!");
  }

}

7. Design der Klasse Vorratskammer. Sagen wir, dass eine Vorratskammer aus drei Marmeladengläsern beliebigen Typs und beliebiger Größe besteht.

Den Inhalt der Vorratskammer auflisten.
Ein Glas durch eine Zahl auswählen
- Gläser werden durch eine Ganzzahl 1, 2, oder 3 ausgewählt.
Marmelade des ausgewählten Glases auftragen.

Um ein Glas Marmelade zu verwenden, muss man erst zur Vorratskammer gehen und eines auswählen.

Hier ist die Dokumentation:

public class 

// Eine Klasse, die eine Vorratskammer
// mit Marmelade modelliert.

// Konstruktor

public Vorratskammer (   glas1,
           glas2,
           glas3 )


// Hinweis: dieser Konstruktor wird drei
// Objektreferenzen als Parameter aufnehmen.
// Die drei Objekte werden die drei Gläser sein,
// die in der Vorratskammer aufbewahrt werden.
// Die Objekte müssen schon existieren,
// bevor der Konstruktor verwendet werden kann.

// Instanzmethoden

// den Inhalt der Vorratskammer ausgeben
 void ausgeben()

// ein Glas durch eine Zahl auswählen
public void  auswaehlen 

// eine bestimmte Menge Marmelade
// aus dem ausgewählten Glas auftragen
public void  auftragen

8. Instanzvariablen und Konstruktor. Entscheiden wir über die Instanzvariablen. Es wird eine Variable geben, die auf das gegenwärtig ausgewählte Marmeladenglas verweist. Wenn kein Glas ausgewählt ist, sollte sie auf kein Objekt verweisen. Außenstehende sollten nicht in der Lage sein die Variablen direkt zu ändern.

public class Vorratskammer
{
  // Instanzvariablen
  private  glas1;
  private  glas2;
  private  glas3;
  private  glasAusgewaehlt;

  // Konstruktor
  public Vorratskammer(GlasMarmelade glas1,
    GlasMarmelade glas2, GlasMarmelade glas3)
  {
     . glas1 = glas1;
     . glas2 = glas2;
     . glas3 = glas3;
    glasAusgewaehlt = ;
  }

  // Instanzmethoden

}

9. Implementieren wir die ausgeben() Methode. Die ausgeben() Methode wird jedes der Gläser in der Vorratskammer ausgeben.

public class Vorratskammer
{
  // Instanzvariablen
  private GlasMarmelade  glas1;
  private GlasMarmelade  glas2;
  private GlasMarmelade  glas3;

  // Konstruktor
  public Vorratskammer( GlasMarmelade glas1,
    GlasMarmelade glas2, GlasMarmelade glas3)
  {
    this . glas1    = glas1;
    this . glas2    = glas2;
    this . glas3    = glas3;
    glasAusgewaehlt = null;
  }

  // Instanzmethoden
  public void ausgeben()
  {
    System.out.print("1: "); .ausgeben();
    System.out.print("2: "); .ausgeben();
    System.out.print("3: "); .ausgeben();
  }
}

Vergewissern wir uns

10. Implementieren wir die auswaehlen() und auftragen() Methoden.

public class Vorratskammer
{
  // Instanzvariablen
  private GlasMarmelade  glas1;
  private GlasMarmelade  glas2;
  private GlasMarmelade  glas3;
  private GlasMarmelade  glasAusgewaehlt;

  // Konstruktor
  public Vorratskammer(GlasMarmelade glas1,
    GlasMarmelade glas2, GlasMarmelade glas3)
  {
    this . glas1    = glas1;
    this . glas2    = glas2;
    this . glas3    = glas3;
    glasAusgewaehlt = null;
  }

  // Instanzmethoden
  public void ausgeben()
  {
    System.out.print("1: "); glas1.ausgeben();
    System.out.print("2: "); glas2.ausgeben();
    System.out.print("3: "); glas3.ausgeben();
  }

  // wir setzen voraus, dass der Anwender
  // eine richtige Auswahl trifft, 1, 2, oder 3
  public void auswaehlen( int glasNummer )
  {
    if ( glasNummer   1 )

      glasAusgewaehlt = ;

    else if ( glasNummer   2 )

      glasAusgewaehlt = ;

    else

      glasAusgewaehlt = ;
  }

  // die ausgewählte Marmelade auftragen
  public void auftragen( int gramm )
  {
     . auftragen( gramm );
  }
}

Vollständiges Programm mit einer Testklasse: Wir kopieren das Programm in unsere Entwicklungsumgebung und probieren es aus.

public class GlasMarmelade
{
  // Instanzvariablen
  private String inhalt; // Art der Frucht im Glas
  private String datum;  // Datum des Abfüllens
  private int menge; // Menge der Marmelade im Glas


  // Konstruktor
  public GlasMarmelade(
    String inhalt, String datum, int menge)
  {
    this . inhalt = inhalt;
    this . datum  = datum;
    this . menge  = menge;
  }

  // Instanzmethoden
  public boolean istLeer()
  {
    return ( menge == 0 );
  }

  public void ausgeben()
  {
    System.out.println (
      inhalt + " " +  datum + " " +
        menge + " Gramm." );
  }

  public void auftragen ( int gramm)
  {
    if ( !istLeer() )
    {
      if ( gramm <= menge )
      {
        System.out.println(
          "Auftragen von " + gramm + " Gramm "
            + inhalt );
        menge = menge - gramm;
      }
      else
      {
        System.out.println(
          "Auftragen von  " + menge + " Gramm "
            + inhalt );
        menge =  0;
      }
     }
     else
       System.out.println(
         "Keine Marmelade im Glas!");
  }

}

public class Vorratskammer
{
  // Instanzvariablen
  private GlasMarmelade  glas1;
  private GlasMarmelade  glas2;
  private GlasMarmelade  glas3;
  private GlasMarmelade  glasAusgewaehlt;

  // Konstruktor
  public Vorratskammer(GlasMarmelade glas1,
    GlasMarmelade glas2, GlasMarmelade glas3)
  {
    this . glas1    = glas1;
    this . glas2    = glas2;
    this . glas3    = glas3;
    glasAusgewaehlt = null;
  }

  // Instanzmethoden
  public void ausgeben()
  {
    System.out.print("1: "); glas1 . ausgeben();
    System.out.print("2: "); glas2 . ausgeben();
    System.out.print("3: "); glas3 . ausgeben();
  }

  // wir setzen voraus, dass der Anwender
  // eine richtige Auswahl trifft, 1, 2, oder 3
  public void auswaehlen( int glasNummer )
  {
    if ( glasNummer == 1 )
      glasAusgewaehlt =  glas1;

    else if ( glasNummer == 2 )
      glasAusgewaehlt = glas2;

    else
      glasAusgewaehlt = glas3;
  }

  // Auftragen der ausgewählten Marmelade
  public void auftragen( int gramm  )
  {
    glasAusgewaehlt . auftragen( gramm  );
  }
}

public class VorratskammerTester
{
  public static void main ( String[] args )
  {
    GlasMarmelade stachelbeer = new GlasMarmelade(
      "Stachelbeer", "30.07.23", 300);
    GlasMarmelade erdbeer     = new GlasMarmelade(
      "Erdbeer", "15.06.23", 250);
    GlasMarmelade aprikosen   = new GlasMarmelade(
      "Aprikosen", "02.07.23", 200);

    Vorratskammer vorrat = new Vorratskammer(
      stachelbeer, erdbeer, aprikosen);
    vorrat.ausgeben();

    vorrat.auswaehlen(1);
    vorrat.auftragen(20);
    vorrat.ausgeben();

    vorrat.auswaehlen(3);
    vorrat.auftragen(30);
    vorrat.ausgeben();
  }
}

Wenn wir das Programm starten, werden wir mit der folgenden Ausgabe belohnt:

1: Stachelbeer 30.07.23 300 Gramm.
2: Erdbeer 15.06.23 250 Gramm.
3: Aprikosen 02.07.23 200 Gramm.
Auftragen von 20 Gramm Stachelbeer
1: Stachelbeer 30.07.23 280 Gramm.
2: Erdbeer 15.06.23 250 Gramm.
3: Aprikosen 02.07.23 200 Gramm.
Auftragen von 30 Gramm Aprikosen
1: Stachelbeer 30.07.23 280 Gramm.
2: Erdbeer 15.06.23 250 Gramm.
3: Aprikosen 02.07.23 170 Gramm.

Ende der Übung. Wer sie wiederholen möchte, klickt im Browser auf "Aktualisieren".

Zurück zum Inhaltsverzeichnis.