erstellt: 13.8.99; überarbeitet: 05.05.03, 09.04.06; übersetzt: 19.05.03; überarbeitet 19.01.04, 06.07.04, 10.01.05, 11.10.06, 20.12.10, 20.11.18, 29.04.19, 23.11.20, 22.11.21, 19.05.22, 17.01.24; Deutsche Übersetzung Heinrich Gailer

Wir füllen die Lücken aus

Hinweise: Das ist eine unbewertete Lückenübung. Jede Frage besteht aus einem Satz, bei dem ein oder zwei Wörter fehlen. Ein Button repräsentiert das fehlende Wort bzw. die fehlenden Wörter. Überlegt welches Wort bzw. welche Wörter fehlen. Klickt dann auf die Schaltfläche, um zu sehen ob Ihr recht habt. Es wird keine Note für diese Übung ermittelt.

Programmieranfänger fahren sich beim Programmieren häufig deswegen fest, weil es scheinbar zu viele Wege gibt etwas zu tun und es nicht klar ist, welches der richtige Weg ist.

Diese Übung zeigt verschiedene Wege, in der ein Programm geschrieben werden kann, um dieselbe Aufgabe auszuführen.

Die Programme werden zunehmend komplizierter und verwenden wahrscheinlich ein zunehmend schlechteres Programmdesign für das angegebene Problem.

1. Wir füllen die Lücken aus, so dass das folgende Programm sechsmal "Hallo Vesta" auf dem Bildschirm ausgibt.

class VestaHallo
{

  public static void main ( String[] args )
  {
    int j =  ;

    while ( j  6 )
    {
        System.out.println( "Hallo Vesta" );
        j = j + 1;
    }

  }
}

Dieses Programm zeigt wenig von der objektorientierten Art der Programmierung. Für das gestellte Problem ist es wahrscheinlich das Beste der zehn Programme, da es die Aufgabe in einer einfachen und klaren Weise löst. Aber wir wollen uns die anderen Programme ansehen.

2. Wir schreiben jetzt ein Programm, das ein Vesta-Objekt verwendet, um "Hallo Vesta" auf dem Bildschirm auszugeben.

class Vesta
{
  void sprich()
  {
    System.out.println( " " );
  }
}

class VestaHallo2
{

  public static void main ( String[] args )
  {
    int   j    = 0  ;
    Vesta vest = new   ;

    while ( j < 6 )
    {
        vest. ;
        j = j + 1;
    }

  }
}

In diesem Programm wird ein Vesta-Objekt erzeugt und dessen Methode sprich() sechsmal aufgerufen. Wenn alles was wir wollten nur die sechsmalige Ausgabe des Satzes war, dann ist die erste Version des Programms wahrscheinlich besser als diese Version.

3. Hier ist eine Abwandlung des Programms. Jetzt werden sechs Vesta-Objekte erzeugt und jedes von ihnen verwendet einmal seine Methode sprich().

class Vesta
{
  void sprich()
  {
    System.out.( "Hallo Vesta" );
  }
}

class VestaHallo3
{

  public static void main ( String[] args )
  {
    int   j    = 0  ;

    while ( j < 6 )
    {
        Vesta vest = new   ;
        vest. ;
        j = j + 1;
    }

  }
}

Diese Version des Programms ist weniger effizient als die vorherigen, da sie sechs Objekte erzeugt, die alle das gleiche tun und wo jedes von ihnen sofort nach der Verwendung Datenausschuss wird. Das ist ein schlechter Programmierstil.

4. Hier ist eine weitere Modifikation des Programms. Wieder werden sechs Vesta-Objekte erzeugt, aber jetzt ist jedes ein temporäres, unbenanntes Objekt.

class Vesta
{
  void sprich()
  {
    System.out.println( "Hallo Vesta" );
  }
}

class VestaHallo4
{

  public static void main ( String[] args )
  {
    int   j    = 0  ;

    while ( j < 6 )
    {
        new   .  ;
        j = j + 1;
    }

  }
}

Der new-Operator wird verwendet, um jedes Objekt zu erzeugen und die Methode sprich() der neu erzeugten Objekte wird aufgerufen. Trotz dieser Verfeinerung ist diese Version des Programms genauso unpraktisch wie die vorherige Version.

5. Jetzt ist die Klasse Vesta so verändert, dass ein Vesta-Objekt seine Mitteilung sechsmal ausgibt:

class Vesta
{
  void sprich()
  {
    int   j    = 0  ;

    while ( j < 6 )
    {
        System.out.println("  ");
        j = j + 1;
    }

  }
}

class VestaHallo5
{

  public static void main ( String[] args )
  {

     vest =  Vesta() ;

    vest .  ;
  }
}

Diese Version hat den Vorteil, dass sie nur ein Objekt erzeugt und den weiteren Vorteil, dass main() jetzt ein einfaches Programm ist. Wenn damit gerechnet wird, dass main() länger wird, indem mehr und mehr Dinge hinzugefügt werden, dann könnte das Vesta-Objekt vernünftig sein. Aber für die angeführte einfache Aufgabe ist das erste Programm immer noch das Beste.

6. In dieser Version beinhaltet die Klassendefinition einen Konstruktor, der die auszugebende Mitteilung initialisiert.

class Vesta
{
   mitteilung ; // Instanzvariable

  // Konstruktor
  Vesta( String mit )
  {
       = mit ;  // Mitteilung initialisieren
  }

  void sprich()
  {
    int   j    = 0  ;

    while ( j < 6 )
    {
        System.out.println(  );
        j = j + 1;
    }

  }
}

class VestaHallo6
{

  public static void main ( String[] args )
  {

    Vesta vest = new Vesta ( "  " ) ;

    vest . sprich() ;
  }
}

Noch einmal, ob die Vesta-Klasse vernünftig ist, hängt von der Aufgabe ab. Wenn die Aufgabe kompliziert ist und das obige Programm erst ein kleiner Schritt in Richtung einer vollständigen Lösung, dann ist die Vesta-Klasse vielleicht gutes Design.

7. Eine weitere Verfeinerung ist die Aufnahme der Iterationsbegrenzung in den Konstruktor.

class Vesta
{
  String  mitteilung ; // Instanzvariable
   anzahl ; // Anzahl der Ausgaben

  // Konstruktor
  Vesta( String mit, int anz )
  {
      mitteilung = mit ;  // Mitteilung initialisieren
      anzahl =  ;  // Anzahl initialisieren
  }

  void sprich()
  {
    int   j    = 0  ;

    while ( j <  )
    {
        System.out.println( mitteilung );
        j = j + 1;
    }

  }
}

class VestaHallo7
{

  public static void main ( String[] args )
  {

    Vesta vest = new Vesta ( "Hallo Vesta" ,  ) ;

    vest . sprich() ;
  }
}

Diese Version der Vesta-Klasse ist flexibler als die vorherige Version. Sie ist wahrscheinlich besser, da sie für mehr Situationen verwendet werden kann als die vorherige.

8. Bei weiterer Überlegung (was vor jeder Programmierung hätte getan werden sollen) scheint es vernünftig, dass die Anzahl für die Ausgabe der Mitteilung besser als Parameter der Methode sprich() spezifiziert wird. Das verbessert weiter die Flexibilität der Klasse.

class Vesta
{
  String  mitteilung ; // Instanzvariable

  // Konstruktor
  Vesta( String mit )
  {
      mitteilung = mit ;  // Mitteilung initialisieren
  }

  void sprich( int )
  {
    int   j    = 0  ;

    while ( j <  )
    {
        System.out.println( mitteilung );
        j = j + 1;
    }

  }
}

class VestaHallo8
{

  public static void main ( String[] args )
  {

    Vesta vest = new Vesta ( "Hallo Vesta" ) ;

    vest . sprich( ) ;
  }
}

Diese Version erscheint sowohl logischer als auch vielseitiger. Die Anzahl wie oft eine Mitteilung wiederholt werden soll, sollte ein Merkmal der Methode sein, nicht ein festes Merkmal des Objekts.

9. Größtenteils sagt ein Vesta-Object "Hallo Vesta", jedes Mal wenn es verwendet wird. Wenn es das ist was wir wollen, dann sollte es nicht die Methode main() sagen.

Klassen können mehrere Konstruktoren mit jeweils verschiedenen Parametern haben. (Denkt an die Point-Klasse.) In der folgenden Version des Programms gibt es zwei Konstruktoren, der eine initialisiert die Mitteilung automatisch mit "Hallo Vesta" und der andere initialisiert sie mit der übergebenen Mitteilung.

class Vesta
{
  String  mitteilung ; // Instanzvariable

  // Parameterloser Konstruktor
  Vesta( )
  {
      mitteilung =  "" ;  // Mitteilung initialisieren
  }


  // Ein Konstruktor mit einem Parameter
  Vesta(  mit )
  {
      mitteilung =   ;  // Mitteilung initialisieren
  }

  void sprich( int anzahl )
  {
    int   j    = 0  ;

    while ( j < anzahl )
    {
        System.out.println( mitteilung );
        j = j + 1;
    }

  }
}

class VestaHallo9
{

  public static void main ( String[] args )
  {

    Vesta vest = new Vesta ();  // Standardwert "Hallo Vesta" verwenden

    vest . sprich( ) ;
  }
}

10. Eine weitere Verbesserung der Vesta-Klasse ist die Aufnahme einer Methode, die die Mitteilung verändern kann. Das ist kein Konstruktor — es ist eine Methode, die ein Teil eines existierenden Objekts ist und die Mitteilung des Objekts ändert.

class Vesta
{
  String  mitteilung ; // Instanzvariable

  // Parameterloser Konstruktor
  Vesta( )
  {
      mitteilung =  "Hallo Vesta" ;  // Mitteilung initialisieren
  }

  // Ein Konstruktor mit einem Parameter
  Vesta( String mit )
  {
      mitteilung =   mit  ;  // Mitteilung initialisieren
  }

  // Methode, die die Mitteilung des Objekts ändert
  void setMitteilung(  mit )
  {
      mitteilung =   ;  // Mitteilung initialisieren
  }

  void sprich( int anzahl )
  {
    int   j    = 0  ;

    while ( j < anzahl )
    {
        System.out.println(  );
        j = j + 1;
    }

  }
}

class VestaHallo10
{

  public static void main ( String[] args )
  {

    Vesta vest = new Vesta () ;  // Den Standardwert "Hallo Vesta" verwenden
    vest . sprich( 6 ) ;

    // Die Mitteilung in "Hallo Ceres" ändern
    vest.setMitteilung( " " );
    vest . sprich( 6 ) ;
  }
}

Beachtet sorgfältig den Unterschied zwischen einem Konstruktor und einer Methode:

Ein Konstruktor initialisiert die Daten in einem Objekt, wenn das Objekt erzeugt wird. Jede Verwendung eines Konstruktors erzeugt ein neues Objekt.

Eine Methode ist Teil eines Objekts. Sie kann die Daten ihres Objekts ändern. Da die Daten in einem Vesta-Objekt geändert werden können, sind sie NICHT unveränderbar.

Ende des Tests. Wer ihn wiederholen möchte, lädt die Seite im Browser neu

Zurück zum Inhaltsverzeichnis.