Stunde #1-21: Themen (Threads)
Bisher haben wir in Java immer eine sehr einfache und generelle Regel befolgt, wenn wir den Run Knopf gedrückt haben, ist unser Programm von oben nach unten durchgelaufen, außer bei einer Schleife.
Bei der Spieleentwicklung benötigt man jedoch mehrere Prozesse, die simultan ablaufen und genau hier kommen uns die verschiedenen Themen (Threads) zu gute.
Das Wort Thread bedeutet, dass wir einen Prozess abhandeln. Wenn wir nun mehrfache Threads haben, werden verschiedene Prozesse simultan ausgeführt.
Wie erstellen wir nun einen Thread?
Die Methode ist ähnlich der Random Methode. Um ein zufälliges Objekt zu erstellen, nutzen wir folgenden Code:
|
1 |
Random random = new Random(); |
Und ein Thread wird folgendermaßen erstellt:
|
1 |
Thread thread = new Thread(); |
Somit haben wir einen Thread namens Thread erstellt. Aber anderst als bei Random müssen wir nun noch eines zusätzlich machen. Threads benötigen eine run() Methode, welche wir direkt in die obige Zeile einfügen.
Beispiel 1: Threads
1. Wir fügen geschweifte Klammern hinzu
|
1 |
Thread thread = new Thread(){ }; |
2. Innerhalb dieser geschweiften Klammern, werden wir die run() Methode platzieren, erinnert euch, dies ist zwingend notwendig. Dieses Vorgehen ist etwas anders als zuvor, stellt euch hierbei einfach die Hierarchie vom Java Code vor:
|
1 2 3 4 |
Thread thread = new Thread(){ public void run () { } }; |
3. Wenn wir nun wollen, dass dieser Thread startet, müssen wir dies auch Java mitteilen. Es gibt einen Code, der bereits in Java eingebaut ist, der das ausführt: .start();
|
1 |
thread.start(); |
4. Wenn unser Thread nun gestartet ist, mit der Hilfe von .start(); sucht Java nach der Thread run Methode und beginnt diese auszuführen. Momentan ist unserer Thread leer, also fügen wir ein wenig hinzu:
|
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"); } } }; |
5. Wenn wir nun unserer Thread starten würden, mit thread.start(); würden wir folgendes sehen:
|
1 2 3 4 5 |
hello hello hello hello hello |
6. Ein Thread alleine bringt keinem etwas, also schreiben wir einen zweiten. So würde der volle Code aussehen:
|
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 |
public class ThreadDemo { public static void main(String args[]) { //Das ist der erste Block unserer Codes. Thread thread = new Thread() { public void run() { for (int i = 0; i < 10; i += 2) { System.out.println("Hallo das ist Thread eins"); } } }; //Das ist der zweite Block unserer Codes. Thread threadTwo = new Thread() { public void run() { for (int i = 0; i < 10; i += 2) { System.out.println("Hallo das ist Thread zwei"); } } }; //Diese 2 Statements sind in der Main Methode und beginnen die 2 Threads. //Das ist der dritte Block unserer Codes. thread.start(); //Das ist der vierte Block unserer Codes. threadTwo.start(); } } |
Lasst uns jetzt einen Blick darauf werfen, was genau hier geschieht. Wenn Java beginnt, dieses Programm durch zu laufen, schaut es als Erstes nach der Main Methode. Diese beinhaltet 4 Blöcke.
Der erste Block erstellt einen Thread namens thread und erstellt eine run Methode. Der zweite Block erstellt einen Thread namens threadTwo und erstellt eine run Methode. Der dritte Block startet den Thread thread und der vierte startet den threadTwo.
Ausgabe:
|
1 2 3 4 5 6 7 8 9 10 |
Hallo das ist Thread eins Hallo das ist Thread eins Hallo das ist Thread eins Hallo das ist Thread eins Hallo das ist Thread eins Hallo das ist Thread zwei Hallo das ist Thread zwei Hallo das ist Thread zwei Hallo das ist Thread zwei Hallo das ist Thread zwei |
Irgendwie sind hier aber keine simultanen Prozesse am Laufen, sondern alles nacheinander?
Warum das so ist, werden wir im Kapitel 2 genauer behandeln.
Stunde #1-22: Grafik (Graphics)
Menschen mögen eine tolle Grafik, mit der sie interagieren können. Funktionalität ist sehr wichtig hierbei. Wir reden bei der Grafik von GUI (graphical user interface) bzw. grafische Benutzeroberfläche.
Wir werden heute nur einen Bruchteil von dem ansprechen, was uns bei diesem Thema erwartet, wir können dann aber immerhin schon etwas graphisches darstellen. Wir reden hier aber erstmal von Bildern. Grafik, wie sie in Spielen verwendet wird, ist etwas komplizierter.
Heute werden wir als Erstes ein Fenster abbilden, welches Bilder darstellen kann. Danach werden wir versuchen, auch wirklich Bilder darzustellen.
Als Erstes erstellen wir eine neue Klasse mit dem Namen GrafikDemo.
|
1 2 3 |
public class GrafikDemo { } |
Nun wenden wir unser Wissen aus der letzten Lektion an. Um Bilder anzeigen zu lassen, müssen wir die Klasse erweitern, also nutzen wir hier Inheritance, dazu benötigen wir extends JFrame:
|
1 2 3 |
public class GrafikDemo extends JFrame { } |
Nun wird uns Eclipse einen Fehler bringen, diesen können wir auf 2 Arten lösen:
1. STRG + Shift + O
2. Wir gehen mit dem Mauszeiger über das Wort JFrame und importieren so das Nötige:
Nun müssten wir folgenden Stand haben:
|
1 2 3 4 5 |
import javax.swing.JFrame; public class GrafikDemo extends JFrame { } |
Eines der ersten Dinge, die wir gelernt haben, war, das Klassen Pläne oder Entwürfe von Objekten sind. Wir haben uns aber nie darüber unterhalten, wie das wirklich funktioniert.
Heute werden wir mit der GrafikDemo Klasse ein Objekt erzeugen, genauso wie wir oben ein Thread erzeugt haben. Um dies zu bewerkstelligen, müssen wir einen Konstrukteur (constructor) verwenden. Ein Konstrukteur ist einfach eine Anleitung zum Erstellen eines Objekts.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import javax.swing.JFrame; public class GrafikDemo extends JFrame { //Der Konstrukteur public GrafikDemo(){ } //alle Klassen benötigen eine Main Methode public static void main(String args[]){ //Wir erstellen ein GrafikDemo Objekt in der Main Methode. //Das sollte uns bekannt sein von Random und Threads. GrafikDemo demo = new GrafikDemo(); } } |
Dieser Code schaut, wenn er ausgeführt wird, nach der Main Methode. In dieser Main Methode ist ein Statement:
|
1 |
GrafikDemo demo = new GrafikDemo(); |
Wenn dieses Statement ausgeführt wird, erstellen wir ein GrafikDemo Objekt mit dem Konstrukteur aus der GrafikDemo Klasse. Der Name des Objekts ist demo. Momentan ist der Konstrukteur aber noch leer:
|
1 2 3 4 |
//Der Konstrukteur public GrafikDemo(){ } |
Also wird bei der Ausführung nichts ausgeführt. Nun werden wir dem Konstrukteur den nötigen Code hinzufügen. Dies werden wir tun, indem wir aus der Super Klasse JFrame ein Statement importieren.
|
1 2 3 4 5 6 7 8 |
//Der Konstrukteur public GrafikDemo(){ setTitle("GrafikDemo mit Basteldroid"); setSize(800,480); setVisible(true); setDefaultCloseOperation(EXIT_ON_CLOSE); } |
Die erste Zeile erstellt einen Titel für das zu erstellende Fenster. Das zweite gibt die Größe des Fensters in Pixeln an. Die dritte Zeile stellt sicher, dass das Fenster auch angezeigt wird. Die letzte Zeile ermöglicht es, das Programm zu beenden, sollte das Fenster geschlossen werden.
Nun sollten wir folgenden Code haben:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
import javax.swing.JFrame; public class GrafikDemo extends JFrame { //Der Konstrukteur public GrafikDemo(){ setTitle("GrafikDemo mit Basteldroid"); setSize(800,480); setVisible(true); setDefaultCloseOperation(EXIT_ON_CLOSE); } //Alle Klassen benötigen eine Main Methode. public static void main(String args[]){ //Wir erstellen ein GrafikDemo Objekt in der Main Methode //Das sollte uns bekannt sein, von Random und Threads GrafikDemo demo = new GrafikDemo(); } } |
Jetzt starten wir das Programm mit run und es öffnet sich folgendes Fenster:
Wichtig: Der Startpunkt (0,0) vom Koordinatensystem ist OBEN LINKS im Fenster, es ist nicht unten Links. Das bedeutet der Y Wert wird größer, je weiter runter wir auf dem Bildschirm gehen.
Um ein Bild anzeigen zu lassen, müssen wir nur einfach eine weitere Methode hinzufügen:
|
1 2 3 |
public void paint(Graphics g){ } |
Hier müssen wir Graphics importieren, also bittet tut dies.
Diese Methode wird nun alles zeichnen, was wir ihr sagen, in dem Fenster welches wir erstellt haben. Wir werden nun ein paar einfache Statements lernen.
Das g bedeutet, dass diese Statements am Objekt g ausgeführt werden.
g.clearRect(int x, int y, int width, int height); – erstellt ein Rechteck mit der momentanen Farbe, am Punkt (x,y) mit der Höhe und Breite.
g.setColor(Color c); – benennt die momentane Farbe von g als Farbe c.
g.drawString(String str, int x, int y); – zeichnet jeden Text am Punkt (x,y).
g.drawRect(int x, int y, int width, int height); – zeichnet ein Rechteck am Punkt (x,y) mit der Höhe und Breite.
Lasst uns das mal an unserem Programm zeigen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public void paint(Graphics g){ //Jetzt setzen wir die Farbe Weiß ein. g.setColor(Color.WHITE); //Hier zeichnen wir den Hintergrund über das komplette Fenster. g.fillRect(0,0,800,480); //Hier sagen wir, dass g blau sein soll. g.setColor(Color.BLUE); //Hier zeichnen wir ein blaues Rechteck. g.drawRect(60, 200, 100, 250); //Jetzt setzen wir die Farbe Schwarz ein. g.setColor(Color.BLACK); //Zum Schluss lassen wir einen Text anzeigen. g.drawString("Mein Name ist Andreas", 200, 400); } |
Wir nehmen den Code Color.White, Color.BLUE und COLOR.Black von der Color Super Klasse aus der Java Bibliothek, also müssen wir diese noch importieren. Wie das geht, wisst ihr ja?
Nun sind wir fertig mit unserem Programm und es sieht wie folgt aus:
|
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 |
import java.awt.Color; import java.awt.Graphics; import javax.swing.JFrame; public class GrafikDemo extends JFrame { //Der Konstrukteur public GrafikDemo(){ setTitle("GrafikDemo mit Basteldroid"); setSize(800,480); setVisible(true); setDefaultCloseOperation(EXIT_ON_CLOSE); } public void paint(Graphics g){ //Jetzt setzen wir die Farbe Weiß ein. g.setColor(Color.WHITE); //Hier zeichnen wir den Hintergrund über das komplette Fenster. g.fillRect(0,0,800,480); //Hier sagen wir, dass g blau sein soll. g.setColor(Color.BLUE); //Hier zeichnen wir ein blaues Rechteck. g.drawRect(60, 200, 100, 250); //Jetzt setzen wir die Farbe Schwarz ein. g.setColor(Color.BLACK); //Zum Schluss lassen wir einen Text anzeigen. g.drawString("Mein Name ist Andreas", 200, 400); } //Alle Klassen benötigen eine Main Methode. public static void main(String args[]){ //Wir erstellen ein GrafikDemo Objekt in der Main Methode //Das sollte uns bekannt sein, von Random und Threads GrafikDemo demo = new GrafikDemo(); } } |
Das Ergebnis sieht wie folgt aus:
Und damit haben wir unsere erste Grafik gezeichnet und beenden hiermit die Grundlagen von Java und werden weiter gehen zu Kapitel 2 Erstellen eines Spiels.
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
Lektion 10 – Inheritance und Interface Kapitel 2 Erstellen eines Spiels