Java-Syntax: Klassen, Methoden, Anweisungen und geschweifte Klammern

Wie ein Java-Programm aussieht

Auf der vorherigen Seite hast du Java zum Laufen gebracht. Jetzt sehen wir uns an, woraus der Code selbst eigentlich besteht. Java ist streng und explizit: Es gibt eine feste Form, der jedes Programm folgen muss, und der Compiler prüft diese Form, bevor eine einzige Zeile ausgeführt wird.

Hier ist das kleinstmögliche vollständige Java-Programm. Führe es aus:

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

Das sind viele Wörter, um eine einzige Zeile auszugeben, und anders als in Python oder JavaScript kannst du keines davon weglassen. Jeder Teil ist erforderlich, daher lohnt es sich zu verstehen, was jeder einzelne tut. Wir zerlegen es von außen nach innen.

Alles lebt in einer Klasse

Java hat keinen „losen“ Code, der auf der obersten Ebene einer Datei schwebt. Aller Code lebt innerhalb einer Klasse, die mit dem Schlüsselwort class und einem Namen deklariert wird:

public class Main {
    // everything goes in here
}

Die öffnende { und die zugehörige schließende } markieren den Rumpf der Klasse. Den Namen Main darfst du selbst wählen, mit einer wichtigen Regel: In einer normalen .java-Datei muss eine public-Klasse exakt mit dem Dateinamen übereinstimmen. Eine public class Main gehört in Main.java. Vertippst du dich bei der Groß-/Kleinschreibung, weigert sich der Compiler, sie zu bauen.

Was Klassen wirklich sind, lernst du im Kapitel Klassen. Behandle public class Main { ... } vorerst als die erforderliche Hülle um deinen Code.

Die main-Methode ist die Startlinie

Wenn du ein Java-Programm ausführst, sucht die Laufzeitumgebung eine ganz bestimmte Methode, um mit der Ausführung zu beginnen:

public static void main(String[] args) {
    // your code starts here
}

Diese Signatur ist nicht verhandelbar. Jedes Wort hat eine Aufgabe:

• public - die Laufzeitumgebung kann sie von außerhalb der Klasse erreichen.
• static - sie läuft, ohne dass zuvor ein Objekt der Klasse erzeugt wird.
• void - sie gibt nichts zurück, wenn sie fertig ist.
• main - der exakte Name, nach dem die Laufzeitumgebung sucht.
• String[] args - ein Array aller an das Programm übergebenen Kommandozeilenargumente.

Ist auch nur ein Wort falsch - Static statt static, String args statt String[] args - kompiliert dein Code vielleicht trotzdem, aber der Start schlägt mit Error: Main method not found in class Main fehl. Diese Meldung bedeutet fast immer einen Tippfehler in dieser Zeile.

Anweisungen enden mit einem Semikolon

Eine Anweisung ist eine vollständige Instruktion. In Java endet jede Anweisung mit einem Semikolon ;. Der Compiler nutzt das Semikolon, um zu erkennen, wo eine Instruktion aufhört und die nächste beginnt - Zeilenumbrüche spielen für ihn keine Rolle.

public class Main {
    public static void main(String[] args) {
        int score = 90;
        score = score + 5;
        System.out.println(score);
    }
}

Da Zeilenumbrüche ignoriert werden, könnten alle drei Anweisungen in einer einzigen Zeile stehen und trotzdem funktionieren - auch wenn niemand Java so schreibt:

int score = 90; score = score + 5; System.out.println(score);

Vergiss ein Semikolon, und der Compiler stoppt dich, bevor das Programm läuft:

int score = 90
System.out.println(score);

error: ';' expected
        int score = 90
                      ^

Ein fehlendes Semikolon ist der häufigste Kompilierfehler, dem du als Anfänger begegnest. Wenn der Compiler auf eine Zeile zeigt, prüfe auch die Zeile darüber - dort steckt oft die eigentliche Auslassung.

Blöcke und geschweifte Klammern

Geschweifte Klammern { } gruppieren Anweisungen zu einem Block. Ein Klassenrumpf ist ein Block, ein Methodenrumpf ist ein Block, und der Rumpf eines if oder einer Schleife ist ein Block. Blöcke können sich in andere Blöcke verschachteln:

public class Main {
    public static void main(String[] args) {
        int hour = 9;

        if (hour < 12) {
            System.out.println("Good morning");
            System.out.println("Time to code");
        }
    }
}

Beachte den Unterschied zu Anweisungen: Eine Zeile, die einen Block öffnet, endet mit {, nicht mit einem Semikolon, und du setzt kein Semikolon nach der schließenden } einer Methode, Klasse, eines if oder einer Schleife. Das zu verwechseln ist ein klassischer Anfängerfehler:

public static void main(String[] args) {
    System.out.println("hi");
}; // <- this semicolon is unnecessary (and after a class/method, wrong)

Die Einrückung in den Beispielen ist rein für Menschen gedacht. Java ignoriert sie, aber eine konsistente Einrückung ist die Art, wie du und alle anderen den Überblick behalten, welche { zu welcher } gehört. Lass deinen Editor automatisch einrücken, und die Klammern richten sich für dich aus.

Java unterscheidet Groß- und Kleinschreibung

Java behandelt Groß- und Kleinbuchstaben als völlig verschiedene Dinge. score, Score und SCORE sind drei getrennte Namen. Dasselbe gilt für Schlüsselwörter und eingebaute Namen:

public class Main {
    public static void main(String[] args) {
        String name = "Ada";
        System.out.println("Hello, " + name);
    }
}

Würdest du system.out.println (kleines s) oder String Name schreiben und dann versuchen, name zu verwenden, würde der Compiler es ablehnen. Ein paar Namen, die Anfänger häufig falsch schreiben:

• System - großes S. system.out.println(...) kompiliert nicht.
• String - großes S. Es ist eine Klasse, anders als die kleingeschriebenen primitiven Typen.
• void, int, public, static - alle kleingeschrieben. Es sind Schlüsselwörter.

Die meisten „cannot find symbol“-Fehler gehen auf einen Ausrutscher bei der Groß-/Kleinschreibung zurück. Der Fehler nennt dir sogar, welches Symbol er nicht finden konnte - vergleiche dessen Schreibweise mit dem, was du getippt hast.

Die Teile zusammensetzen

Hier ist ein etwas größeres Programm, das alles von dieser Seite verwendet - eine Klasse, die main-Methode, mehrere Anweisungen, einen verschachtelten Block und konsistente Schreibweise:

public class Main {
    public static void main(String[] args) {
        String city = "Lisbon";
        int temperature = 24;

        System.out.println("City: " + city);
        System.out.println("Temp: " + temperature + "C");

        if (temperature > 20) {
            System.out.println("Warm enough for shorts");
        }
    }
}

Lies es von oben nach unten: Die Klasse umschließt alles, main ist der Ort, an dem die Ausführung beginnt, jede Instruktion endet mit ;, der Rumpf des if ist in seinem eigenen Block gruppiert, und jeder eingebaute Name ist korrekt geschrieben. Das ist das Grundgerüst praktisch jedes Java-Programms, das du schreiben wirst.

Als Nächstes: Kommentare

Du kannst jetzt die Struktur einer Java-Datei lesen. Das Nächste, was du hinzufügst, sind Notizen für Menschen - Text, den der Compiler vollständig ignoriert. Die nächste Seite behandelt Kommentare: die einzeilige Form //, die Blockform /* */ und wann ein Kommentar seinen Platz im Code wirklich verdient.