20 Umstieg auf Java

Nachdem Sie schon spektakuläre Spiele und atemberaubende 3D-Grafiken auf Processing programmiert haben, gehen wir in diesem Kapitel in eine ganz neue Richtung: Wir steigen auf Java um und begnügen uns fürs erste auf etwas trockenere Programmierbeispiele. Außerdem lernen wir eine Entwicklungsumgebung (engl. IDE) für "Erwachsene" kennen, NetBeans, die uns das Leben mittelfristig leichter macht.

Warum muss das sein - warum steigen wir auf Java um? Einige Argumente:

Java ist eine der zwei Top-Programmiersprachen (gemäß TIOBE Programming Community Index, Mai 2014) Geschlagen wird Java dabei nur von der alterwürdigen Sprache C (wohlgemerkt nicht von dem modernerem C++). C wird überall dort eingesetzt, wo Geschwindigkeit und Speicherknappheit angesagt sind, z.B. in der Robotik oder in der Hochleistungs-Computergrafik. Java wird stark im Netz-Bereich, bei der Server-Programmierung und generell im akademischen Bereich eingesetzt.

Java ist die Programmiersprache der Android-Plattform Android ist 2013 auf 79% Marktanteil im mobilen Bereich, also bei Smartphones und Tablets, geklettert. Die Programmiersprache für diese Geräte ist Java.

Processing ist eben nur fast Java Processing verwendet eine Bibliothek von Zusatzfunktionen und einen mittelgroßen "Zaubertrick", um Ihnen das Leben zu erleichtern. Der Zaubertrick besteht darin, dass alle Ihre Programme in Wirklichkeit eine Unterklasse der Klasse PApplet sind. Wenn Sie in Java programmieren, stehen Ihnen einerseits einige Funktionen nicht mehr zur Verfügung und andererseits müssen Sie Dinge lernen wie "Wie starte ich mein Java-Programm?".

Wir beginnen mit dem Umstieg auf die Entwicklungsumgebung NetBeans und schreiben dann ein Soziales Netzwerk, um pures Java kennen zu lernen.

20.1 Die Entwicklungsumgebung NetBeans

Eine "Integrierte Entwicklungsumgebung" (Integrated Development Environment, IDE) fasst verschiedene Dienste in ein einziges Programm mit einer schicken Oberfläche zusammen. Einige dieser Dienste sind:

• Code schreiben: einen Editor zur Verfügung stellen, Vervollständigungsvorschläge während des Tippens liefern (code completion), schnell durch den Code navigieren
• Code compilieren und starten: Code wird übersetzt, Programm wird gestartet, Konsolen-Ausgabe wird angezeigt, Programm kann jederzeit unterbrochen werden
• Code debuggen: den Code Zeile für Zeile durchlaufen und dabei den aktuellen Zustand von Variablen einsehen
• Code-Refactoring: Klassen, Methoden und Variablen umbenennen, wobei alle Vorkommen des fraglichen Konstrukts durch den neuen Namen ersetzt werden

NetBeans ist eine der IDEs mit der weitesten Verbreitung. Das liegt u.a. daran, dass es von der gleichen Institution entwickelt wird wie Java selbst, nämlich Oracle bzw. früher die Firma Sun.

Es gibt natürlich andere IDEs, zum Beispiel Eclipse. Eclipse ist ähnlich verbreitet wie NetBeans und hat mehr den "independent"-Charakter und ist bekannt für seine unzähligen Plugins. NetBeans und Eclipse sind beide kostenlos. Eine weitere IDE ist IntelliJ IDEA, die kommerziell ist (allerdings gibt es eine kostenlose Community-Edition, die für die meisten Zwecke ausreicht). IntelliJ hat den Ruf, besonders innovativ in der Gestaltung des Interfaces zu sein. Dass IntelliJ eine ernst zu nehmender Player ist, zeigt die Tatsache, dass Google 2013 eine neue Android-IDE angekündigt hat, Android Studio, die auf IntelliJ basiert.

Wir verwenden Netbeans, weil es derzeit einige wichtige Neuerungen bei Java gibt, zum Beispiel JavaFX, und diese Neuerungen wahrscheinlich bei NetBeans am schnellsten durch Tools unterstützt werden.

Installation: Java, API, NetBeans

Sie benötigen außerdem unbedingt Java in Version 8, genauer gesagt das Java SDK 8 (nicht JRE). Wenn dies bei Ihrem Rechner nicht bereits installiert ist, gehen Sie zur Java-Downloads-Seite und laden und installieren das JDK.

Außerdem empfehle ich Ihnen, die API-Dokumentation der Java-Klassen runterzuladen und in Ihrem Browser zu bookmarken. Dazu müssen Sie auf der Java-Downloads-Seite bei "Java SE 8 Documentation" (relativ weit unten) auf den Download-Button klicken. Auf der folgenden Seite sehen zwei Downloads für Java und JavaFX. Laden Sie ruhig beides runter. Um die APIs zu öffnen, klicken Sie auf die index.html Datei.

Noch ein technischer Hinweis: Verwenden Sie im Code niemals Umlaute (ä, ü, ö) oder das scharfe s (ß). Natürlich dürfen Sie Umlaute in Strings verwenden, aber nicht für Klassen-, Paket, Methoden- oder Variablennamen. Umlaute verursachen leider immer wieder Probleme.

Dann installieren Sie NetBeans. Die aktuelle Version von NetBeans ist 8.0.2 (Stand: 18.06.2015). Laden Sie sich unter https://netbeans.org/downloads/ das einfachste Paket runter:

Dann installieren Sie die Software und starten NetBeans.

Projekt anlegen

Was in Processing ein "Sketch" (Skizze) ist, ist in NetBeans ein Projekt. Ein Projekt wird genauso wie ein Sketch in einem eigenen Verzeichnis gespeichert. Wählen Sie im Hauptmenü File > New Project... und es erscheint ein Dialogfenster, das Sie durch den Prozess führt:

Im ersten Fenster wählen Sie "Java" (links) und "Java Application" (rechts) und klicken dann "Next".

Im zweiten Fenster wählen Sie den Speicherort aus. Richten Sie ein Basisverzeichnis für alle Ihre Programme ein (Project Location). Ihr neues Projekt legt dann ein neues Verzeichnis speziell für Ihr Projekt an (Project Folder), das genau so heißt wie Ihr Projekt (Project Name), z.B. "FirstTimeJava".

Jetzt öffnet sich die Netbeans-Oberfläche für Ihr Projekt. Für Sie interessant sind zwei Teilfenster für den Code (rechts) und für die Projekt-Struktur (links oben).

Im Projektfenster sehen Sie ein Unterverzeichnis "Source Packages". Dort kommen alle Ihre Klassen hinein. Das sehen wir uns im nächsten Abschnitt genauer an.

Zunächst erstellen wir unsere erste Klasse:

NetBeans fragt Sie in einem Dialog nach dem Namen der Klasse:

Jetzt erscheint im Projektfenster Ihre Klasse unter Source Packages und <default package>. Im Code-Editor erscheint das Grundgerüst einer Klasse (Ihr Kommentar sieht etwas anders aus, das ignorieren wir erstmal).

Einstiegspunkt mit main

Ein wichtiger Unterschied zwischen Java und Processing ist: In Java besteht ein Programm nur aus Klassen, es gibt kein "Hauptprogramm" und kein setup() oder draw(). Wenn es kein Hauptprogramm gibt, stellt sich die Frage: Welcher Code wird ausgeführt, wenn wir unser Programm starten? Wo ist also der Einstiegspunkt, ab wo die Programmzeilen abgearbeitet werden?

Die Antwort lautet: Sie legen in einer Ihrer Klassen eine spezielle Methode an, die Java als Einstiegspunkt verwendet. Diese Methode heißt die statische main()-Methode. Sie muss zwingend den Rückgabetyp void haben und als Parameter einen String-Array. Nehmen wir an, Sie definieren diese Methode in der Klasse MyClass. Dann können Sie Java anweisen, "die Klasse MyClass zu starten". Java sucht in der Klasse nach der main()-Methode und, sofern diese vorhanden ist, wird diese ausgeführt.

Was bedeutet "statisch"? Statisch bedeutet in Java, dass eine Methode ausgeführt werden kann, obwohl kein Objekt der Klasse existiert. Normalerweise kann eine Methode nur auf einem Objekt ausgeführt werden. Stellen Sie sich eine Klasse "Person" mit der Methode "getFullName()" vor. Die Methode kann nur auf konkreten Objekten ausgeführt werden, nicht auf der Klasse. Die main()-Methode hingegen gehört zu keinem Objekt, sondern zur Klasse. Man nennt statische Methoden auch Klassenmethoden.

System.out.println

Wir wollen einfach einen String ausgeben, wenn wir MyClass starten. In Java gibt es leider kein einfaches "println" wie in Processing. Stattdessen schreiben Sie:

System.out.println("hello");

Die Bedeutung dieses Ausdrucks ist wie folgt: System ist eine Klasse, die Java von Haus aus zur Verfügung stellt. Das out ist eine Variable der Klasse System, allerdings eine statische Variable (siehe oben), weshalb man sie auch auf der Klasse aufrufen kann. Die Variable out enthält ein Objekt vom Typ PrintStream . PrintStream stellt die Befehle print und println zur Verfügung, wie Sie in der Java API nachlesen können.

Um Ihnen Schreibarbeit zu sparen, gibt es in modernen IDEs sogenannte code templates (eine Liste finden Sie hier). Sie tippen eine "Abkürzung" ein, z.B. "sout" für "System.out.println"...

...Und drücken dann die Tabulator-Taste. NetBeans ersetzt die Abkürzung durch ein Code-Template:

Jetzt schreiben wir den Text:

Programm starten

Und starten das Programm mit dem grünen Play-Button in der Toolbar.

Jetzt könnte es sein, dass Sie nicht nur eine, sondern viele Klassen geschrieben haben. Daher muss NetBeans erst fragen, welche Klasse Sie eigentlich starten wollen. Die Klasse, die Sie hier auswählen, wird auch zukünftig immer zum Starten den Projekts verwendet.

Der Druck auf den Play-Button löst sowohl das Compilieren des Codes (Übersetzung in Maschinensprache, genauer: Bytecode) als auch das Starten des Codes (genauer: der main-Methode in MyClass) aus.

Im rechten unteren Teil erscheint jetzt auch die Konsole, die Sie auch aus Processing kennen.

Sie haben Ihr erstes Java-Programm geschrieben!

20.2 Erste Schritte in Java

Wir nähern uns Java an, indem wir ein zweites Programm schreiben. Dazu legen wir ein Projekt "SecondTimeJava" an.

Pakete

Java bietet "packages" (Pakete) an, um Ihre Klassen besser zu organisieren. Pakete können wie Verzeichnisse verschachtelt werden. Es wird empfohlen, gleich zu Beginn ein Paket einzurichten. Wir nennen unseres "fancyproject". Beachten Sie, dass Paketnamen komplett in Kleinbuchstaben geschrieben werden.

Das neue Paket wird innerhalb von "Source Packages" gezeigt. Wenn Sie eine neue Klasse erstellen, markieren Sie das Paket und dann Rechtsklick:

Wir erstellen die Klasse Toy (Spielzeug). Sie sehen ganz oben im Code die Zeile

package fancyproject;

Damit wird angezeigt, dass die Klasse im Paket "fancyproject" liegt:

Wenn Sie ein Unterpaket "foo" in "fancyproject" hätten und die Klasse dort läge, müssten Sie schreiben:

package fancyproject.foo;

Unterpakete werden also mit Punkten abgetrennt.

Zugriffsmodifikatoren

Wir legen drei Instanzvariablen an:

public class Toy {

private String bezeichnung;
private int seriennummer;
private double preis;
}

Ihnen werden die Begriffe public und private auffallen. Dies sind Zugriffsmodifikatoren (auch: Sichtbarkeitsmodifikatoren). Diese Begriffe geben an, wer auf diese Klasse bzw. die Variablen zugreifen kann.

Der Begriff public bedeutet: Jeder kann auf die Klasse/Variable zugreifen, insbesondere können andere Objekte darauf zugreifen. private heißt bei Variablen, dass nur ein Objekt dieser Klasse darauf zugreifen kann.

Es gibt noch einen weiteren Modifikator protected. Mit diesem Modifikator dürfen auch die Unterklassen auf die Variable zugreifen (und auch alle Klassen innerhalb des gleichen Pakets).

Die folgende Tabelle fasst zusammen, wer Zugriff auf eine(n) Klasse, Konstruktor, Methode oder Instanzvariable hat:

Sie sehen hier auch, was passiert, wenn Sie den Modifikator ganz weglassen ("leer"). Diesen Fall nennt man package-private. Hier haben die Unterklassen keinen Zugriff, dafür aber alle Klassen im selben Paket. Diese Kombination ist selten sinnvoll, daher sollten Sie immer einen Modifikator hinschreiben.

Jetzt wollen wir einen Konstruktor erstellen. NetBeans bietet Ihnen hier eine Automatik an, die man mit Source > Insert Code... oder mit einer dort angegebenen Tastenkombination auslöst. Wählen Sie dann "Constructor...":

NetBeans fragt Sie, welche der drei Instanzvariablen Sie als Parameter im Konstruktor haben möchten. Markieren Sie alle drei.

NetBeans produziert einen lehrbuch-mäßigen Konstruktor:

Getter- und Setter-Methoden

In Java spielt die Sichtbarkeit einer Variablen eine große Rolle. Die Faustregel für Instanzvariablen lautet: Im Zweifelsfall jede Instanzvariable als "private" deklarieren.

Private Variablen dürfen selbst von Unterklassen nicht angefasst werden. Wie manipuliert man dann die Variablen von außen? Zum Beispiel diese hier:

private String bezeichnung;

Ganz einfach: man definiert Methoden, um die Variablen zu manipulieren. Um den Wert zu erhalten, definiert man eine Getter-Methode, die natürlich "public" ist und somit von überall her aufrufbar.

public String getBezeichnung() {
return bezeichnung;
}

Um den Wert zu verändern, definiert man eine Setter-Methode, die den neuen Wert als Parameter bekommt:

public void setBezeichung(String b) {
bezeichnung = b;
}

NetBeans nimmt uns das lästige Schreiben der immergleichen Getter- und Setter-Methoden ab. Wieder lösen wir das Insert Code... Menü aus. Diesmal nehmen wir "Getter and Setter..."

Im nächsten Schritt sagen Sie, welche Instanzvariablen genau Sie per Getter und Setter zugänglich machen wollen:

Schließlich sehen Sie den generierten Code, den Sie natürlich frei bearbeiten oder löschen können.

Verzeichnisstruktur

Wenn Sie in das Verzeichnis gehen, in dem Ihr Projekt gespeichert ist, sehen Sie folgendes (nachdem Sie Ihr Programm mindestens einmal gestartet haben):

Das wichtigste Verzeichnis ist src, Kurzform für "source code" also Quellcode, das sind Ihre Klassendateien, die alle die Extension .java haben. Für jedes Paket, das Sie angelegt haben, gibt es ein Unterverzeichnis, d.h. Sie haben ein Unterverzeichnis "fancyprojects", in dem die Dateien "Toy.java" und "ToyAlbum.java" liegen.

Im Verzeichnis build werden die in Bytecode übersetzten Datein gespeichert Es gibt eine Verzeichnisstruktur, die analog zum Quellcode ist, nur dass jede Klassendatei mit .class endet.

In dist (für "distribution" = Vertrieb) wird eine .jar Datei abgelegt, die genauso heißt wie Ihr Projekt, zum Beispiel "SecondTimeJava.jar". In dieser Datei sind alle zum Start Ihres Programms notwendigen Dateien (.class Dateien) in ZIP-komprimierter Form. Sie können diese .jar-Datei weitergeben und der Empfänger kann diese starten, indem er eine Command Shell (aka Terminal) öffnet, ins dist-Verzeichnis geht und schreibt:

java -jar SecondTimeJava.jar

Das .jar-File lässt sich i.d.R. auch durch Doppelclick starten, aber das macht nur Sinn, wenn Sie z.B. eine GUI programmiert haben, da Konsolen-Output bei dieser Art des Startens nicht angezeigt wird.

Das Verzeichnis nbproject enthält Einstellungsinfos zu Ihrem Projekt (nb = NetBeans). Die Dateien build.xml und manifest.mf ebenso.

Kommentare und Javadoc

In Java können Kommentare so verwendet werden, dass eine umfassende Code-Dokumentation in Form von Webseiten daraus generiert werden kann. So ist zum Beispiel die Dokumentation der Java-Standardbibliothek genau so entstanden.

Das Tool, das die Kommentare in eine HTML-Dokumentation umwandelt, heißt Javadoc. Es werden nicht alle Kommentare für diese Dokumentation verwendet, sondern nur solche, die direkt von einer Klasse, Instanzvariable, Konstruktor oder Methode stehen und die so aussehen:

/**
* Dies ist meine erste Klasse.
*
* @author Michael
*/
public class MyClass {
...
}

Ausschlaggebend ist das doppelte Sternchen zu Beginn. Das signalisiert Javadoc, dass der Kommentar in die Dokumentation soll. Der Spezialschlüssel "@author" erlaubt es, den Autoren der Klasse einzufügen. Solche Informationen werden an bestimmte Stellen in der HTML-Doku platziert.

Bei einer Methode sieht das so aus:

/**
* Berechnet Summe.
*
* @param a erster Summand
* @param b zweiter Summand
* @return Summe von a und b
*/
public int computeSum(int a, int b) {
return a + b;
}

Die Schlüsselwörter "@param" und "@return" sind Erweiterungen des Kommentars, die es Javadoc erlauben, eine differenziertere Dokumentation zu erstellen. Sie können Javadoc auf Ihrem eigenen Projekt ausführen mit Run > Generate Javadoc

Javadoc erzeugt mehrere HTML-Dateien, die anschließend von NetBeans geöffnet werden. Die Dateien sind im Unterverzeichnis dist/javadoc zu finden.

Klassen importieren

Nehmen wir an, wir wollen eine Liste von Toy-Objekten speichern. Obwohl die Klasse ArrayList zur Java-Standardbibliothek gehört, kann sie nicht einfach verwendet werden, sondem muss importiert werden. Dies erfolgt durch den Befehl import, der noch oberhalb der Klasse stehen muss. Glücklicherweise unterstützt uns NetBeans dabei.

Sie tippen Ihren Code und sehen die Fehlermeldung (rote Unterstreichung erscheint, dann Maus über die Glühbirne am linken Rand halten).

Drücken Sie STRG-ENTER, um das folgende Kontext-Menü zu erhalten, und wählen Sie Fix Imports. (Alternativ im Hauptmenü unter Source > Fix Imports...)

Sie sehen jetzt oberhalb der Klasse das "import java.util.ArrayList". Dies ist der vollständige Klassenname. Man sieht, dass die Klasse in einem Paket namens "java" und dort im Unterpaket "util" verortet ist. Pakete und Unterpakete werden mit Punkten getrennt.

Ein weiteres nützliches Feature ist code completion. Wenn Sie einen Befehl, einen Klassen- oder Variablennamen eintippen, können Sie jederzeit STRG-LEERTASTE drücken und NetBeans macht Ihnen Vorschläge zur Vervollständigung.

Wir schreiben eine Klasse, um Toy-Objekte zu verwalten, inklusive dem Hinzufügen von Toy-Objekten und dem Ausdrucken aller Objekte.

package fancyproject;

import java.util.ArrayList;

/**
* @author Michael Kipp
*/
public class ToyAlbum {
private ArrayList<Toy> toys;

public ToyAlbum() {
toys = new ArrayList<Toy>();
}

public void addToy(Toy toy) {
toys.add(toy);
}

public void printToys() {
for (Toy toy: toys) {
System.out.println(toy);
}
}
}

Schließlich schreiben wir eine statische main-Methode. Nutzen Sie hier das nützliche Code-Template psvm für "public static void main(String[] args)":

public static void main(String[] args) {
ToyAlbum album = new ToyAlbum();
album.addToy(new Toy("Lonny", 25001, 29.95));
album.addToy(new Toy("Donny", 25002, 31.95));
album.addToy(new Toy("Bonny", 25003, 79.95));
album.printToys();
}

In der main-Methode erzeugen wir ein ToyAlbum-Objekt und fügen einige Testobjekte hinzu. Anschließend drucken wir alle Objekte aus. Drücken Sie auf den Run-Button von NetBeans.

Wir sehen die Objektausgaben. Um das ganze informativer zu gestalten, fügen wir in der Klasse Toy eine toString-Methode hinzu.

public String toString() {
return bezeichnung + ", " + seriennummer + ", " +
preis + " EUR";
}

Jetzt haben wir eine aussagekräftige Ausgabe:

Refactoring

Ein "Killer-Feature" von IDEs wie NetBeans ist die Möglichkeit, die Namen von Klassen, Variablen und Methoden über Ihr gesamtes Projekt hinweg umzubenennen, ohne dass Sie jede Stelle suchen müssen, wo dieser Name auftaucht. Eine solche Aktion läuft unter dem Begriff Refactoring (wobei Refactoring allgemein bedeutet, den Code so umzubauen, dass er robuster und leichter lesbar wird).

Nehmen wir an, Sie möchten die Klasse "Toy" in "Spielzeug" umbenennen. Der Begriff Toy taucht an vielen Stellen auf, z.B. bei "ArrayList<Toy>". Mit Rechtklick auf den Klassennamen (egal, wo er auftaucht), bekommen Sie ein Kontextmenü, in dem Sie Refactor > Rename wählen (Sehen Sie sich auch den Tastaturkürzel an, variiert nach Betriebssystem):

In einfachen Fällen editieren Sie direkt im Code, in komplexeren Fällen, wie bereits hier bei Toy, erscheint ein Dialog, der nach dem neuen Namen fragt.

Nach einem Druck auf Refactor, werden alle Vorkommen des Namens ersetzt.

NameGenerator gen = new NameGenerator();

gen.addVorname("Harry");
gen.addVorname("Sally");
gen.addVorname("Brad");
gen.addVorname("Angie");
gen.addVorname("Barack");

gen.addNachname("Miller");
gen.addNachname("Merkel");
gen.addNachname("Obama");
gen.addNachname("Putin");
gen.addNachname("Sanders");

for (int i = 0; i < 5; i++) {
System.out.println(gen.createName());
}

Kundenkonto konto = new Kundenkonto();

konto.neueReise("München", 50);
konto.neueReise("Berlin", 150);
konto.neueReise("London", 350);
konto.neueReiseMitHotel("Stuttgart", 80, "B&B", 60);
konto.neueReiseMitHotel("Berlin", 150, "Motel One", 70);

System.out.println("Hotelkosten: " + konto.berechneKostenHotels());
System.out.println("Gesamtkosten: " + konto.berechneKostenGesamt());

Hotelkosten: 130.0
Gesamtkosten: 810.0

20.3 Java durchleuchtet

Hier finden Sie zwei Videos, die beleuchten, was der Unterschied zwischen Ihrem Quellcode und dem ausführbaren Programm ist. Sie sehen ferner, wie Sie auf einer "Command Shell" (auch Konsole genannt) Ihren Code compilieren und ausführen können.

20.4 Literatur

• Schauen Sie in mein Java-Notbuch, wo die wichtigsten Konzepte übersichtlich in einem PDF dargestellt sind
• Eines der meist genutzten Bücher zu Java ist nicht nur online verfügbar, sondern auch kostenlos: Java ist auch eine Insel von Christian Ullenboom
• Die ultimative Quelle für weiterführendes Verständnis (dabei sehr lesbar), sind die Core Java Bücher von Cay Horstmann. Aktuell sind das "Core Java for the Impatient" (2015) und "Core Java - Volume 1 Fundamentals" (2015). Beide beinhalten bereits Java 8.
• Java-Tutorial-Seite zu Zugriffsmodifikatoren (Oracle)