Home > Informatik > Stufe EF > Folge 7 (Arrays)

7.1 Einfache Arrays, Teil 2

Arrays - Objekt-Arrays - verstehen - Held

Eine Klasse für natürliche Zahlen

Unter den natürlichen Zahlen versteht man in der Regel die positiven ganzen Zahlen $\mathbb{N}$, mit $\mathbb{N}$ = {1, 2, 3, 4, ...}.

Wir wollen nun eine Klasse NZahlen schreiben, mit denen wir die natürlichen Zahlen sowie einige Operationen auf $\mathbb{N}$ modellieren können.

Natürliche Zahlen können in Java am besten durch den Datentyp int dargestellt werden. Bei der Implementierung müssen wir dann nur aufpassen, dass wir keine negativen int-Zahlen verwenden, sondern nur positive.

Als erstes erzeugen wir einen Array, der aus 100 int-Zahlen besteht. Nach den Ausführungen in Teil 1 sollte dies für Sie kein Problem mehr sein.

Deklaration und Initialisierung des Arrays
public class NZahlen
{
    int[] zahlen;
    
    public NZahlen()
    {
       zahlen = new int[100];
    }
}

Achtung: Die Klasse heißt NZahlen, der Array dagegen zahlen. Diese beiden Bezeichner sollten nicht verwechselt werden.

Eine einfache Ausgabe-Methode
    public void ausgeben()
    {
       for (int i=0; i < 100; i++)
          System.out.println("Zahl " + i + " = " + zahlen[i]);
    }

Wenn wir diese Methode auführen, sehen wir, dass alle 100 Arrayelemente den Wert 0 haben. In der Tat werden die Elemente eines neu erzeugten int-Arrays alle mit dem Wert 0 initialisiert. Das sind aber noch keine natürlichen Zahlen, denn die fangen ja mit 1 an und nicht mit 0.

Den Array mit Zufallszahlen füllen

Wir wollen den Array nun mit Zufallszahlen aus $\mathbb{N}$ = {1, 2, 3, ..., 1000}. füllen. Dazu muss unser Programm eine Java-Bibliothek importieren, das geschieht mit der Zeile

import java.util.Random;

Wird diese Zeile ganz oben in den Java-Quelltext geschrieben, kann die Klasse NZahlen auf die Klasse Random zugreifen und Objekte dieser Klasse anlegen.

Zwischenstand

Hier das ganze bisherige Programm:

import java.util.Random;

public class NZahlen
{
    int[] zahlen;
    
    public NZahlen()
    {
       zahlen = new int[100];
    }
    
    public void ausgeben()
    {
       for (int i=0; i < 100; i++)
          System.out.println("Zahl " + i + " = " + zahlen[i]);
    }
    
    public void mitZufallszahlenBelegen()
    {
       Random generator = new Random();
       
       for (int i=0; i < 100; i++)
          zahlen[i] = generator.nextInt(1000) + 1;
    }
}

In der Methode mitZufallszahlenBelegen() wird zunächst ein Objekt generator der Klasse Random erzeugt. Aber das haben wir ja schon im ersten Teil dieses Workshops kennengelernt.

In der for-Schleife wird dann jedem der 100 Arrayelement eine Zufallszahl im Bereich zwischen 1 und 1000 zugewiesen. Die Methode nextInt() der Klasse Random liefert diese Zufallszahl. Der Parameter dieser Methode definiert den Bereich, in dem die Zufallszahlen liegen. Hätte man den Wert 80 übergeben, so würde nextInt() Zahlen im Bereich zwischen 0 und 79 erzeugen. Denken Sie immer daran: Informatiker fangen bei 0 an zu zählen, Informatikerinnen übrigens auch. Mit dem Parameter 1000 werden also Zahlen im Bereich zwischen 0 und 999 erzeugt. Weil wir nun noch die 1 dazu addieren, erhalten wir Zahlen im Bereich zwischen 1 und 1000.

Übungen

Übung 7.1-1 (*)

Schreiben Sie für die Klasse NZahlen eine sondierende Methode

public int gibSumme()

welche alle 100 Zufallszahlen des Arrays addiert und das Ergebnis dann zurückliefert.

Lösungsvorschlag auf den Seiten für Lehrer(innen) / Nähere Infos dazu

Übung 7.1-2 (*)

Schreiben Sie für die Klasse NZahlen eine sondierende Methode

public int gibKleinsteZahl()

welche alle 100 Zufallszahlen des Arrays durchsucht und als Ergebnis die kleinste Zahl zurückliefert.

Lösungsvorschlag auf den Seiten für Lehrer(innen) / Nähere Infos dazu

Übung 7.1-3 (**)

Schreiben Sie für die Klasse NZahlen eine sondierende Methode

public int gibAnzahlVon(int z)

welche als Ergebnis zurückliefert, wie oft die Zahl z in dem Array vorkommt.

Lösungsvorschlag auf den Seiten für Lehrer(innen) / Nähere Infos dazu

Experten-Übung 7.1-4 (****)

1.) Reduzieren Sie in Ihrem Quelltext die Zahl der Arrayelemente auf 20.

2.) Sorgen Sie dafür, dass die Arrayelemente nur mit Zufallszahlen zwischen 1 und 50 belegt werden.

3.) Schreiben Sie dann eine manipulierende Methode

public void zeigeSterne()

welche die Werte der Arrayelemente als Reihe von Sternzeichen * anzeigt.

Angenommen, das erste Arrayelement enthält die Zahl 17, das zweite Element die Zahl 30 und das dritte Element die Zahl 12. Dann müssen die drei ersten Zeilen, die von dieser Methode in die Konsole ausgegeben werden, so aussehen:

*****************
******************************
************

Die Konsole zeigt dann 20 Zeilen unterschiedlicher Länge an, da der Array jetzt aus 20 int-Zahlen besteht.

Lösungsvorschlag auf den Seiten für Lehrer(innen) / Nähere Infos dazu

Experten-Übung 7.1-5 (*****)

Man kann eine for-Schleife auch etwas einfacher gestalten. Hier sehen Sie eine Methode mit einer solchen for-Schleife:

    public int gibSumme()
    {
       int sum = 0;
       for (int i:zahlen)
          sum += i; 
       
       return sum;
    }

In dem Schleifenkopf wird eine int-Variable i initialisiert, welche dann nacheinander die Werte der einzelnen Arrayelemente aufnehmen wird. Die Zeile

sum += i;

wird dann korrekt ausgeführt. Es wird nicht der Wert der Laufvariable i zu sum addiert, sondern der Wert des Arrayelementes mit dem Index i. Streng genommen ist i dann auch keine Laufvariable mehr.

Nun zur eigentlichen Aufgabe:

Betrachten Sie folgenden Quelltext:

    public void ausgeben()
    {
       for (int i:zahlen)
          System.out.println("Zahl " + i + " = " + zahlen[i]);
    }

Wenn man diesen Quelltext kompiliert, kommt es zu einer Fehlermeldung. Erläutern Sie, wie diese Fehlermeldung zustande kommt!

Lösungsvorschlag auf den Seiten für Lehrer(innen) / Nähere Infos dazu

Seitenanfang -
Weiter mit Objekt-Arrays...