Java ausführen: mit javac kompilieren und mit java starten

Erst kompilieren, dann ausführen

Jetzt, da du ein JDK installiert hast, ist das Ausführen von Java ein zweistufiger Zyklus. Anders als bei einer Skriptsprache, bei der du einen Interpreter auf eine Datei ansetzt und loslegst, kompiliert Java deinen für Menschen lesbaren Quelltext zuerst in Bytecode, und ein separater Schritt führt diesen Bytecode dann auf der JVM aus.

Diese beiden Schritte entsprechen zwei Kommandozeilenwerkzeugen, die mit dem JDK ausgeliefert werden:

• javac - der Compiler. Er liest Main.java und schreibt Main.class (Bytecode).
• java - der Launcher. Er startet die JVM und führt den Bytecode in Main.class aus.

Du kannst jedes eigenständige Beispiel direkt hier auf der Seite ausführen - der Editor unten erledigt beide Schritte für dich. Aber es lohnt sich zu verstehen, was auf deinem eigenen Rechner passiert, denn dort leben echte Projekte.

public class Main {
    public static void main(String[] args) {
        System.out.println("Compiled, then run.");
    }
}

Die zwei Befehle auf deinem Rechner

Angenommen, du hast diesen Code als Main.java gespeichert:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello from the terminal");
    }
}

Öffne ein Terminal in dem Ordner, der die Datei enthält, und führe den Compiler aus:

javac Main.java

Wenn der Code fehlerfrei kompiliert, gibt javac nichts aus und erstellt eine neue Datei, Main.class, neben deinem Quelltext. Diese .class-Datei ist der Bytecode - sie ist kein lesbarer Text und nicht an dein Betriebssystem gebunden.

Starte sie jetzt mit dem java-Befehl:

java Main

Hello from the terminal

Der mit Abstand häufigste Anfängerfehler steckt hier: Du führst java aus, nicht javac, um das Programm zu starten, und du übergibst den Klassennamen ohne Erweiterung. Es heißt java Main - niemals java Main.class und niemals java Main.java.

Der Dateiname muss zur öffentlichen Klasse passen

Java erzwingt eine Regel, die Neulinge überrascht: Eine public-Klasse muss in einer Datei mit exakt demselben Namen plus .java liegen. Eine public class Main muss in Main.java stehen. Vertu dich bei der Groß- und Kleinschreibung, und javac weigert sich zu kompilieren.

// This is in a file called Greeting.java
public class Greeting {   // ERROR: class Greeting should be in Greeting.java... wait, it is
    public static void main(String[] args) {
        System.out.println("Hi");
    }
}

Die Diskrepanz, die Leute wirklich beißt, ist subtiler - die Datei greeting.java (kleingeschrieben) zu nennen, während die Klasse Greeting heißt, oder Main.java zu speichern, aber public class Hello zu schreiben. Der Compiler meldet etwa Folgendes:

Main.java:1: error: class Hello is public, should be declared in a file named Hello.java

Die Lösung ist immer dieselbe: Mache den Dateinamen und den Namen der öffentlichen Klasse identisch, Zeichen für Zeichen.

Die Abkürzung: eine einzelne Datei direkt ausführen

Seit JDK 11 kannst du den expliziten Kompilierschritt für eine einzelne Quelldatei überspringen. Der java-Befehl kompiliert sie im Arbeitsspeicher und führt sie in einem Rutsch aus - es wird keine .class-Datei auf die Festplatte geschrieben:

java Main.java

Das ist perfekt für schnelle Experimente und kleine Skripte. Beachte den Unterschied bei dem, was du übergibst:

• java Main - führt eine bereits kompilierte Main.class aus.
• java Main.java - kompiliert und führt die Quelldatei in einem Zug aus.

Der Einzeldatei-Modus funktioniert nur, wenn dein gesamtes Programm in eine Datei passt. Sobald du den Code auf mehrere Klassen in mehreren Dateien aufteilst, kompilierst du wieder zuerst mit javac. Zum Erlernen der Grundlagen hält der Einzeldatei-Modus die Schleife kurz.

Argumente an dein Programm übergeben

Erinnerst du dich an das String[] args in main? Das sind die Kommandozeilenargumente. Alles, was du nach dem Klassennamen im java-Befehl eingibst, landet in diesem Array:

public class Main {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("No arguments given.");
        } else {
            System.out.println("First argument: " + args[0]);
            System.out.println("Total arguments: " + args.length);
        }
    }
}

Auf deinem eigenen Rechner würdest du ihm so Argumente übergeben:

java Main hello world

First argument: hello
Total arguments: 2

Der Editor oben kann keine Terminal-Argumente entgegennehmen, also führt er den Zweig „keine Argumente" aus - aber derselbe Code behandelt beide Fälle. So lesen Java-Programme die beim Start übergebene Eingabe ein, lange bevor du zu Dateien oder Benutzereingaben kommst.

Die Fehlermeldungen des Compilers lesen

Wenn javac deinen Code ablehnt, nennt er dir die Datei, die Zeile und was schiefgelaufen ist. Zu lernen, diese Meldungen zu lesen, ist die halbe Miete, um wieder ins Rollen zu kommen. Hier ist ein Klassiker - ein fehlendes Semikolon:

public class Main {
    public static void main(String[] args) {
        System.out.println("Oops")   // no semicolon
    }
}

Main.java:3: error: ';' expected
        System.out.println("Oops")
                                  ^
1 error

Das Caret (^) zeigt auf die Stelle, an der der Compiler etwas erwartet hat. Main.java:3 ist die Datei und die Zeilennummer. Widerstehe dem Drang zu raten - lies die Zeile, behebe die eine Sache, die sie benennt, und kompiliere neu. Compiler-Fehler bedeuten, dass noch nichts gelaufen ist; Laufzeitfehler (die anders aussehen) bedeuten, dass dein Programm gestartet und dann gescheitert ist.

Ein Funktionstest-Programm

Führe dies im Editor aus oder speichere es als Main.java und mache javac Main.java und dann java Main auf deinem eigenen Rechner. Wenn du alle drei Zeilen siehst, funktioniert deine Toolchain von Anfang bis Ende:

public class Main {
    public static void main(String[] args) {
        System.out.println("1. Java is running");

        int sum = 2 + 2;
        System.out.println("2. Two plus two is " + sum);

        String[] languages = {"Java", "Python", "JavaScript"};
        System.out.println("3. There are " + languages.length + " languages listed");
    }
}

Hier tauchen drei Dinge auf, die du bald richtig kennenlernst: eine int-Variable, die Zeichenkettenverkettung mit + und ein Array mit seinem .length. Für den Moment reicht es, dass das Programm kompiliert und etwas ausgibt.

Weiter: Java-Syntax

Du hast ein paar Programme ausgeführt, aber wir sind über die Interpunktion hinweggegangen - die geschweiften Klammern, die Semikolons, public static void main und warum jede Zeile so aussieht, wie sie aussieht. Die nächste Seite zerlegt Javas Syntax Stück für Stück, damit sich die Struktur nicht mehr wie Boilerplate anfühlt, sondern Sinn ergibt.