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; Deutsche Übersetzung Heinrich Gailer


Füllen Sie 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. Jede Schaltfläche repräsentiert das fehlende Wort bzw. die fehlenden Wörter. Überlegen Sie welches Wort bzw. welche Wörter fehlen. Klicken Sie dann auf die Schaltfläche, um zu sehen ob Sie recht haben. Es wird keine Note für diese Übung ermittelt.


Studenten 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.       Füllen Sie die Lücken aus, so dass das folgende Programm sechsmal "Hallo Vesta" auf den 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 lassen Sie uns die anderen Programme ansehen.



2.      Schreiben Sie jetzt ein Programm, das ein Vesta-Objekt verwendet, um "Hallo Vesta" auf den 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 Sie 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 ; // Der Ausgabe-String

  // 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 ; // Der Ausgabe-String
   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 ; // Der Ausgabe-String

  // 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 Anfrage sein, nicht ein inhärentes 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. (Denken Sie 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 ; // Der Ausgabe-String

  // 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 ; // Der Ausgabe-String

  // 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 ) ;
  }
}

Beachten Sie 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 verändert die Daten ihres Objekts. Da die Daten in einem Vesta-Objekt geändert werden können, sind sie NICHT unveränderbar.


Ende des Tests. Wenn Sie ihn wiederholen möchten, klicken Sie in Ihrem Browser auf "Aktualisieren".

Zurück zum Inhaltsverzeichnis.