Java main()-Methode – Syntax und Vereinfachung seit Java 25

In diesem Artikel erfährst du alles über die main()-Methode in Java – den Startpunkt eines jeden Java-Programms. Der Artikel beschreibt auch die in Java 25 finalisierten Vereinfachungen.

Du erfährst im Einzelnen:

• Was ist eine main()-Methode, und wofür brauchen wir sie?
• Wie wird die main()-Methode aufgerufen?
• Was sind die Bestandteile der main()-Methode in Java, und was bedeuten sie?
• Wie kannst du die main()-Methode in modernen Java-Versionen wesentlich einfacher schreiben?

Was ist eine main()-Methode in Java?

Damit ein Java-Programm gestartet werden kann, benötigt es eine main()-Methode. Diese Methode ist der Einstiegspunkt in das Programm. Die JVM (Java Virtual Machine) ruft beim Start eines Programms diese main()-Methode auf und führt den darin liegenden Java-Code aus.

Beispiel für eine main()-Methode in Java

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}Code-Sprache: Java (java)

Um dieses Programm zu starten, speichere den Programmcode zunächst in einer Datei mit dem Namen HelloWorld.java.

java HelloWorld.javaCode-Sprache: Klartext (plaintext)

Du solltest nun folgende Ausgabe sehen:

Hello world!Code-Sprache: Klartext (plaintext)

Glückwunsch! Du hast dein erstes Java-Programm geschrieben und gestartet.

Aber warum war das so kompliziert?

Was bedeuten all die Begriffe wie public, class, static, void usw. im Programmcode?

Die gute Nachricht: Das musst du als Anfänger:in zunächst gar nicht wissen. Denn: In modernen Java-Versionen geht das viel einfacher!

Wie? Das wirst du im folgenden Abschnitt sehen.

(Falls es dich dennoch interessiert, findest du eine detaillierte Beschreibung aller Bestandteile der main()-Methode weiter unten im Abschnitt Syntax der Java-main()-Methode.)

Vereinfachte main()-Methode

In Java 25 wurde die main()-Methode stark vereinfacht (die Vereinfachungen waren von Java 21 bis Java 24 als Preview-Feature verfügbar).

In diesem Abschnitt zeige ich dir, was sich für dich ändert. Die technischen Details hinter diesen Änderungen erfährst du im Abschnitt Compact Source Files and Instance Main Methods.

Gehen wir noch einmal zurück zum Hello-World-Beispiel aus dem ersten Abschnitt:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}Code-Sprache: Java (java)

Du musstest hier eine ganze Menge sogenannten „Boilerplate Code“ schreiben – also Code, der in jedem Java-Programm immer wieder der gleiche wäre. Dabei ist das Einzige, was du sagen willst: „Bitte gib den Text ‚Hello World!‘ aus.“

Seit Java 25 (und in Java 21 bis 24 mit aktivierten Preview-Features) kannst du das viel kürzer schreiben:

void main() {
    IO.println("Hello world!");
}Code-Sprache: Java (java)

Die main()-Methode und der Ausgabebefehl println sind noch da – doch eine Menge Boilerplate-Code drum herum wurde gelöscht, und System.out.println() wurde zu IO.println() verkürzt.

Somit müssen sich Java-Anfänger:innen keine Gedanken mehr über public, class, static usw. machen. Diese Begriffe können dann eingeführt werden, wenn sie wirklich gebraucht werden.

Im folgenden Kapitel erfährst du, welche technischen Details hinter den Veränderungen stecken.

Compact Source Files and Instance Main Methods

Im vorherigen Abschnitt hast du erfahren, dass eine Java-main()-Methode ohne Klasse, ohne public static und ohne String[] args geschrieben werden kann und dass für die Ausgabe statt System.out.println(...) das kürzere IO.println(...) genügt.

Damit ist der folgende Code ein gültiges und vollständiges Java-Programm:

void main() {
    IO.println("Hello world!");
}Code-Sprache: Java (java)

Dieser Abschnitt beschreibt detailliert die Änderungen, die diese Vereinfachung ermöglicht haben.

Im Folgenden beschreibe ich die fünf Bestandteile des Features: kompakte Quelldateien, implizit deklarierte Klassen, Instanz-Main-Methoden, die neue Klasse java.lang.IO für die Konsolenausgabe und den automatischen Import des java.base-Moduls.

Compact Source Files

Eine Java-Datei ohne explizite Klassendeklaration, also ohne beispielsweise public class HelloWorld, wird als „Compact Source File“, also „kompakte Quelldatei“ bezeichnet.

Implizit deklarierte Klassen

Aus dem in einer kompakten Quelldatei enthaltenen Code erzeugt der Java-Compiler eine sogenannte „implizit deklarierte Klasse“ mit einem vom Compiler festgelegten Namen. In der Praxis ist das der Name der Datei ohne die .java-Endung.

Wenn du beispielsweise die Datei HelloWorld.java kompilierst, erzeugt der Compiler die Datei HelloWorld.class – und wenn du diese z. B. mit deiner IDE dekompilierst, siehst du, dass auch der Klassenname HelloWorld ist.

Auf diesen Namen darfst du dich allerdings nicht verlassen: Er ist implementierungsspezifisch und kann sich ändern.

Für implizite Klassen gelten die folgenden Besonderheiten:

• Eine implizit deklarierte Klasse liegt immer im unbenannten Paket (so wie eine reguläre Klasse ohne package-Definition).
• Eine implizit deklarierte Klasse ist grundsätzlich final, von ihr kann also nicht geerbt werden.
• Eine implizit deklarierte Klasse kann keine Interfaces implementieren oder von anderen Klassen erben.
• Auf eine implizit deklarierte Klasse kann nicht über den vom Compiler festgelegten Namen zugegriffen werden, d. h. andere Klassen können eine implizit deklarierte Klasse nicht instanziieren, und keine Methoden darauf aufrufen, auch keine statischen.

Eine implizit deklarierte Klasse kann jedoch Methoden auf sich selbst aufrufen, d. h. Methoden, die in derselben .java-Datei definiert sind, so wie in folgendem Beispiel:

void main() {
    IO.println(greeting());
}

String greeting() {
    return "Hello, World!";
}Code-Sprache: Java (java)

Da auf eine implizit deklarierte Klasse von außerhalb nicht zugegriffen werden kann, muss sie immer eine main()-Methode enthalten.

Instanz-Main-Methoden

Instanz-Main-Methoden sind nicht-statische main()-Methoden, also main()-Methoden ohne das static-Keyword. Folgende main()-Methoden sind erlaubt:

• nicht statische Instanz-Methoden,
• Methoden mit dem Sichtbarkeitslevel public, protected oder package-private (ohne Modifier),
• Methoden mit oder ohne String[]-Parameter.

Hier sind ein paar Beispiele:

• void main()
• void main(String[] args)
• public void main()
• protected static void main(String[] args)

Statische und nicht-statische Methoden mit gleicher Signatur sowie Methoden mit unterschiedlichen Visibility-Modifiern bei gleicher Signatur schließen sich gegenseitig aus und führen zu einem „method is already defined“-Compiler-Fehler.

Es ist allerdings möglich, dass gleichzeitig eine main()-Methode mit String[]-Parameter und eine main()-Methode ohne Parameter in derselben .java-Datei existieren:

void main(String[] args) {
    // . . .
}

protected static void main() {
    // . . .
}Code-Sprache: Java (java)

Für diesen Fall wurde festgelegt, dass die Methode mit String[]-Parameter Priorität hat, im Beispiel also void main(String[] args) gestartet werden würde.

Dahinter steckt die Rückwärtskompatibilität: Schon vor den Vereinfachungen durfte eine Klasse neben der klassischen Einstiegsmethode public static void main(String[] args) eine weitere, überladene main()-Methode ohne Parameter enthalten – als Einstiegspunkt diente aber immer nur die Variante mit String[]-Parameter. Genau dieses Verhalten bleibt erhalten, damit bestehende Programme unverändert starten.

Konsoleninteraktion mit java.lang.IO

In der dritten Preview-Phase der Änderungen, in Java 23, wurde die neue IO-Klasse eingeführt. Seit der Finalisierung in Java 25 stellt sie fünf statische Methoden bereit:

• void print(Object obj) – gibt den übergebenen Text oder die Text-Repräsentation des übergebenen Objekts auf der Konsole aus – ohne Zeilenumbruch am Ende.
• void println(Object obj) – gibt den übergebenen Text oder die Text-Repräsentation des übergebenen Objekts auf der Konsole aus – mit Zeilenumbruch am Ende.
• void println() – gibt nur einen Zeilenumbruch aus, also eine leere Zeile.
• String readln(String prompt) – zeigt den übergebenen Prompt an, nimmt eine Benutzereingabe entgegen und gibt diese zurück.
• String readln() – nimmt eine Benutzereingabe ohne vorherigen Prompt entgegen und gibt diese zurück.

Automatischer Import des java.base-Moduls

Viele Standardklassen sind auch in kleinen Programmen nützlich. Damit du dafür nicht jedes Mal einen Import schreiben musst, importiert eine kompakte Quelldatei automatisch das gesamte java.base-Modul – so, als stünde am Dateianfang die Deklaration import module java.base;

Klassen aus häufig genutzten Paketen wie java.util, java.io oder java.math kannst du dadurch ohne expliziten Import verwenden:

void main() {
    var names = List.of("Anna", "Ben", "Carla");
    for (var name : names) {
        IO.println(name);
    }
}Code-Sprache: Java (java)

List ist hier sofort verfügbar, obwohl kein import java.util.List; im Code steht.

Sobald dein Programm wächst und du es in eine reguläre Klasse überführst, fällt dieser automatische Import weg. Dann ergänzt du die nötigen Imports selbst – beispielsweise mit einer Modul-Import-Deklaration import module java.base; am Dateianfang. Wie diese Modul-Import-Deklarationen genau funktionieren, erfährst du im Artikel import module in Java: Module Import Declarations.

Die Historie der Änderungen

Zum Abschluss noch ein Blick darauf, wie sich das Feature über die Java-Versionen hinweg entwickelt hat:

• Alles begann in Java 21 mit einem Preview-Feature mit dem kompliziert klingenden Namen „Unnamed Classes and Instance Main Methods“ (definiert in JDK Enhancement Proposal 445).
• In Java 22 wurde das Feature in die noch kompliziertere Bezeichnung „Implicitly Declared Classes and Instance Main Methods“ umgenannt (definiert in JDK Enhancement Proposal 463).
• In Java 23 wurde das Feature noch einmal verbessert (JDK Enhancement Proposal 477).
• In Java 24 wurde das Feature umbenannt in „Simple Source Files and Instance Main Methods“, bleibt aber weiter im Preview-Stadium (JDK Enhancement Proposal 495).
• In Java 25 wurde das Feature unter dem Namen „Compact Source Files and Instance Main Methods“ finalisiert (JDK Enhancement Proposal 512).

Syntax der Java-main()-Methode

Dieser Abschnitt beschreibt die klassische Syntax der main()-Methode, wie sie vor den Vereinfachungen galt – und in größeren Programmen weiterhin gilt. Klassischerweise ist eine main()-Methode in eine Klasse eingebettet, und ihre Syntax ist fest vorgegeben:

public class MyMainMethodDemo {
    public static void main(String[] args) {
        // code to execute
    }
    // possibly more code
}Code-Sprache: Java (java)

Nur der Name der Klasse, im Beispiel MyMainMethodDemo, und der Name des Parameters, im Beispiel args, dürfen frei gewählt werden.

Wenn ein Programm aus mehreren Klassen besteht, dürfen beliebig viele dieser Klassen eine main()-Methode enthalten. Zum Start eines Programms wird, wie zu Beginn des Artikels gezeigt, der Name der Klasse angegeben, deren main()-Methode gestartet werden soll.

Was bedeuten die einzelnen Elemente?

public class MyMainMethodDemo

Mit dieser ersten Codezeile wird eine Klasse im Sinne der objektorientierten Programmierung eingeleitet. MyMainMethodDemo ist der Name der Klasse. Java-Code ist immer innerhalb von Klassen angeordnet.

public static void main(String[] args)

Mit der zweiten Zeile, der sogenannten Methodensignatur, wird eine Methode eingeleitet. Methoden enthalten den auszuführenden Programmcode.

public

public ist ein sogenannter Sichtbarkeitsmodifikator. Eine Klasse sowie die darin enthaltene main()-Methode müssen public, also öffentlich sein, damit die JVM die main()-Methode aufrufen und den darin enthaltenen Programmcode ausführen kann.

static

In der Objektorientierung wird zwischen statischen Methoden und Instanzmethoden unterschieden. Statische Methoden können aufgerufen werden, ohne dass eine Instanz der sie umgebenden Klasse – also ein Objekt – erzeugt werden muss. Instanzmethoden können hingegen nur auf einem Objekt aufgerufen werden.

Die main()-Methode in Java muss statisch sein, um ohne Instanziierung der Klasse – also ohne Erzeugung eines Objekts dieser Klasse – aufrufbar zu sein.

void

Methoden können Werte zurückgeben, z. B. gibt die Methode Math.random() eine Zufallszahl zurück. Eine main()-Methode hat jedoch keinen Rückgabewert. Und genau das wird durch den Bezeichner void angegeben.

String[] args

Hierbei handelt es sich um einen Parameter der Methode. String[] ist der Typ des Parameters: ein String-Array. Und args ist der Name des Parameters. Dieser Name darf geändert werden. Beim Start eines Programms können sogenannte Kommandozeilenparameter übergeben werden, z. B. so:

java HelloWorld.java happy coders out thereCode-Sprache: Klartext (plaintext)

Diese Parameter werden als String-Array an die main()-Methode übergeben und können dort z. B. so ausgelesen und ausgegeben werden:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.print("Hello");
        for (String arg : args) {
            System.out.print(" " + arg);
        }
        System.out.println("!");
    }
}Code-Sprache: Java (java)

Wenn du dieses Programm wie oben aufrufst, bekommst du folgende Ausgabe:

Hello happy coders out there!Code-Sprache: Klartext (plaintext)

Fazit

Die main()-Methode ist der Startpunkt eines jeden Java-Programms. Ohne diese kann kein Java-Programm starten. Klassischerweise ist die Syntax einer main()-Methode starr vorgegeben:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}Code-Sprache: Java (java)

Seit Java 25 (und in Java 21 bis 24 mit aktivierten Preview-Features) kannst du dieselbe main()-Methode wie folgt schreiben:

void main() {
    IO.println("Hello world!");
}Code-Sprache: Java (java)

Das macht es insbesondere Java-Anfänger:innen leichter, die Sprache zu erlernen. Konzepte, die erst für größere Programme relevant werden, wie Klassen, die Unterscheidung in statische und Instanzmethoden, Sichtbarkeitsmodifikatoren wie public, protected und private sowie grobgranulare Strukturen wie Pakete und Module können so dann eingeführt werden, wenn sie gebraucht werden.