Erste Gehversuche mit Applets

Ich steige mit einem „Hallo Welt“-Programm ein - wie sich das gehört. Das schreibe ich allerdings hier nicht auf. Lediglich ein paar Methoden und Objekte, die dafür benutzt werden könnten:

lAusgabe.setText("Hallo Welt!");
taAusgabe.setText ("Hallo Welt");
taAusgabe.append ("Hallo Welt!");

Java ist objektorientiert. Wow! Ja und? Das heißt, Wenn der Rechner irgendetwas tun soll, müssen wir das einem Objekt mitteilen. Z.B. sagen wir einem label, bitte liebes label, gib doch mal folgenden Text aus. Da Objekte im Allgemeinen recht freundlich sind, wird das label dieser Aufforderung nachkommen - jedenfalls, wenn die Nachricht korrekt geschrieben wurde. Der Aufbau dieser Nachrichten ist immer der gleiche:

nameDesObjekts.nameDerNachricht(eventuellVorhandeneParameter)

In dem Fall mit dem label, nennen wir es lAusgabe, lautet der Aufruf:

lAusgabe.setText("Hallo Welt!");

Auf deutsch:„Hör ma, liebes Label, ändere doch bitte mal Deine Aufschrift um in 'Hallo Welt!'“ - Kein Bitte, kein Danke…

Wenden wir uns nun noch schwierigeren Algorithmen zu.

for (int i=1; i<=10; i++) {
    taAusgabe.append(Integer.toString(i)+i" "
}

Erläuterungen:

• int steht für Integer bzw. ganze Zahlen mit 32 Bit Größe.
• for steht für eine Schleife, bei der
  • eine Integervariable einen Startwert erhält,
  • die Anweisungen in der folgenden geschweiften Klammerung solange wiederholt wird, wie die Bedingung in den runden Klammern eine wahre Aussage ergibt und
  • die Integervariable um einen im dritten Teil der runden Klammer definierten Wert nach jedem Schleifendruchlauf verändert wird. Hier: Plus 1
• append hängt den neuen Text an den schon vorhandenen an.
• Integer.toString macht aus einer Integervariablen einen String (Text), da Java nur Strings ausgeben kann.

for (int i=1; i<=49; i++) {
    taAusgabe.append(Integer.toString(i)+" ");
    if (i%7==0) {
        taAusgabe.append("\n");
    }
}

Erläuterungen:

• i%7 (sprich i modulo 7) ergibt den Rest der Division von i durch 7. Beispiel: 4 durch 7 ist gleich 0 Rest 4. Also ergibt 4%7 4. 11%7 ergibt auch 4. 13%7 ergibt 6. 14%7 ergibt 0. Das heißt, nach jeder 7 Zahl (die ja durch 7 teilbar ist und daher bei der Division durch 7 einen Rest von 0 ergibt) wird ein Zeilenumbruch („\n“) ausgegeben.
• == vergleicht 2 Werte und gibt entweder true oder false. Wird nur ein Gleichheitszeichen notiert, so erwartet der Compiler eine Zuweisung - keinen Vergleich!

Zweite Möglichkeit (Danke Lukas!)

for (int i=1; i<=49; i+=7) {
    for (int z=i; z<=i+6; z++) {
        taAusgabe.append (Integer.toString(z)+" ");
    }
    taAusgabe.append("\n");
}

Benötigt man bestimmte mathematische Funktionen, wie die Bestimmung einer Zufallszahl, so kann man auf die Wrapper-Klasse Math zurückgreifen. Diese Klassen werden immer dann verwendet, wenn es wenig oder keinen Sinn macht ein Objekt einer bestimmten Klasse zu generieren. Es wird hier lediglich die Verwendung mathematischern Methoden gefordert, wer diese zu Verfügung stellt, ist eigentlich wurscht. Trotzdem wird in Java die objektorientierte Schreibweise gefordert. Es gibt also kein Objekt namens Math. Es handelt sich hier um die Wrapper-Klasse. Daher liefert der Aufruf

Math.random()

eine Zufallszahl, die im Intervall [0;1[ liegt. Nein, das ist kein Tippfehler. Die mathematisch korrekte Klammerung des Intervalls bedeutet, dass die Null im Intervall enthalten ist und die Eins nicht. Sollen aus einer solchen Zahl aber ganze Zahlen von 1 bis 49 erstellt werden, ist folgende Rechnung notwendig:

(int)Math.round(  Math.random()*49 + 0.5  );

Die Intervalllänge wird von [0;49[ aufgeblasen und nach [0,5; 49,5[ verschoben. Durch das Runden ergeben sich Dezimalbrüche, deren Nachkommastellen sämtlich 0 sind. (int) macht aus dem Dezimalbruch wieder eine ganze Zahl.

Mit Hilfe einer for-Schleife können nun beliebig viele Zufallszahlen ausgegeben werden.

Viele schöner geht das allerdings mit Hilfe der Klasse Random. Man erzeugt zunächst ein Objekt dieser Klasse. Das Objekt ist dann dafür zuständig Zufallszahlen zu liefern. Man fragt es einfach danach. Im folgenden Beispiel wird dem Konstruktor von Random eine 3 überliefert. Somit wird die erste „Zufalls“zahl festgelegt - sehr praktisch zum Testen!

        Random zufallszahlen = new Random(3);
        int wuerfel = zufallszahlen.nextInt(6);

Auch hübsch:

            int zahl = Integer.parseInt(javax.swing.JOptionPane.showInputDialog("Neue zahl:"));

Meistens müssen Zahlen gespeichert werden, damit sie beispielsweise vor der Ausgabe sortieren kann. Im Fall der Lottozahlen bietet sich die Verwendung eines array (einer Reihung) an. Erzeugen und speichern der Zahlen:

int [] zahlen = new int [6]; 
for (int i=0; i<=5; i++) {
    zahlen[i] = (int)Math.round( Math.random()*49+0.5 );
}

Danach kann man sie beispielsweise mit einer weiteren for-Schleife ausgeben:

for (int i=0; i<=5; i++) {
    taAusgabe.append(Integer.toString(i)+" ");
}

Ausführliche Information findest Du unter arrays.

Ein sehr eleganter Algorithmus stammt von Lukas Mäusezahl. Vielen Dank dafür!

Er baut darauf auf, die vorhandenen Zahlen von 1 bis 49 eine Weile lang zu durchmischen. Dazu werden die Zahlen von 1 bis 49 zunächst in einem array gespeichert:

int [] kugeln = new int [49];   // Der array wird erzeugt.
for (int i=1; i<=49; i++) {
    kugeln[i-1] = i;            // Die Felder des arrays sind von 0 bis 48 nummeriert
                                // und erhalten die Zahlen von 1 bis 49.
}    

Nun kann gemischt werden.

for (int i=1; i<=ganzGrosseZahl; i++) {
    int posFeld1 = (int)Math.round(Math.random()*49-0.5);
    int posFeld2 = (int)Math.round(Math.random()*49-0.5);
    // Inhalte der beiden zufällig gewählten Felder tauschen:
    int zwischenspeicher = kugeln[posFeld1];
    kugeln[posFeld1]=kugeln[posFeld2];
    kugeln[posFeld2]=zwischenspeicher;
}

Da keine neuen Kugeln erzeugt werden, sondern lediglich ihre Positionen im array ausgetauscht werden, kann es nicht passieren, dass eine Zahl doppelt vorkommt.

Im Anschluss gibt man einfach die ersten 6 Zahlen des array aus.