Die ersten Schritte zur Java Programmierung

Martin Kompf

Inhalt

Basiswerkzeuge

Um in Java programmieren zu können, benötigt man mindestens die folgenden Werkzeuge:

Die Abkürzung «SE» steht für «Standard Edition». Das ist die am meisten verwendete Java Edition für Desktop Applikationen. Daneben gibt es auch eine Micro Edition (ME) für embedded Devices und eine Enterprise Edition (EE) für Unternehmensanwendungen, die nicht im Fokus dieses Einsteigertutorials sind.

Texteditor

Der Texteditor dient zum Erstellen des Java Quell- oder Sourcecodes. Es ist schwer, einen geeigneten Texteditor zu empfehlen, da hier die persönlichen Vorlieben weit auseinander gehen. Man sollte bei der Auswahl neben der zuverlässigen Funktion auf gewisse Komfortmerkmale, wie mehrstufiges Undo/Redo, Suchen und Ersetzen, farbige Syntaxhervorhebung und so weiter, achten.

Eine sehr unvollständige Liste geeigneter und freier Texteditoren ist:

Die Organisation des Arbeitsbereiches

Als einfaches Beispiel im Rahmen dieser Anleitung soll ein kleines Programm dienen, das «Hello» gefolgt vom Anmeldenamen des Benutzers ausgibt:

package de.kompf.tutor;

/**
 * Simple java program to greet the user.
 */
public class Hello {

  /**
   * MAIN
   * @param args ignored
   */
  public static void main(String[] args) {
    Hello hello = new Hello();
    hello.greet();
  }

  private void greet() {
    String user = System.getProperty("user.name");
    System.out.println("Hello " + user + "!");
  }
}

Das Programm ist also in den Texteditor einzugeben und dann abzuspeichern. Bei der Wahl des Speicherortes und generell der Organisation des Arbeitsbereiches sollte man jedoch planvoll vorgehen. Ein mögliches Verfahren hierfür ist:

Zusammengefasst führt das im Beispiel zu folgender Struktur des Arbeitsbereiches:

firststeps
|
+-- bin
|
+-- src
    |
    +--de
       |
       +--kompf
          |
          +--tutor
             |
             +--Hello.java

Das Java SE Development Kit

Die wichtigste Komponente des Java Development Kits (JDK) ist der Java Compiler javac, der den Sourcecode in Bytecode übersetzt. Dieser Bytecode ist plattformneutral, das heisst er kann auf den verschiedensten Betriebssystemen ausgeführt werden. Allerdings benötigt man dafür auf jeder Zielplattform das Java Runtime Environment (JRE), dessen wichtigste Bestandteile die Java Virtual Machine (JVM) und die Java Standard API sind.

Die JRE ist Bestandteil des JDK, sodass ein Java Entwickler nur die JDK installieren muss. Für einen Endanwender, der nur Java Programme ausführen will, ist dagegen die Installation der JRE ausreichend.

Es gibt eine Reihe verschiedener Hersteller von JDKs. Empfehlenswert für den Anfänger ist eigentlich nur die Implementierung vom Java Erfinder Sun. Auf den Downloadseiten von java.sun.com findet man die aktuellen JDKs für Window, Linux und Solaris. Hier steht auch die komplette JDK Dokumentation zur Verfügung, die man gleich mit herunterladen sollte. Linux Anwender sollten vorher einen Blick in den Paketmanager ihrer Distribution werfen, möglicherweise ist dort sogar die aktuelle JDK verfügbar. Unter Debian Lenny beispielsweise heißt das entsprechende Paket sun-java6-jdk.

Nach der Installation der JDK und dem Entpacken der Dokumentation steht ein erster Test an. Dazu öffnet man eine Eingabeaufforderung oder ein Terminal und bestimmt die Versionen der JVM java und des Compilers javac:

java -version
javac -version

Es ist wichtig, dass die Versionsnummern von java und javac übereinstimmen. Unter Windows schlägt dieser Test regelmäßig fehl, da nach einer Standardinstallation nur die JRE im Suchpfad ist und javac dann nicht gefunden wird. Dem kann man durch das Setzen der Umgebungsvariablen JAVA_HOME und PATH abhelfen:

set JAVA_HOME=C:\Programme\Java\jdk1.6.0_13
set PATH=%JAVA_HOME%\bin;%PATH%
java -version
java version "1.6.0_13"
javac -version
javac 1.6.0_13

Das ist nur ein Beispiel, die genauen Pfade hängen von der installierten Java Version ab und sind entsprechend anzupassen!

JAVA_HOME muss auf das Verzeichnis zeigen, in das die JDK installiert wurde und PATH ist um das bin Verzeichnis des JDK zu erweitern. Unter Unix ist die Syntax zum Setzen der Umgebungsvariablen der verwendeten Shell anzupassen, zum Beispiel für die Bash:

export JAVA_HOME=/usr/lib/jdk1.6.0_13
PATH=$JAVA_HOME/bin:$PATH

Falls man - wie oben angeregt - die JDK über den Paketmanager der Linux Distribution eingespielt hat, sollte dieser Schritt allerdings gar nicht notwendig sein.

Kompilieren mit javac

Nach diesen Vorarbeiten kann nun endlich das erste Java Programm kompiliert werden. Man wechselt dazu in das oben eingerichtete Projektverzeichnis firststeps und ruft den Java Compiler auf.

javac -d bin src/de/kompf/tutor/Hello.java

Damit wird die angegebene Sourcecode Datei kompiliert, der Bytecode wird - per Option -d spezifiziert - im Verzeichnis bin abgelegt. Die Bytecode Datei trägt den Namen der Java Klasse gefolgt von der Extension .class. Die Ordnerstruktur entspricht wieder der Packagestruktur. Im Beispiel entsteht somit die Datei bin/de/kompf/tutor/Hello.class.

Ausführen mit java

Zur Ausführung des Bytecodes benötigt man die JVM, die sich hinter dem Programm java verbirgt:

java -cp bin de.kompf.tutor.Hello
Hello martin!

Das Programm java bekommt den Namen der Klasse mit der main Methode übergeben. Es handelt sich wohlgemerkt um den Namen der Klasse inklusive Package und nicht um den Dateinamen! Deswegen wird als Separator auch der Punkt verwendet und es gibt keine Dateiextension.

Die Option -cp bezeichnet den Classpath, in dem die .class Dateien gesucht werden. Das kann eine Liste von Verzeichnissen oder JAR Dateien (dazu später mehr) sein. Die Bestandteile der Liste werden mit dem plattformspezifischen PATH-Separator getrennt, also Semikolon ; unter Windows oder Doppelpunkt : unter Unix.

Paketieren mit jar

Sind alle Tests erfolgreich abgelaufen, so möchte man sein neues Java Programm vielleicht anderen Personen zur Verfügung stellen. Es ist zwar möglich, aber allerdings auch sehr aufwändig und fehlerträchtig, die komplette Verzeichnisstruktur unterhalb des bin Verzeichnis zu verteilen. Eine geeignetere Distributionsform ist das Zusammenpacken aller benötigten Dateien in ein Archiv, die JAR Datei. Dazu dient das Tool jar:

jar cvfe firststeps.jar de.kompf.tutor.Hello -C bin .

Parameter des Aufrufs von jar sind der Name der zu erzeugenden JAR Datei, der Name der Klasse mit der main Methode, das Verzeichnis mit den .class Dateien und die Liste der Dateien. Der hier verwendete Punkt . steht für alle Dateien in allen Unterverzeichnissen.

Die so erstellte JAR Datei kann wieder mittels java ausgeführt werden. Es muss dabei nur noch der Name des JAR Files angegeben werden, der Name der Main Klasse ist bereits (durch den Aufruf jar) im Archiv fest verankert:

java -jar firststeps.jar
Hello martin!

Das JAR File mit dem enthaltenen Bytecode ist plattformunabhängig. Es stellt kein Problem dar, das JAR auf beliebigen Betriebssystemen auszuführen, sofern dort eine JRE vorhanden ist. Das ist ein großer Vorteil von Java verglichen mit der Programmierung in C oder C++!

Die Beispiele haben nur einen kleinen Teil der möglichen Optionen der Tools javac, jar und java vorgestellt. Eine vollständige Dokumentation ist in der JDK Dokumentation, Abschnitt Tool Docs enthalten.

Automatisierung mit ant

Die im letzen Kapitel vorgestellten Schritte Kompilieren, Ausführen/Testen, Paketieren werden während der Softwareentwicklung typischerweise immer wieder ausgeführt. Das ist nervend und fehlerträchtig, insbesondere bei größeren Projekten mit vielen Sourcecode Dateien verliert man schnell den Überblick. Eine Automatisierung des Prozesses kann hier Abhilfe schaffen.

Das Tool zur Automatisierung von Buildprozessen im Java Umfeld ist Ant. Es ist selber auch in Java implementiert und daher auf allen von Java unterstützten Plattformen lauffähig.

Zur Installation kann man unter Linux wieder den Paketmanager der Distribution verwenden. Unter Debian Lenny heißt das entsprechende Paket ant.

Sonst (unter Windows) muss man sich die Distribution von http://ant.apache.org/ herunterladen und in ein leeres Verzeichnis auspacken. Dann ist noch die Umgebungsvariablen ANT_HOME zu setzen, sodass sie den Pfad zu diesem Verzeichnis enthält. Außerdem muss PATH um $ANT_HOME/bin erweitert werden. Zum Beispiel:

set ANT_HOME=C:\Programme\apache-ant-1.6.2
set PATH=%ANT_HOME%\bin;%PATH%

Die Steuerung von Ant erfolgt über eine projektspezifisches Build Datei im XML Format. Standardmäßig hat diese Datei den Namen build.xml und befindet sich direkt im Projektverzeichnis - im Beispiel also im Verzeichnis firststeps. Die Arbeitsweise von ant kann am besten an einer exemplarischen build.xml veranschaulicht werden:

<project name="firststeps" default="compile" basedir=".">
    <!-- The main class of the project -->
    <property name="main.class" value="de.kompf.tutor.Hello"/>

    <property name="jar.file" value="${basedir}/${ant.project.name}.jar"/>
    <property name="src.dir" value="${basedir}/src"/>
    <property name="build.dir" value="${basedir}/bin"/>
    
    <path id="run.classpath">
        <pathelement path="${build.dir}"/>
    </path>
    
    <target name="init">
        <mkdir dir="${build.dir}"/>
    </target>

    <target name="compile" depends="init" description="compile">
        <javac srcdir="${src.dir}" destdir="${build.dir}" />
    </target>

    <target name="run-hello" depends="compile" description="Run the program">
        <java classname="${main.class}" classpathref="run.classpath" />
    </target>

    <target name="jar" depends="compile" description="Create a jar file">
        <jar destfile="${jar.file}">
            <fileset dir="${build.dir}"/>
            <manifest>
                <attribute name="Main-Class" value="${main.class}"/>
            </manifest>
        </jar>
    </target>
</project>

Die äußere Klammer bildet das Element project. Darunter sind verschiedene targets deklariert. Ein Target steht für eine bestimmte, in sich abgeschlossene Aufgabe, wie zum Beispiel Kompilieren (Target compile), Ausführen (run-hello) oder Paketieren (jar). Eine Übersicht über alle Targets erhält man durch Eingabe von ant -p:

ant -p
Main targets:

 compile    compile
 jar        Create a jar file
 run-hello  Run the program
Default target: compile

Das klappt so nur, wenn die Build Datei den Namen build.xml hat und sich im aktuellen Verzeichnis befindet. Sonst muss man ihren Namen per Kommandozeilenoption -f übergeben.

Ein Target kann direkt ausgeführt werden durch Eingabe von ant gefolgt vom Namen des Targets:

ant jar

Lässt man das Target weg, dann wird das Default Target ausgeführt, welches im Attribut default des Elements project definiert wurde.

Targets können voneinander abhängig sein, dies wird durch das Attribut depends gekennzeichnet. Beim Ausführen des jar Targets wird daher zunächst intern compile aufgerufen, das wiederum als erstes init ausführt.

Innerhalb eines Targets stehen ein oder mehrere Tasks. Sie bestimmen, was bei der Abarbeitung des Targets letztendlich passiert. Im Beispiel ruft das Target compile den Task javac auf. Eine Liste aller in Ant eingebauten Tasks und der zugehörigen Attribute findet man im Ant Manual. Die umfangreiche Palette reicht von Operationen im Dateisystem, der Arbeit mit Archiven über das Kompilieren und Ausführen von Programmen bis hin zum Versenden von E-Mail.

Die vorgestellte minimale build.xml lässt sich gut als Ausgangspunkt für eigene Projekte verwenden. Damit der Änderungsaufwand gering bleibt, wurden variable Parameter zu Beginn der Datei als property definiert. Zum Beispiel enthält die Property main.class den Namen der Main Klasse. An verschiedenen Stellen nimmt die Build Datei dann auf diese Property mittels der Konstruktion ${main.class} Bezug.

Integrierte Entwicklungsumgebungen

Trotz der Automatisierung mit Ant ist das bisher beschriebene Vorgehen bei größeren Projekten immer noch mühsam. Der ständige Wechsel zwischen Texteditor und Kommandozeile, fehlende Querverweise zwischen verschiedenen Sourcecode Dateien und unvollkommene Eingabehilfen, wie automatische Quelltextvervollständigung, sind nervend und zeitraubend.

Abhilfe schafft hier die Verwendung einer integrierten Entwicklungsumgebung (Integrated Development Environment - IDE). Bekannte und freie IDEs im Java Umfeld sind

Beide IDEs sind gleichermaßen umfangreich und mächtig, unterscheiden sich aber in Konzept und Bedienung teilweise erheblich. Man sollte beides einmal ausprobieren und sich dann auf eine IDE festlegen.

Erste Schritte mit Eclipse

Voraussetzung für den Betrieb von Eclipse ist eine installierte JRE. Trotzdem ist die IDE keine pure Java Implementierung, auf der Downloadseite muss man daher das passende Betriebssystem auswählen. Für die Entwicklung auf der Basis der Java SE ist das Paket «Eclipse IDE for Java Developers» die richtige Wahl.

Unter Debian Lenny kann man auch die Installation von Eclipse über den Paketmanager abhandeln, das Paket heißt eclipse und installiert die nicht mehr ganz aktuelle, aber ausreichende Version 3.2 der Eclipse Plattform inklusive der Java Development Tools.

Nach dem Start fordert Eclipse zur Auswahl des Workspace Verzeichnis auf. Unter diesem Verzeichnis werden später die Projekte angelegt. Man kann die Standardeinstellung übernehmen - beim ersten Start von Eclipse erscheint dann die «Welcome» Seite.

Ein neues Java Projekt legt man per File - New - Project - Java Project an. Es erscheint ein Wizard, in dem man mindestens den Projektnamen angeben sollte - zum Beispiel firststeps. Auch empfiehlt sich eine Trennung von Source- und Bytecode, dies erreicht man durch Auswahl der Option Create separate source and output folders.

Nun taucht das neu angelegte Projekt im Package Explorer der Java Perspektive auf. Per File - New - Class kann man eine neue Java Klasse anlegen. Als Package trägt man de.kompf.tutor und als Name Hello ein. Jetzt erscheint die neue Klasse im Package Explorer und ein Java Editor Fenster öffnet sich. Hier kann der Java Sourcecode aus dem Beispiel oben eingegeben werden. Beim Abspeichern per Tastenkombination Strg S wird die Klasse dann sofort automatisch kompiliert und eventuelle Fehler angezeigt. Geschieht dies nicht, sollte man sich vergewissern, ob die Option Project - Build Automatically eingeschaltet ist.

Das Java Programm kann auch direkt in der IDE ausgeführt werden, dazu selektiert man Hello.java im Package Explorer mit der rechten Maustaste und wählt aus dem Kontextmenü Run As - Java Application aus.

Die Möglichkeiten von Eclipse sind dermaßen umfangreich, dass sie den Umfang dieses Einsteigertutorial sprengen würden. Daher an dieser Stelle nur der Hinweis auf zwei interessante und häufig genutzte Features:

Durch Aktivieren der Strg Taste verwandeln sich Klassen-, Methoden- und Variablennamen beim Überfahren mit der Maus in Links. Beim Anklicken gelangt man dann sofort zur Deklaration der entsprechenden Klasse, Methode oder Variablen.

Die Code Completetion macht während des Eintippens beim Aktivieren der Tastenkombination Strg Space passende Vorschläge zur Vervollständigung des Programmcodes:
Eclipse Code Completion

Mit den hier beschriebenen Verfahren ist es möglich, Entwicklungsumgebungen unterschiedlicher Leistungsfähigkeit und Komforts für die Java Programmierung aufzubauen. Obwohl für kleinere Projekte die Kombination Editor plus JDK ausreichend ist, wird später jeder Entwickler eine IDE wie Eclipse oder NetBeans verwenden. Tools wie Ant sind jedoch unabdingbar, wenn es um die Automatisierung von Buildprozessen geht, wie sie bei der Entwicklung von Softwareprodukten und der Teamarbeit unverzichtbar sind.