Let’s Play. Programmieren lernen mit Java und Minecraft · 11 Einleitung Liebe Leserinnen und...

5

Inhalt

Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Kapitel 1 Java 15

1.1 Programmiersprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.2 Besonderheiten von Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171.3 Installation und Einrichtung . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

1.3.1 Java-Compiler installieren . . . . . . . . . . . . . . . . . . . . . . 201.3.2 Ordner einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

1.4 Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Kapitel 2 Minecraft-Server 25

2.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262.1.1 CraftBukkit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262.1.2 Spigot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

2.2 Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.3 Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362.4 Verbinden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372.5 Updates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

Kapitel 3 Das erste Plugin 43

3.1 Programmieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433.2 Kompilieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3.2.1 Fehler finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473.2.2 Jar-Datei erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

3.3 Starten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503.4 Entdecken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523.5 Rätsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

© des Titels »Let’s Play. Programmieren lernen mit Java und Minecraft« (ISBN 9783958457942) 2017 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/794

6

Inhalt

Kapitel 4 Chat-Befehle 55

4.1 Eigene Befehle definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564.2 Chat-Nachrichten versenden . . . . . . . . . . . . . . . . . . . . . . . . . . . 604.3 Rätsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

Kapitel 5 Eclipse installieren und einrichten 63

5.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635.2 Einrichtung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645.3 Ein neues Projekt anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655.4 Neue Dateien in einem Projekt anlegen . . . . . . . . . . . . . . . . . . 67

5.4.1 Java-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685.4.2 Info-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

5.5 Kompilieren und packen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

Kapitel 6 Variablen und Konstanten 73

6.1 Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 736.1.1 Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 746.1.2 Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776.1.3 Konvertierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 826.1.4 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

6.2 Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 956.3 Rätsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 966.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

Kapitel 7 Schleifen 101

7.1 Kürbis-Plugin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017.1.1 Positionierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1027.1.2 Blöcke platzieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

7.2 Die verschiedenen Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . 1077.2.1 for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1087.2.2 while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1127.2.3 do-while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1177.2.4 Verschachtelte Schleifen . . . . . . . . . . . . . . . . . . . . . . . 118


7

Inhalt

7.3 Rätsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1227.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

Kapitel 8 Verzweigungen 127

8.1 if-Verzweigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1278.2 case-Verzweigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1348.3 Rätsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1368.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

Kapitel 9 Funktionen 139

9.1 Deklaration von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . 1399.2 Rückgabewerte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1409.3 Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1419.4 Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1429.5 Rätsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1469.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

Kapitel 10 Klassen und Objekte 149

10.1 Die ganze Welt ist ein Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . 14910.2 Erstellung einer eigenen Klasse . . . . . . . . . . . . . . . . . . . . . . . . 15210.3 Funktionen in Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15510.4 Zugriffskontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16310.5 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16510.6 Abstrakte Methoden und Klassen . . . . . . . . . . . . . . . . . . . . . . 17010.7 Bau-Plugin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17310.8 Rätsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17810.9 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

Kapitel 11 Bauen 181

11.1 Notunterkunft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18111.1.1 Wände und Decke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18211.1.2 Tür . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18711.1.3 Bett . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19111.1.4 Fackel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195


8

Inhalt

11.2 Runde Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19911.2.1 Kreise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20011.2.2 Kugeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

11.3 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

Kapitel 12 Schilder 209

12.1 Hängende Schilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20912.2 Stehende Schilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21012.3 Text festlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

12.3.1 Farbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21312.3.2 Formatierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

12.4 Schilder-Plugin (Listen) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21612.4.1 Listen-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21712.4.2 Das Plugin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220

12.5 Rätsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23612.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

Kapitel 13 Listener 239

13.1 Grundgerüst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23913.2 Spieler-Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24013.3 Kreaturen-Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24713.4 Block-Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25113.5 Inventar-Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25413.6 Server-Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25513.7 Fahrzeug-Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25613.8 Wetter-Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25713.9 Welt-Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

13.10 Mehrere Listener in einem Plugin . . . . . . . . . . . . . . . . . . . . . . . 25813.11 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

Kapitel 14 Crafting-Rezepte 261

14.1 Rezepte festlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26114.2 Eigene Rezepte entwerfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26414.3 Feuerschwert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26514.4 Enderbogen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269


9

Inhalt


Kapitel 15 Informationen dauerhaft speichern 275

15.1 Konfigurationsdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27515.1.1 Lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27515.1.2 Schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

15.2 Objekte in Dateien speichern . . . . . . . . . . . . . . . . . . . . . . . . . . 28115.3 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296

Kapitel 16 Eigene Spielmodi entwickeln 299

16.1 Schneeballschlacht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29916.1.1 Schneebälle verteilen . . . . . . . . . . . . . . . . . . . . . . . . . 30016.1.2 Schneebälle automatisch auffüllen . . . . . . . . . . . . . . 30216.1.3 Punkte zählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30316.1.4 Highscore-Liste anzeigen . . . . . . . . . . . . . . . . . . . . . . . 30616.1.5 Vollständiger Quellcode . . . . . . . . . . . . . . . . . . . . . . . . 308

16.2 Sammelspiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31016.2.1 Aufbau des Plugins . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31016.2.2 Plugin starten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31116.2.3 Spieler betritt den Server . . . . . . . . . . . . . . . . . . . . . . 31316.2.4 Gegenstände zählen . . . . . . . . . . . . . . . . . . . . . . . . . . . 31416.2.5 Auftrag anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31516.2.6 Vollständiger Quellcode . . . . . . . . . . . . . . . . . . . . . . . . 316


Kapitel 17 Eigenständige Java-Programme 321

17.1 Grundgerüst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32117.2 Statische Variablen und Funktionen . . . . . . . . . . . . . . . . . . . . 32217.3 Ein- und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

17.3.1 »Hallo Welt!«-Programm . . . . . . . . . . . . . . . . . . . . . . . 32417.3.2 Eingaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

17.4 Quiz programmieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326


10

Inhalt

Anhang A Rätsel-Lösungen 333

Anhang B Befehlsreferenz 341

Anhang C Materialien 359

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373


11

Einleitung

Liebe Leserinnen und Leser,

die Welt von Minecraft steckt voller Dinge, die es zu entdecken gilt. Verschiedene Land-schaften, Hunderte verschiedene Gegenstände und allerlei Tiere und Monster sind nureinige der Dinge, die dich erwarten.

Irgendwann ist aber selbst diese Vielzahl an Möglichkeiten erschöpft und man hat dasGefühl, alles schon einmal gesehen oder gemacht zu haben. Wenn es dir so geht, dannist dieses Buch genau das Richtige für dich. Denn im Verlaufe dieses Buches lernst du,wie man mithilfe von Java und dem Bukkit- oder Spigot-Server eigene Erweiterungen fürMinecraft programmiert, sogenannte Plugins, die du dann zusammen mit deinen Freun-den auf deinem eigenen Minecraft-Server ausprobieren kannst.

Egal ob du neue Crafting-Rezepte entwerfen möchtest, ganze Häuser mit einem einfa-chen Chat-Befehl bauen oder sogar einen eigenen Spielmodus programmieren möch-test, mit eigenen Plugins steckt die Welt von Minecraft wieder voller Herausforderungenund Dingen, die entdeckt werden wollen. Und ganz nebenbei lernst du auch noch zu pro-grammieren – und wer weiß, vielleicht kommt das nächste Minecraft eines Tages von dir!

Bevor es so weit ist, liegt allerdings noch ein ordentliches Stück Weg vor dir. Die erstenbeiden Kapitel dieses Buches beschäftigen sich deshalb zunächst einmal damit, wie dudeinen Computer für das Programmieren und Testen eigener Plugins vorbereitest. Dazuwird dir erklärt, wie du den Bukkit- oder Spigot-Server installierst, der in diesem Buchverwendet wird, ihn nach deinen Wünschen konfigurierst und wie du deinen Computerso einrichtest, dass du Java-Programme schreiben kannst.

Direkt im Anschluss geht es im dritten Kapitel ohne Umschweife direkt los mit dem Pro-grammieren deines ersten eigenen Plugins. Die ersten Schritte werden dir vielleichtnoch etwas unspektakulär vorkommen, aber mit jedem der folgenden Kapitel wirst duimmer mehr Möglichkeiten haben, um immer ausgeklügeltere Plugins zu programmie-ren. Schon im vierten Kapitel wirst du zum Beispiel lernen, wie du eigene Chat-Befehleprogrammieren und verwenden kannst.

In Kapitel 5 lernst du Eclipse kennen, einen Editor, der dich beim Programmierenvon Plugins mit vielen nützlichen Funktionen unterstützen kann. Die Kapitel 6 bis 10beschäftigen sich mit grundlegenden Konzepten des Programmierens im Allgemeinenund der Programmiersprache Java im Besonderen. Was du hier liest, wird dir nicht nurbeim Programmieren von Minecraft-Plugins helfen, sondern beim Programmieren jedesProgramms in jeder Programmiersprache. Trotzdem entstehen dabei natürlich aucheinige praktische kleine Plugins wie zum Beispiel das Mauer-Plugin, das es dir erlaubt,mit einem einfachen Chat-Befehl auf die Schnelle eine Mauer zu bauen – wenn du möch-test, sogar aus purem Gold.


Einleitung

12

Das elfte Kapitel widmet sich dann ganz der Baukunst. Häuser, Schilder, Kreise undKugeln – hier wird kein Block auf dem anderen gelassen. Und wenn du schon einmal ver-sucht hast, eine Kugel in Minecraft von Hand zu bauen, dann wirst du ganz besondersdie Dienste des Kugel-Plugins zu schätzen wissen, das dir auf Knopfdruck eine nahezuperfekte Kugel zaubern kann. Weiter geht es danach mit dem Bau von Schildern, denendas gesamte zwölfte Kapitel gewidmet ist.

Und wenn dir selbst ein Knopfdruck noch zu viel ist, dann wird dir das dreizehnte Kapitelbesonders gefallen. Dort geht es nämlich um Plugins, die vollautomatisch auf Gescheh-nisse in der Spielwelt reagieren. Egal ob ein Creeper über die Karte schleicht, ein Spieleretwas isst oder ein Baum wächst: Hier lernst du, wie deinem Plugin nichts mehr von dementgeht, was auf deinem Server passiert, und natürlich auch, wie du darauf reagierenkannst.

Falls du dich um die umherschleichenden Creeper aber doch lieber ganz manuell küm-mern möchtest, kannst du die Informationen aus Kapitel 14 nutzen, um ganz eigene Waf-fen zu kreieren. In diesem Kapitel geht es nämlich um das Erstellen eigener Crafting-Rezepte und ein Beispiel, das dir dort begegnen wird, ist ein Rezept für ein Flam-menschwert, das alles in Brand setzt, worauf es trifft.

Kapitel 15 ist dann wieder etwas technischer, aber nicht weniger nützlich. Hier lernst dunämlich, wie du Informationen dauerhaft speichern kannst, die auch dann erhalten blei-ben, wenn der Server zwischenzeitlich ausgeschaltet wird. Das ist zum Beispiel prak-tisch, wenn du wie in Kapitel 16 eigene Spielmodi kreieren willst, also sozusagen einSpiel im Spiel. Wie wäre es zum Beispiel mit einem Schneeballschlacht-Mod mit eigenerHighscore-Liste, die die Treffer zählt? Oder lieber ein lustiges Suchspiel, bei dem derGewinner mit Erfahrungspunkten oder wertvollen Gegenständen belohnt wird? Ganzwie du möchtest: Deiner Kreativität sind keine Grenzen gesetzt!

Im letzten Kapitel bekommst du dann noch einen kurzen Ausblick darauf, was du mit dei-nen neu gewonnenen Programmierfähigkeiten noch anstellen kannst, außer Minecraft-Plugins zu programmieren. Denn wenn du am Ende des Buches angelangt bist, hört derSpaß noch lange nicht auf, denn dann hast du alle Werkzeuge und alles Wissen, das dubenötigst, um ganz eigene Plugins, ganz nach deinen Vorstellungen zu entwerfen. Dabeihelfen dir einige Listen im Anhang des Buches, in denen du Befehle und besonders häu-fig benötigte Dinge schnell nachschlagen kannst. Denn egal wie erfahren man als Pro-grammierer ist, alles kann und muss man nicht auswendig können, man muss nur wis-sen, wo man es nachschlagen kann – und genau dazu dient der Anhang dieses Buches.

Für Fragen, Kritik oder Anregungen zum Buch oder generell zu Minecraft-Plugins,kannst du mich gerne jederzeit kontaktieren. Du erreichst mich per Mail an [email protected], über meine Facebook-Seite www.facebook.com/AutorDanielBraunoder über meine Website www.daniel-braun.com.


Einleitung

13

Mein besonderer Dank gilt Karl-Heinz Barzen, der den Entstehungsprozess diesesBuches unermüdlich mit zahlreichen hilfreichen Kommentaren und Anmerkungen be-gleitet und damit einen wichtigen Beitrag dazu geleistet hat, dass dieses Buch mög-lichst verständlich und einsteigerfreundlich wird.

Nun wünsche ich dir aber vor allem viel Spaß beim Lesen, Programmieren und Ent-decken!

Daniel Braun

Downloads zum BuchUnter der Webadresse buch.daniel-braun.com findest du:

• Links zu allen Downloads, die du benötigst

• Alle Plugins, die du im Rahmen des Buches programmieren wirst, falls du denCode nicht aus dem Buch abtippen möchtest


15

Kapitel 1

JavaOb bewusst oder unbewusst, eine der wichtigsten Entscheidungen, die man auf demWeg zum Programmierer zu treffen hat, hast du bereits getroffen: welche Programmier-sprache du lernen möchtest. Mit diesem Buch hast du dich nämlich für die Programmier-sprache Java entschieden. Bevor wir uns aber mit den Besonderheiten von Java beschäf-tigen und damit, warum es eine gute Entscheidung ist, Java zu lernen, soll es zunächstum die Frage gehen, was Programmiersprachen eigentlich sind und warum sie benötigtwerden.

1.1 ProgrammiersprachenBeim Programmieren geht es im Wesentlichen darum, dass der Programmierer demComputer eine bestimmte Aufgabe gibt, die dieser erledigen soll. Damit er das kann,braucht der Computer eine genaue Handlungsvorschrift, die auch Algorithmus genanntwird. Auch im Alltag begegnen uns oft Handlungsvorschriften, zum Beispiel in Formeines Rezepts:

1. 250 Gramm Mehl in eine Schüssel geben

2. 500 Milliliter Milch dazugeben

3. 2 Eier hinzugeben

4. Mit einer Prise Salz würzen

5. Umrühren

Fertig ist der Crêpes-Teig! Damit eine Handlungsvorschrift korrekt ausgeführt werdenkann, müssen sich beide Seiten auf eine gemeinsame Sprache einigen. Wenn dir jemandein Rezept auf Chinesisch gibt, kannst du vermutlich nicht viel damit anfangen.

Computer »sprechen« in Einsen und Nullen, also in einer Sprache, mit der Menschennicht besonders gut umgehen können. Unsere Sprache wiederum, egal ob es sich umDeutsch, Englisch oder Chinesisch handelt, ist für den Computer viel zu ungenau. Neh-men wir zum Beispiel den Satz: »Da vorne ist eine Bank.« Obwohl es sich dabei um einenvollkommen korrekten deutschen Satz handelt, ist doch nicht eindeutig klar, was mitdem Satz eigentlich gemeint ist. Steht da vorne eine Parkbank, auf die man sich setzenkann, oder ist dort die Filiale einer Bank, auf der man Geld einzahlen und abheben kann?


1 Java

16

Es wäre ein recht kostspieliger Fehler, wenn dein Computer beim Online-Shoppen ausVersehen die Deutsche Bank statt einer Bank für den Garten kauft.

Algorithmen müssen deshalb nicht nur Handlungsvorschriften sein, sie müssen eindeu-tige Handlungsvorschriften sein. Auch mit Begriffen wie »eine Prise« kann ein Computerwenig anfangen. Aus diesem Grund nutzen wir Programmiersprachen, denn sie ermög-lichen es uns, eindeutige Handlungsvorschriften festzulegen. Und obwohl sie auf denersten Blick recht kompliziert scheinen, können wir sie doch leichter lernen als eineSprache aus Nullen und Einsen.

Damit der Computer die Programmiersprache auch versteht, muss sie aber zunächstübersetzt werden, in die sogenannte Maschinensprache. Diese Übersetzung findetdurch ein Programm statt, das Compiler genannt wird. Das Ergebnis sind dann soge-nannte Binärdateien, die vom Computer ausgeführt werden können. Diese Binärdateienbestehen, wie in Abbildung 1.1 gezeigt, nur aus Nullen und Einsen.

Abbildung 1.1: Funktionsweise eines Compilers

Compiler

01010100000110001100010010101001110

void main(){

int var1 = 0;int var2 = 3;....

}


1.2 Besonderheiten von Java

17

Der einfache Satz »Das ist ein Test.« wird so zum Beispiel zu einer 136 Zeichen langenKette aus Nullen und Einsen, die du in Listing 1.1 sehen kannst.

1.2 Besonderheiten von JavaVerschiedene Programmiersprachen haben verschiedene Vor- und Nachteile. Einigesind besonders leicht zu erlernen, wie zum Beispiel Python, andere, wie zum Beispiel C,sind besonders für zeitkritische Anwendungen geeignet, also Anwendungen, bei denenes auf schnelle Reaktionszeiten ankommt, und wieder andere sind besonders universelleinsetzbar, wie zum Beispiel Java. Die eine »richtige« oder »beste« Programmiersprachegibt es daher nicht – je nach Anwendungsfall kann der Einsatz einer anderen Program-miersprache sinnvoll sein.

Der Hauptgrund, warum wir Java zum Programmieren unserer Plugins verwenden, ist,dass sowohl Minecraft selbst als auch der Minecraft-Server in Java programmiert sind.Außerdem können Java-Programme, im Gegensatz zu vielen in anderen Programmier-sprachen geschriebenen Programmen, problemlos auf allen gängigen Betriebssyste-men ausgeführt werden, also insbesondere auf Windows, GNU/Linux und macOS.

Damit das möglich ist, funktioniert der Java-Compiler anders als andere Compiler. Erwandelt die Programmiersprache nicht sofort in Maschinencode um, sondern zunächstin den sogenannten Java-Bytecode. Dieser ist ein Zwischenschritt zwischen der fürMenschen gut lesbaren Programmiersprache und dem für den Computer gut lesbarenMaschinencode. Erst die sogenannte Java Virtual Machine (JVM) wandelt das Programmin Maschinencode um.

Der Vorteil: Statt jedes Programm in Maschinencode für jedes Betriebssystem, also zumBeispiel Windows, macOS und GNU/Linux übersetzen zu müssen, muss nur ein Pro-gramm, nämlich die Java Virtual Machine, für jedes Betriebssystem übersetzt werden –und das bedeutet deutlich weniger Aufwand.

01000100 01100001 01110011 00100000 01101001 01110011 01110100 00100000 01100101 01101001 01101110 00100000 01010100 01100101 01110011 01110100 00101110

Listing 1.1: Binärcodierung von »Das ist ein Test.«

Merke• Ein Algorithmus ist eine eindeutige Handlungsvorschrift.

• Der Compiler übersetzt Programmiersprache in Maschinensprache.

• Eine Binärdatei besteht aus Nullen und Einsen.


1 Java

18

Abbildung 1.2: Funktionsweise des Java-Compilers

1.3 Installation und EinrichtungBevor du mit dem eigentlichen Programmieren loslegen kannst, musst du daher dafürsorgen, dass auf deinem Computer sowohl die Java Virtual Machine als auch der Java-Compiler installiert sind. Auf manchen Systemen, insbesondere GNU/Linux-Systemen,

Java Compiler

iload_0iload_1iaddireturniconst_4iconst_2invokestatic [f]

class Test {public static......

}

Java Virtual Machine

01010100000110001100010010101001110


1.3 Installation und Einrichtung

19

sind beide Programme schon vorinstalliert. Um zu testen, ob das bei deinem System derFall ist, musst du zunächst die Eingabeaufforderung (Windows) beziehungsweise dasTerminal (GNU/Linux, macOS) öffnen, denn im Gegensatz zu den meisten modernenProgrammen, wie wir sie heute kennen, hat der Java Compiler keine grafische Ober-fläche, sondern wird komplett über die Eingabeaufforderung bedient. Unter Windowsfindest du die Eingabeaufforderung entweder, indem du den Namen einfach in dasSuchfeld im Startmenü eingibst, oder ebenfalls im Startmenü unter ZUBEHÖR. UntermacOS findest du das Terminal im Ordner /Programme/Dienstprogramme oder indemdu in die Suche Terminal eingibst. In der Eingabeaufforderung beziehungsweise imTerminal gibst du dann den Befehl javac ein und bestätigst die Eingabe mit der(Enter)-Taste. Ist danach eine Ausgabe wie in Abbildung 1.3 zu sehen, ist der Java-Compiler bereits korrekt auf deinem Computer installiert und du kannst direkt weiter zuAbschnitt 1.3.2 springen. Bekommst du dagegen eine Meldung wie Der Befehl"javac" ist entweder falsch geschrieben oder konnte nicht gefunden werden.oder Ähnliches, so muss der Java-Compiler noch auf deinem Computer installiert werden.

Abbildung 1.3: Ausgabe bei korrekt installiertem Java-Compiler


1 Java

20

1.3.1 Java-Compiler installierenDer Java-Compiler ist, wie auch die Java Virtual Machine, Teil des Java DevelopmentKit (JDK) und kann kostenlos auf der Website von Oracle heruntergeladen werden. EinenLink zum Download findest du auf buch.daniel-braun.com.

Auf der Seite von Oracle musst du dann die für dein Betriebssystem passende Datei he-runterladen. Die Dateien sind nach dem Schema benannt jdk-$u$$$-betriebssys-tem-x64, wobei die $-Zeichen der Versionsnummer entsprechen und betriebssystemdem Namen des Betriebssystems, das du verwendest. Nach dem Herunterladen kannstdu die Datei einfach mit einem Doppelklick öffnen und der Installation bis zum Endefolgen.

Sobald diese abgeschlossen ist, solltest du die in Abschnitt 1.3 beschriebenen Schrittewiederholen, um zu testen, ob der Java-Compiler nun korrekt installiert ist. Solltest duWindows verwenden, kann es sein, dass der Befehl noch nicht funktioniert. Das bedeu-tet wahrscheinlich nicht, dass es einen Fehler bei der Installation gegeben hat, sondernlediglich, dass du noch eine sogenannte Umgebungsvariable einstellen musst.

Dazu musst du zunächst die erweiterten Systemeinstellungen deines Computers öff-nen.

Windows XP, Vista und 7: Unter Windows XP, Vista und 7 öffnest du dafür zunächst dasStartmenü und dann die SYSTEMSTEUERUNG. Dort wählst du aus der Kategorie SYSTEM UND

SICHERHEIT den Eintrag SYSTEM aus und im sich danach öffnenden Fenster den EintragERWEITERTE SYSTEMEINSTELLUNGEN.

Windows 8 und 10: Unter Windows 8 kannst du diese öffnen, indem du den Begriff ein-fach direkt in die Suche eingibst. Unter Windows 10 dagegen musst du zunächst mit derrechten Maustaste auf das Windows-Logo in der unteren linken Ecke klicken und dortdann auf SYSTEM und in dem sich öffnenden Fenster wieder auf ERWEITERTE SYSTEMEINSTEL-LUNGEN.

Nun solltest du, unabhängig von deiner verwendeten Windows-Version, das in Abbil-dung 1.4 gezeigte Fenster sehen. Dort findest du in der rechten unteren Ecke einen But-ton mit der Beschriftung UMGEBUNGSVARIABLEN. Bei einem Klick darauf öffnet sich das inAbbildung 1.5 gezeigte Fenster.

Dort wählst du dann, wie in Abbildung 1.5 gezeigt, den Eintrag PATH aus und klickstanschließend auf BEARBEITEN. Sollte der Eintrag nicht vorhanden sein, so kannst dudirekt zum nächsten Absatz springen. Danach öffnet sich ein langes Textfeld, in dem esschon zahlreiche Einträge gibt, die auf keinen Fall geändert werden dürfen. Stattdessensolltest du am Ende, abgetrennt durch ein Semikolon, den Pfad angeben, an dem duzuvor das Java Development Kit installiert hast. Standardmäßig sähe das so aus:

C:\Program Files\Java\jdk1.8.0_121\bin;


1.3 Installation und Einrichtung

21

Abbildung 1.4: Erweiterte Systemeinstellungen

Je nachdem, welche Java-Version du installiert hast, kann der Pfad aber, insbesonderebei der Versionsnummer, leicht abweichen. Daher solltest du unbedingt darauf achten,den tatsächlichen Installationspfad zu nutzen. Danach musst du die Änderungen nurnoch mit OK und ÜBERNEHMEN bestätigen.

Sollte es bei dir noch keinen Eintrag mit dem Namen PATH geben, so kannst du diesenganz einfach selbst anlegen. Dazu klickst du statt auf BEARBEITEN einfach auf NEU. ImFenster, das sich daraufhin öffnet, gibst du als NAME DER VARIABLEN das Wort PATH ein undals WERT DER VARIABLEN den Pfad zur Installation, beendet durch ein Semikolon, undbestätigst deine Eingabe mit OK.

Anschließend sollte der javac-Befehl dann in der Eingabeaufforderung funktionieren.


1 Java

22

Abbildung 1.5: Umgebungsvariablen

1.3.2 Ordner einrichtenIm Verlaufe des Buches wirst du zahlreiche Plugins programmieren, einige davon auchin verschiedenen Versionen. Damit du darüber später leichter den Überblick behaltenkannst, solltest du jetzt schon vorsorgen.

Am besten legst du einen eigenen Ordner an, in dem du später alle Projekte aus demBuch speicherst. Prinzipiell kannst du diesen Ordner natürlich, wie den des Servers, wie-der speichern, wo du möchtest. Es wird dir später aber das Leben erleichtern, wenn duihn im selben Verzeichnis wie den Server-Ordner platzierst, unter Windows also zumBeispiel unter C:\ und unter GNU/Linux und macOS unter /home/Benutzername be-ziehungsweise /Benutzer/Benutzername. Als Namen für den Ordner kannst du zumBeispiel einfach plugins wählen.


1.4 Editor

23

1.4 EditorDamit sind auch fast alle Vorbereitungen abgeschlossen, die nötig sind, bevor es mitdem Programmieren losgehen kann. Was dir jetzt noch fehlt, ist ein Programm zumSchreiben deiner zukünftigen Plugins. Grundsätzlich kannst du dazu nahezu jedes Pro-gramm verwenden, mit dem man Texte verfassen kann. Der mit Windows mitgelieferteEDITOR, den du im Startmenü unter ZUBEHÖR findest, ist zum Beispiel völlig ausreichend.macOS bringt das Programm TEXTEDIT mit, das sich im Ordner Programme befindet oderüber die Suche gefunden werden kann. Solltest du dich für den Windows-Editor ent-scheiden, so musst du beim SPEICHERN darauf achten, dass du als DATEITYP den EintragALLE DATEIEN auswählst. Beim Programm TEXTEDIT sollte nach dem Neuanlegen einesDokuments der Menüpunkt FORMAT|IN REINEN TEXT UMWANDELN ausgewählt werden. Undunabhängig davon, welches Programm du verwendest, solltest du beim Speichern anden Dateinamen die Endung .java anhängen, damit dein Computer weiß, dass es sichbei der gespeicherten Datei um Java-Code handelt.

Abbildung 1.6: Speichern von Dateien mit dem Windows-Editor

Wenn du es gerne etwas komfortabler hättest, kannst du aber auch einen Editor wählen,der speziell dafür entwickelt wurde, Java-Programme zu schreiben. Solche Editoren bie-ten dir in der Regel zahlreiche Komfortfunktionen wie das automatische Einfärben vonQuellcode, automatisches Einrücken oder sogar eine automatische Vervollständigung


1 Java

24

an. Einige Editoren, die besonders viele solcher Zusatzfunktionen mitbringen, nenntman auch integrierte Entwicklungsumgebungen, oder englisch Integrated Develop-ment Environment, kurz IDEs. Zu den bekanntesten Java-IDEs gehören zum BeispielEclipse und NetBeans.

Diese sind mitunter allerdings sehr komplex zu bedienen. Fürs Erste solltest du dahervielleicht einen etwas weniger umfangreichen Editor wählen, da du die meisten Funk-tionen der großen IDEs anfangs ohnehin nicht nutzen wirst. Der Editor jEdit, der kosten-los für alle gängigen Betriebssysteme erhältlich ist, bietet sich dafür zum Beispiel an.Den Link zum Download sowie eine Installationsanleitung findest du ebenfalls unterbuch.daniel-braun.com.

Abbildung 1.7: jEdit

1.5 Zusammenfassung

Begriff Bedeutung

Algorithmus Eine eindeutige Handlungsvorschrift, die festlegt, was genau zum Beispiel ein Programm tun soll.

Compiler Ein Programm, das Programmiersprache in Maschinensprache übersetzt.

Binärdatei Eine Datei, die Maschinensprache enthält, die nur aus Nullen und Einsen besteht.


43

Kapitel 3

Das erste PluginNachdem Java und der Minecraft-Server fertig eingerichtet sind, kann es nun endlichmit dem Programmieren von Minecraft-Plugins losgehen. Da aller Anfang bekanntlichschwer ist, wollen wir mit etwas Einfachem beginnen: einem freundlichen kleinen Plug-in, das dich beim Start des Servers mit den Wörtern »Hallo Welt!« begrüßt.

3.1 ProgrammierenDazu musst du zunächst eine neue Datei mit dem Namen HalloWeltPlugin.java anle-gen. Dafür erstellst du am besten im Plugin-Ordner, den du im letzten Kapitel angelegthast, ein neues Unterverzeichnis mit dem Namen HalloWeltPlugin. Die neu erzeugteDatei füllst du dann mit folgendem Inhalt, den wir uns im Folgenden Schritt für Schrittanschauen werden:

import org.bukkit.plugin.java.JavaPlugin;

public class HalloWeltPlugin extends JavaPlugin { public void onEnable() { this.getLogger().info("Hallo Welt!"); }

public void onDisable() { }}

Listing 3.1: HalloWeltPlugin.java

TippEs ist eine gute Übung, die Programme aus dem Buch abzutippen, da du dir so dieverschiedenen Befehle schneller einprägen kannst. Allerdings musst du darauf ach-ten, dabei sehr exakt vorzugehen, denn schon ein einzelner Tippfehler kann dafürsorgen, dass dein Programm nicht mehr funktioniert. Möchtest du die Programmetrotzdem nicht abtippen, so findest du sie, wie bereits in der Einleitung erwähnt,unter buch.daniel-braun.com zum Download.

12345678910


3 Das erste Plugin

44

Das sind auf den ersten Blick erst einmal ziemlich viele Wörter und Zeichen, die wenigSinn ergeben. Der Text in Listing 3.1 wird Programmcode, Sourcecode oder Quellcodegenannt. Er beinhaltet die Handlungsvorschriften, die der Computer ausführen soll. Indiesem Fall also die Vorschrift: Zeige beim Starten des Servers die Nachricht »HalloWelt!« an. Im Laufe der nächsten Kapitel wirst du alle Befehle genau kennen- und ver-stehen lernen. Für den Anfang soll aber zunächst einmal ein grober Überblick reichen.

Die erste Zeile des Plugins beginnt mit dem Wort import und endet mit dem Zeichen ;,dem Semikolon. Mit dem Befehl import kannst du dem Compiler sagen, welche spe-ziellen Bestandteile und Funktionen du für die Programmierung eines Plugins benötigst.Um ein Spigot- oder Bukkit-Plugin zu programmieren, musst du daher zum Beispielimmer org.bukkit.plugin.java.JavaPlugin importieren. Das Semikolon am Endeder Zeile markiert das Ende eines Befehls, deshalb steht es am Ende vieler, wenn auchnicht aller Zeilen.

In der dritten Zeile wird der Name des Plugins festgelegt, das du gerade erstellst, in die-sem Fall also »HalloWeltPlugin«. Generell ist dir die Namenswahl freigestellt, ein paarRegeln musst du allerdings beachten: Der Name darf keine Leerzeichen, Sonderzeichenwie ?, !, % und Ähnliches oder Umlaute, also ä, ö und ü, enthalten. Außerdem muss der

MerkeSicher ist dir auch schon aufgefallen, dass der Quellcode eine bestimmte Formatie-rung besitzt. Die verschiedenen Zeilen sind unterschiedlich weit eingerückt und anmanchen Stellen findest du Leerzeilen. Diese spezielle Formatierung ist eine Konven-tion, also eine Vereinbarung, auf die sich Programmierer über die Jahre geeinigthaben. Nicht alle Konventionen sind ganz eindeutig und sie sind auch nicht verbind-lich, ihr Ziel ist es aber, Programmcode besser lesbar zu machen, gerade auch für Pro-grammierer, die ihn nicht selbst geschrieben haben.

Der Programmcode in Listing 3.2 ist für den Computer bei der Ausführung identischmit dem Programmcode aus Listing 3.1. Für Menschen ist er aber deutlich schwerer zulesen und sollte der Compiler einen Fehler finden und melden, wird es deutlichschwieriger, diesen zu finden, da die Zeilenangabe wenig hilfreich ist, wenn alleBefehle in einer Zeile stehen. Aus diesem Grund solltest du versuchen, auch wenn esnicht zwingend notwendig ist, dich an die Konventionen zur Formatierung zu halten,die dir im Laufe dieses Buches begegnen werden. Sie werden deine Arbeit deutlichvereinfachen.

import org.bukkit.plugin.java.JavaPlugin; public class HalloWeltPlugin extends JavaPlugin { public void onEnable() { this.getLogger().info("Hallo Welt!"); } public void onDisable() { } }

Listing 3.2: HalloWeltPlugin.java ohne Formatierung


3.1 Programmieren

45

gewählte Name auch immer dem Dateinamen entsprechen. Möchtest du das Plugin alsozum Beispiel umbenennen in »HalloPlugin«, musst du darauf achten, dass sowohl in derDatei der Name geändert wird als auch beim Abspeichern der Dateiname. Auf denNamen folgen noch die Wörter extends JavaPlugin, was dem Compiler signalisiert,dass dieses Programm ein Spigot- oder Bukkit-Plugin ist. Was genau die Wörter publicund class an dieser Stelle bedeuten, damit werden wir uns im späteren Verlauf desBuches noch beschäftigen.

Vermutlich sind dir bereits die geschweiften Klammern, also { und }, aufgefallen, dieman in normalen Texten doch eher selten findet. In Java und vielen anderen Program-miersprachen markieren geschweifte Klammern Teile von Programmen, die in irgend-einer Form zusammenhängen. Das »HalloWeltPlugin« besteht aus drei solchen zusam-menhängenden Blöcken.

Der erste Block beginnt in der dritten Zeile des Plugins und endet erst mit der letzten. Beidiesem Block handelt es sich um eine sogenannte Klasse. Was Klassen sind und wofürman sie verwendet, werden wir in Kapitel 10 genauer unter die Lupe nehmen. Innerhalbdieses Blocks befinden sich zwei weitere kleinere Blöcke. Diese werden auch Funktio-nen genannt.

Die erste Funktion trägt den Namen onEnable und beginnt in Zeile 4, die zweite Funk-tion heißt onDisable und beginnt in Zeile 8. Jedes Plugin besitzt diese beiden Funktio-nen. Die erste, onEnable, wird immer dann aufgerufen, wenn der Server – und damitauch die Plugins – gestartet werden. Die onDisable-Funktion wird dagegen aufgerufen,wenn der Server – und somit auch die Plugins – gestoppt werden. Diese beiden Funk-tionen werden dir im Laufe des Buches noch sehr häufig begegnen, da jedes Plugin überdiese beiden Funktionen verfügt. Was genau die Ausdrücke public und void vor denFunktionen bedeuten, braucht uns an dieser Stelle noch nicht zu interessieren, auchdazu werden wir aber noch kommen.

Da es das Ziel des Plugins ist, den Nutzer beim Starten des Servers zu begrüßen, gehörtder entsprechende Befehl logischerweise in die onEnable-Funktion, während dieonDisable-Funktion, wie in Zeile 8 und 9 zu sehen ist, bei diesem Plugin leer bleibt. Dieeigentliche Handlungsanweisung, also der Befehl, der dem Plugin konkret sagt, zeige»Hallo Welt!« an, befindet sich in Zeile 5, nämlich this.getLogger().info("HalloWelt!").

TippVergessene Klammern sind ein häufig auftretender Fehler und können dazu führen,dass dein Plugin nicht funktioniert. Achte darauf, dass jede geöffnete Klammer auchwieder geschlossen werden muss. Die Anzahl der öffnenden Klammern muss alsoimmer gleich der Anzahl der schließenden Klammern sein.


373

IndexSymbole^ 116! 116!= 108@Override 172*/ 109*= 89/* 109// 109/= 89&& 114%= 89++ 89+= 89< 108<= 108-= 89== 108> 108>= 108|| 115

AAbrunden 86abstract 170, 171abstrakte Klasse 170abstrakte Methode 170Abstraktion 150add 217addUnsafeEnchantment 266Algorithmus 15Alias 186Angel 262Array 93, 344ArrayList 217Attribut 151Aufrunden 86Ausrichtung 211

BBefehl 36Bett 191Bezeichner 74Binärdatei 16Binnenmajuskel siehe CamelCaseBlock 350

Status 187BlockFace 187Bogen 269BOLD 216Boolean 113break 136, 224Bukkit siehe CraftBukkitbukkit.yml 33byte 75Bytecode 17

CCamelCase 74case 135case-Verzweigung 134cd 26Chat 55, 355Chat-Befehl 55Chat-Kommando siehe Chat-BefehlCheat siehe Befehlclass 151clear 219Client 25commands 56Compiler 16config.yml 276contains 219, 301CraftBukkit 25Crafting 261, 353


374

Index

DDaten-Ordner 279Deklaration 74Differenz 77Division 77

Rest 77double 76do-while-Schleife 117

EEclipse 63

Workspace 64else 130Enderbogen 269Enderperle 269Endlosschleife 109Entweder-Oder-Operator 116equals 136Ereignis siehe EventEVA-Prinzip 73Event 240

PlayerJoinEvent 240Priorität 242setCancelled 268

exists 290

FFackel 195

Data 196faires Runden 86Fallunterscheidung 134Feld siehe Arrayfirst 301Fließkommazahl 75float 76Formatierung 215, 216for-Schleife 108Funktion 139, 347

Signatur 170überschreiben 172

Fußgesteuert 117

GGegenstand 351

Geschweifte Klammer 45get 219getDataFolder 279getShooter 271getState 187getTargetBlock 223getter-Methode 164getUUID 236getYaw 225Gleitkommazahl siehe Fließkommazahl

HHandlungsvorschrift siehe AlgorithmusHashMap 303

IIDE siehe Integrierte Entwicklungsumge-

bungif-Verzweigung 127Implementierung 172implements 172import 44indexOf 219Info-Datei 49Initialisierung 93instanceof 128Instanzen 150int siehe IntegerInteger 75Integrierte Entwicklungsumgebung 24, 63Interface 172Inventar 301, 351

Slot 301IP-Adresse 39ITALIC 216ItemStack 261

JJar-Datei 49Java 17Java Development Kit 20Java Virtual Machine 17Java-Archive 49Java-Bytecode 17


375

Index

javac 19JDK siehe Java Development KitJVM siehe Java Virtual Machine

KKaufmännisches Runden 86Klasse 150, 346

abstrakt 170Kommentar 109Konfigurationsdatei 275, 356Konkatenationsoperator 78Konstante 95Konstruktor 151Konvertierung 83Koordinate 103Kopfgesteuert 117Kreis 200Kugel 204

LLaufbedingung 108length 222LinkedList 217Liste 217, 344

abrufen 219ändern 219ArrayList 217Länge 218lesen 219LinkedList 217Löschen 218Position 219

Listener 239, 356Location siehe PositionLog-Datei 31logischer Operator 348Lokale Variable 157long 75

MMap

TreeMap 306Maschinensprache 16Math.pow siehe PotenzMeta-Daten 265

Methode 160abstrakt 170überschreiben 172

Methode von Horn 200Methode von Metzger 200Midpoint-Algorithmus 200mkdirs 290Mod 25Modulo siehe Restwert

NnextInt 312Nicht-Operator 116Notunterkunft 181

OOberklasse 166Objekt 150, 346Objektorientierte Programmierung 149Oder-Operator 115onDisable 290OOP siehe Objektorientierte Programmie-

rung

PParameter 57, 141plugin.yml 49PluginManager 240Position 102, 349Potenz 207private 163Produkt 77Programmcode siehe QuellcodeProgrammiersprache 15

C 17Java 17Python 17

ProjectileHitEvent 270protected 174public 163

QQuellcode 44Quotient 77


376

Index

RRadius 200Rasterung 200Rechnen 353remove 218Restwert 77return 141Rezept 261, 353

ShapedRecipe 262ShapelessRecipe 261

Rückgabewert 140Runden

abrunden 86aufrunden 86faires 86kaufmännisch 86

runden 85

SsaveResource 279Schild 209

Ausrichtung 211hängend 209stehend 210Text 212

Schleife 107, 341do-while 117endlose 109for 108fußgesteuert 117Kopf 108kopfgesteuert 117Rumpf 109Variable 108while 112

Schleifenkopf 108Schleifenrumpf 109Schleifenvariable 108Schneeballschlacht 299Schnittstelle siehe InterfaceSchriftfarbe 213Semikolon 44Serialisierung 286Serializable 286

Server 25server.properties 31set 219setAmount 301setCancelled 268setDisplayName 265setHinge 189setLine 213setOpen 187setter-Methode 164setTopHalf 188setTypeIdAndData 195shape 262short 75Signatur 170size 218Slot 301Sourcecode siehe QuellcodeSpeichern 275Spieler 348Spigot 25spigot.yml 35Startwert 108STRIKETHROUGH 216String 77Summe 77super 167switch 135switch-case-Verzweigung siehe case-Ver-

zweigungSyntax 108

Tteleport 272Textformatierung 215TreeMap 306Tür 187

UÜberschreiben 172Umgebungsvariable 20UML-Diagramm 168UNDERLINED 216Und-Operator 114


377

Index

Unterklasse 167usage 56UUID 236

VVanilla-Server 25Variable 73, 342

Deklaration 74Initialisierung 93lokal 157Name 74Typ 75Wertzuweisungen 76

Vererbung 166Vergleichsoperator 108Verzauberung 266Verzweigung 127, 342

case 134else 130if 127

void 140

WWahrheitstafel 114Wahrheitswert 113Welt 350Wertebereich 75Wertzuweisungen 76while-Schleife 112writeObject 290

XXOR-Operator 116

ZZeichenkette siehe StringZufallsgenerator 312


Let’s Play. Programmieren lernen mit Java und Minecraft · 11 Einleitung Liebe Leserinnen und...

Documents

Transcript of Let’s Play. Programmieren lernen mit Java und Minecraft · 11 Einleitung Liebe Leserinnen und...