erstellt: 30.09.99; überarbeitet: 07.03.00; übersetzt: 15.06.03; überarbeitet 03.02.04, 18.01.05, 11.07.06, 19.10.06, 19.01.11, 26.06.18, 11.12.18, 21.07.21, 29.06.22, 27.03.23, 07.02.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 Marmelade 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 Marmelade. 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 Marmelade-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:

class 

// Eine Klasse, die ein Marmeladenglas modelliert.

// Konstruktor

public Marmelade ( String ,      // überlegen wir uns sinnvolle Parameternamen
            String ,            // für jeden der drei Werte
            int      )

// Instanzmethoden

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

// etwas Marmelade entnehmen --- eine bestimmte Menge davon
// 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.

class MarmeladeTester
{

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

     glas.ausgeben();

     if ( glas. )
       System.out.println("Es kann keine Marmelade aufgetragen werden: 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.

class Marmelade
{
  // Instanzvariablen
   inhalt;
   datum;
   menge;

  // Konstruktor

  // Instanzmethoden

}

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

class Marmelade
{
  // 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 Marmelade(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.

class Marmelade
{
  // 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 Marmelade(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 von " + 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:

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 von 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.

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

  // Konstruktor
  public Vorratskammer( Marmelade glas1, Marmelade glas2, Marmelade 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.

class Vorratskammer
{
  // Instanzvariablen
  private Marmelade  glas1;
  private Marmelade  glas2;
  private Marmelade  glas3;

  // Konstruktor
  public Vorratskammer(Marmelade glas1, Marmelade glas2, Marmelade 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.

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

  // Konstruktor
  public Vorratskammer( Marmelade glas1, Marmelade glas2, Marmelade 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 dieses Programm in unseren Editor und probieren es aus.

class Marmelade
{
  // 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 Marmelade( 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!");
  }

}

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

  // Konstruktor
  public Vorratskammer( Marmelade glas1, Marmelade glas2, Marmelade 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  );
  }
}

class VorratskammerTester
{
  public static void main ( String[] args )
  {
    Marmelade stachelbeer = new Marmelade( "Stachelbeer", "15.06.22", 300 );
    Marmelade erdbeer     = new Marmelade( "Erdbeer", "30.06.22", 250 );
    Marmelade aprikosen   = new Marmelade( "Aprikosen", "02.09.21", 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 15.06.22 300 Gramm
2: Erdbeer 30.06.22 250 Gramm
3: Aprikosen 02.09.21 200 Gramm
Auftragen von 20 Gramm Stachelbeer
1: Stachelbeer 15.06.22 280 Gramm
2: Erdbeer 30.06.22 250 Gramm
3: Aprikosen 02.09.21 200 Gramm
Auftragen von 30 Gramm Aprikosen
1: Stachelbeer 15.06.22 300 Gramm
2: Erdbeer 30.06.22 250 Gramm
3: Aprikosen 02.09.21 170 Gramm

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

Zurück zum Inhaltsverzeichnis.