Stunde #2-3: Einen Thread implementieren
Wie wir schon in den vorherigen Lektionen besprochen haben, dienen Threads dazu, Prozesse simultan ablaufen zu lassen. Lasst uns nochmal ein Beispiel dazu anschauen:
|
1 2 3 4 5 |
@Override public void start() { Thread thread = new Thread(); thread.start(); } |
Das ist eigentlich recht einfach. Die erste Zeile erstellt einen neuen Thread mit dem Namen thread und die zweite Zeile startet diesen.
Wenn wir unseren Thread starten, wird momentan noch nichts geschehen. Nehmen wir hierzu das Beispiel #1-21:
|
1 2 3 4 5 6 7 |
Thread thread = new Thread(){ public void run () { for (int i = 0; i < 10; i += 2){ System.out.println("hello"); } } } |
Threads benötigen eine run Methode, welche entscheidet, was im Thread genau passiert. Genau deshalb passiert in unserem ersten Beispiel auch nichts. Wir haben keine run Methode erklärt und dies hat auch einen Grund. Wir werden die run Methode aus dem Thread herauslösen und eine separate Methode erstellen:
1. Wir implementieren das Runnable Interface zu unserer bestehenden Klasse wie folgt:
|
1 |
public class StartingClass extends Applet implements Runnable { |
2. Nun schreiben wir am Ende unseres Codes run und drücken STRG + Leertaste und wählen die erste Option. Damit wird der Code automatisch vervollständigt. Wir bekommen dabei auch noch wichtige Informationen angezeigt:
3. Nun müssen wir noch den Thread erstellen und ihn mit der run Methode verbinden. Dazu gehen wir zurück zu der start Methode und ergänzen Folgendes:
|
1 2 |
Thread thread = new Thread(this); thread.start(); |
Warum wir hier das Wort this verwenden, werden wir zu einem späterem Zeitpunkt erläutern, wenn wir etwas mehr Wissen haben. Nun müssten wir alle den folgenden Stand haben:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
package basteldroid; import java.applet.Applet; public class StartingClass extends Applet implements Runnable { @Override public void init() { // TODO Auto-generated method stub } @Override public void start() { // TODO Auto-generated method stub Thread thread = new Thread(this); thread.start(); } @Override public void stop() { // TODO Auto-generated method stub } @Override public void destroy() { // TODO Auto-generated method stub } @Override public void run() { // TODO Auto-generated method stub } } |
Stunde #2-4: Erstellen einer unendlichen Spielschleife
Hier werden wir eine Spielschleife erstellen. In der ersten Lektion dieses Kapitels haben wir bereits erfahren, dass diese der Herzschlag des Spieles ist. Sie überprüft ständig, ob sich etwas geändert hat und passt dies sofort an.
Je weiter wir in der Entwicklung kommen, desto komplexer werden die Schleifen. Für den Anfang müssen wir aber nur vier Dinge berücksichtigen:
1. Update Spieler
2. Update Umgebung
3. Zeichne Grafik neu
4. Schlafe für 17 Millisekunden
Aber warum benötigen wir Punkt 4?
Filme und Spiele werden bei 30 Bildern pro Sekunde flüssig dargestellt. Um kein Stocken oder Hängen zu bekommen, finden die meisten, dass 60 Bilder pro Sekunde das beste sind. 1000 / 60 ergibt 17 Millisekunden. Das bedeutet nun also, dass unser Spiel alle 17 Millisekunden neu angepasst wird. Setzt man voraus, dass der Prozessor diese Leistung schafft, sollten wir ein sehr flüssiges Spiel erstellen können. Da wir momentan ein sehr einfaches Spiel programmieren, sollte das kein Problem sein.
Als Erstes erstellen wir eine Spielschleife in unserer run Methode:
1. Diese Schleife wird eine while Schleife werden und unendlich lange laufen. Um die while Schleife andauernd laufen zu lassen, schreiben wir einfach true in die Klammern.
|
1 2 3 |
while(true){ } |
2. Innerhalb der Schleife fügen wir den folgenden Code ein:
|
1 2 3 4 5 |
repaint(); Thread.sleep(17); } |
repaint ist eine eingebaute Methode, diese ruft die paint (zeichnen) Methode auf, mit welcher wir Objekte auf dem Bildschirm zeichnen. Wir haben diese Methode zwar noch nicht erstellt, rufen sie aber alle 17 Millisekunden auf.
Nun wollten wir einstellen, dass unser Thread 17 Millisekunden schläft. Eclipse zeigt uns aber sofort an, wenn ein Code fehlerhaft ist. Thread.sleep erzeugt diesen Fehler. Wenn wir nun darauf klicken, können wir try und catch auswählen.
In try versuchen wir, etwas zum Laufen zu bringen, in diesem Fall sleep bzw. schlafen.
In catch werden eventuelle Fehlerinformationen gespeichert und es wird uns auf dem Bildschirm dargestellt.
Darüber brauchen wir uns aber erstmal keine Gedanken zu machen. Dies ist ein eingebautes ausfallsicheres System. Unser Programm wird deshalb trotzdem funktionieren.
Nun müssten wir alle den folgenden Stand haben:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
package basteldroid; import java.applet.Applet; public class StartingClass extends Applet implements Runnable { @Override public void init() { // TODO Auto-generated method stub } @Override public void start() { // TODO Auto-generated method stub Thread thread = new Thread(this); thread.start(); } @Override public void stop() { // TODO Auto-generated method stub } @Override public void destroy() { // TODO Auto-generated method stub } @Override public void run() { // TODO Auto-generated method stub while (true) { repaint(); try { Thread.sleep(17); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } |
Stunde #2-5: Definieren der Größe, des Hintergrundes und des Titels
Wir haben uns schon in der ersten Lektion die vier von uns erstellten Methoden genauer angesehen: init, start, stop und destroy.
Diese vier Methoden laufen nach dem Lebenszyklus unseres Programms ab. Wir werden uns jetzt init näher ansehen. Wenn Applet das erste Mal ausgeführt wird, startet es die init Methode. Diese läuft genauso ab wie die main(String args[]) Methode bei einem normalen Programm.
Wir werden nun innerhalb dieser Methode die folgenden Parameter definieren:
1. Größe des Applet
2. Hintergrundfarbe
3. Applet-Titel
Wir werden nun folgendes in die Methode schreiben
1. setSize(800, 480);
Damit bestimmen wir die Größe auf 800 mal 480 Pixel, dies ist die häufigste Android Auflösung
2. setBackground(Color.Black);
Hier stellen wir einen schwarzen Hintergrund ein. Erinnert euch daran, dass wir hier eine Konstante Black aufrufen aus der Color Superklasse, daher müssen wir diese auch importieren.
3. setFocusable(true);
Wenn unser Spiel startet, sorgt diese Anweisung dafür, dass der Fokus auf unserem Spiel liegt und unsere Eingaben unmittelbar ins Spiel einfließen können. Ohne diese Anweisung müssten wir erst darauf klicken, bevor wir eine Eingabe im Spiel tätigen könnten.
4. Frame frame = (Frame) this.getParent().getParent();
frame.setTitle(„Q-Bot Alpha“);
Frame muss auch erst importiert werden, damit wir dies verwenden können. Dies ist an dieser Stelle etwas kompliziert zu erklären. Zum jetzigen Zeitpunkt genügt es zu wissen, dass die erste Zeile das Applet Fenster unserer frame Variablen zuweist. Die zweite Zeile weist unserem Titel den String „Q-Bot Alpha“ zu. Das ist nicht endgültig, das können wir später noch ändern.
Nun sollten wir alle diesen Stand haben:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
package basteldroid; import java.applet.Applet; import java.awt.Color; import java.awt.Frame; public class StartingClass extends Applet implements Runnable { @Override public void init() { // TODO Auto-generated method stub setSize(800, 480); setBackground(Color.BLACK); setFocusable(true); Frame frame = (Frame) this.getParent().getParent(); frame.setTitle("Q-Bot Alpha"); } @Override public void start() { // TODO Auto-generated method stub Thread thread = new Thread(this); thread.start(); } @Override public void stop() { // TODO Auto-generated method stub } @Override public void destroy() { // TODO Auto-generated method stub } @Override public void run() { // TODO Auto-generated method stub while (true) { repaint(); try { Thread.sleep(17); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } |
Für alle, die etwas Zeit sparen wollen, hier nochmal ein paar hilfreiche Short-Cuts bzw. Tastenkombinationen:
STRG + Shift + O – automatisches Importieren von Code, kann eventuell auch das Falsche importieren
STRG + Shift + F – automatisches Formatieren unseres Codes
STRG + Space – öffnet die automatische Vorschlagbox
Source Code
Für diejenigen unter euch, die hier einsteigen möchten, ohne den ganzen Code abtippen zu müssen, habe ich das Projekt exportiert. Mit der Importfunktion könnt ihr das Projekt bequem bei euch einfügen. Unter der Kategorie Eclipse und Java > Import und Export habe ich erklärt, was dafür zu tun ist.
Falls ihr Fragen habt, immer raus damit, ich helfe euch sehr gerne. Hinterlasst bitte einfach einen Kommentar.
Teilt diese Seite mit euren Freunden und besucht uns mal auf Facebook und auf Google+, das würde dieser Seite wirklich weiterhelfen, danke sehr. Auch ein Klick auf die Werbung hilft dabei, diese Seite am Laufen zu halten.
Quelle: Original Anleitung auf englisch von Kilobolt Studios