erstellt 25.11.99; überarbeitet 28.05.03; übersetzt 22.06.03; überarbeitet 14.02.05, 17.04.24, 29.05.24

Kapitel 40 Wir füllen die Lücken aus

Mit dieser Aufgabe üben wir das Schreiben von Methoden, die Dinge mit Arrays tun.

1. Design der StudiNoten-Klasse. Ein Objekt dieser Klasse repräsentiert die Noten eines einzelnen Studierenden. Aus Gründen der Einfachheit nehmen wir an, dass alle Noten gleich zählen und, dass ein Studierender bis zu 25 davon haben kann.

Wir überlegen uns drei Instanzvariablen, die für ein StudiNoten-Objekt benötigt werden.

Wir überlegen uns jetzt einige Methoden, die nützlich sind, um sie auf eine Liste von Noten anzuwenden. Es ist fast immer eine gute Idee eine Möglichkeit zu haben sich die Daten eines Objekts ausgeben zu lassen, und es wird notwendig sein eine Note zu der Liste hinzuzufügen.

2. Dokumentation der Klasse. Wir füllen jetzt die Dokumentation der Klasse aus:

class 

Eine Klasse, die die Noten für einen Studierenden enthält.

Konstruktor

// Ein neu konstruiertes Objekt hat den Namen des Studierenden, aber enthält keine Noten
StudiNoten (  studiName )

Methoden

// Daten ausgeben
public void   // die von der Klasse Object geerbte Methode überschreiben

// eine Note für diesen Studierenden hinzufügen
public void  hinzufuegenNote 

// Durchschnitt berechnen
public double  berechneDurchschnitt()

// Minimum berechnen
public int 

// Maximum berechnen
public int

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

class StudiTester
{

  public static void main ( String[] args )
  {
     // ein Objekt für einen Studierenden erzeugen
     StudiNoten studi = new  ( "Laura Lyons" ) ;

     // ein Objekt ausgeben
     studi. ;

     // ein paar Noten hinzufügen: 90, 95, and 88
     studi. ;
     studi. ;
     studi. ;

     // das Objekt mit dessen neuen Daten ausgeben
     studi. ;

     // Durchschnitt berechnen und ausgeben
     System.out.println( "Durchschnittsnote: " + studi. ;

     }

  }
}

4. Wir füllen die Instanzvariablen aus. Wir überlegen uns einen Datentyp für jede Instanzvariable. Die Noten werden in einem Integer Array aufbewahrt, das Platz für 25 Zahlen hat. Wir konstruieren das Array noch nicht. Es wird ebenfalls eine Instanzvariable geben, die zählt wie viele Elemente des Arrays Daten enthalten.

Mögliche Unklarheit: Die Länge des Arrays ist die Anzahl seiner Elemente. In diesem Programm werden nicht alle Elemente mit Noten gefüllt werden, also brauchen wir die Anzahl der verwendeten Elemente. Elemente werden in ihrer Reihenfolge verwendet und beginnen mit dem Index 0.

class StudiNoten
{
  final int ARRAYLAENGE = 25;

  // Instanzvariablen
  private  name;
  private  noten ;
  private  anzahlNoten;

  // Konstruktoren

  // Methoden

}

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

class StudiNoten
{
  final int ARRAYLAENGE = 25;

  // Instanzvariablen
  private String name;          // der Name des Studierenden
  private int[]  noten;         // das Array mit den Noten
  private int    anzahlNoten;   // wie viele Elemente Daten enthalten

  // Konstruktor
  StudiNoten( String studiName )
  {
    name        =   ;
    noten       =  int[ ARRAYLAENGE ] ;
    anzahlNoten =  ;
  }


  // Methoden

}

6. Wir vervollständigen die toString() Methode. Wir möchten nicht jedes Element des Arrays ausgeben (das ist nicht wie in der ausgeben() Methode dieses Kapitels), sondern nur die tatsächliche Anzahl der Noten.

class StudiNoten
{
  final int ARRAYLAENGE = 25;

  // Instanzvariablen
  String name;          // der Name des Studierenden
  int[]  noten;         // das Array mit den Noten
  int    anzahlNoten;   // wie viele Elemente Daten enthalten

  // Konstruktor
  StudiNoten( String studiName )
  {
    name = studiName  ;
    noten =  new int[ ARRAYLAENGE ] ;
    anzahlNoten =  0  ;
  }

  // Methoden
  public String toString()
  {
    String str = "Name: " +   + "\n" ;

    for ( int j=0; j <  ; j++ )
     str += "grade " + j + ": " + grades[ ] + ", ";

     return str;
  }
}

7. Wir implementieren die hinzufuegenNote() Methode. Diese Methode wird eine Note (Integer) zur Liste der Noten für den Studierenden hinzufügen. Wir stellen sicher, dass anzahlNoten erhöht wird.

class StudiNoten
{
  final int ARRAYLAENGE = 25;

  // Instanzvariablen
  private String name;         // der Name des Studierenden
  private int[]  noten;        // das Array mit den Noten
  private int    anzahlNoten;  // wie viele Elemente Daten enthalten

  // Konstruktor
  StudiNoten( String studiName )
  {
    name = studiName  ;
    noten =  new int[ ARRAYLAENGE ] ;
    anzahlNoten =  0  ;
  }

  // Methoden
  public void toString () { ..... }

  public void hinzufuegenNote ( int note )
  {
    if ( anzahlNoten < ARRAYLAENGE )
      noten[  ] = note ;

     ++  ;

  }

}

Wir studieren sorgfältig wie die Variable anzahlNoten arbeitet. Sie enthält sowohl die Anzahl der Array Elemente, die Daten enthalten, als auch den Index des nächsten verfügbaren Elements. Dies ist ein gebräuchlicher Programmiertrick.

8. Wir implementieren die berechneDurchschnitt() Methode. Wir stellen sicher, dass summe mit 0 initialisiert wird. Addieren dann die Noten und dividieren sie durch anzahlNoten, um den Durchschnitt zu bekommen.

class StudiNoten
{
  final int ARRAYLAENGE = 25;

  // Instanzvariablen
  private String name;         // der Name des Studierenden
  private int[]  noten;        // das Array mit den Noten
  private int    anzahlNoten;  // wie viele Elemente Daten enthalten

  // Konstruktor
  StudiNoten( String studiName ) { .... }

  // Methoden
  public void toString () { ..... }
  public void hinzufuegenNote ( int note ) { ..... }

  public double berechneDurchschnitt ( )
  {
    double summe =   ;

    for ( int j=0; j <  ; j++ )
      summe +=  [ j ] ;

       summe /  ;
  }

}

9. Wir implementieren die berechneMinimum() Methode. Wir stellen sicher, dass nur die tatsächliche Anzahl der Noten berücksichtigt wird.

class StudiNoten
{
  final int ARRAYLAENGE = 25;

  // Instanzvariablen
  private String name;         // der Name des Studierenden
  private int[]  noten;        // das Array mit den Noten
  private int    anzahlNoten;  // wie viele Elemente Daten enthalten

  // Konstruktor
  StudiNoten( String studiName ) { .... }

  // Methoden
  public void toString () { ..... }
  public void hinzufuegenNote ( int note ) { ..... }

  public double berechneDurchschnitt ( )
  {
    double summe =  0  ;

    for ( int j=0; j < anzahlNoten; j++ )
      summe += noten[ j ] ;

    return   summe / anzahlNoten ;
  }

  public int berechneMinimum( )
  {
    int min =   ;

    for ( int j=0; j <  ; j++ )

      if (   < min )
          min =   ;

    return  ;
  }

}

10. Wir implementieren die berechneMaximum() Methode. Das ist fast das Gleiche wie die berechneMinimum() Methode.

class StudiNoten
{
  final int ARRAYLAENGE = 25;

  // Instanzvariablen
  private String name;         // der Name des Studierenden
  private int[]  noten;        // das Array mit den Noten
  private int    anzahlNoten;  // wie viele Elemente Daten enthalten

  // Konstruktor
  StudiNoten( String studiName ) { .... }

  // Methoden
  public void toString () { ..... }
  public void hinzufuegenNote ( int note ) { ..... }

  public double berechneDurchschnitt ( ) { ..... }

  public int berechneMaximum( )
  {
    int max =   ;

    for ( int j=0; j <  ; j++ )

      if ( noten[j]  max )
          max =   ;

    return  ;
  }

}

Das gesamte Programm mit einer Klasse zum Testen: Wir speichern das Programm in unserer Entwicklungsumgebung und experimentieren damit.

class StudiNoten
{
  final int ARRAYLAENGE = 25;

  // Instanzvariablen
  private String name;         // der Name des Studierenden
  private int[]  noten;        // das Array mit den Noten
  private int    anzahlNoten;  // wie viele Elemente Daten enthalten

  // Konstruktor
  StudiNoten( String studiName )
  {
    name = studiName  ;
    noten =  new int[ ARRAYLAENGE ] ;
    anzahlNoten =  0  ;
  }

  // Methoden
  public String toString()
  {
    String str = "Name: " +  name  + "\n";

    for ( int j=0; j < anzahlNoten ; j++ )
      str += "Note " + j + ": " + noten[ j ] +", ";

    return str;
  }

  public void hinzufuegenNote ( int note )
  {
    if ( anzahlNoten < ARRAYLAENGE )
      noten[anzahlNoten] = note ;
    anzahlNoten ++ ;
  }

  public double berechneDurchschnitt ( )
  {
    double summe =  0  ;

    for ( int j=0; j < anzahlNoten; j++ )
      summe += noten[ j ] ;

    return   summe / anzahlNoten ;
  }

  public int berechneMinimum( )
  {
    int min = noten[ 0 ] ;

    for ( int j=0; j < anzahlNoten; j++ )

      if ( noten[j] < min )
        min = noten[j] ;

    return min ;
  }

  public int berechneMaximum( )
  {
    int max = noten[ 0 ] ;

    for ( int j=0; j < anzahlNoten; j++ )

      if ( noten[j] > max )
        max = noten[j] ;

    return max ;
  }

}

class StudiTester
{

  public static void main ( String[] args )
  {
     // ein Objekt StudiNoten erzeugen
     StudiNoten studi = new StudiNoten( "Laura Lyons" ) ;

     // ein paar Noten hinzufügen
     studi.hinzufuegenNote( 90 ) ;
     studi.hinzufuegenNote( 95 ) ;
     studi.hinzufuegenNote( 88 ) ;
     studi.hinzufuegenNote( 78 ) ;
     studi.hinzufuegenNote( 82 ) ;
     studi.hinzufuegenNote( 97 ) ;

     // das Objekt mit den neuen Daten ausgeben
     studi.toString() ;

     // Durchschnitt, Minimum und Maximum berechnen und ausgeben
     System.out.println( "Durchschnittsnote: " + studi.berechneDurchschnitt() + " Minimum: " + studi.berechneMinimum() +
         " Maximum: " + studi.berechneMaximum() );
     }
}

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

Zurück zum Inhaltsverzeichnis.