====== 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. ===== Die Zahlen von 1 bis 10 in eine jTextArea ausgeben =====


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. ===== Die Zahlen von 1 bis 49 ausgeben - 7 Zahlen pro Zeile =====


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

===== Die Zufallszahlen ===== 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. ===== Auch Zufallszahlen ===== 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:"));

===== Zufallszahlen in ein array speichern ===== 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]]. ===== VERSCHIEDENE Zufallszahlen ===== 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.