{"id":40683,"date":"2024-05-30T13:05:45","date_gmt":"2024-05-30T11:05:45","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=40683"},"modified":"2026-06-11T09:59:29","modified_gmt":"2026-06-11T07:59:29","slug":"main-methode","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/java\/main-methode\/","title":{"rendered":"Java main()-Methode \u2013 Syntax und Vereinfachung seit Java 25"},"content":{"rendered":"\n<p class=\"wp-block-paragraph\">In diesem Artikel erf\u00e4hrst du alles \u00fcber die <code>main()<\/code>-Methode in Java \u2013 den Startpunkt eines jeden Java-Programms. Der Artikel beschreibt auch die in <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-25-features\/#compact-source-files-and-instance-main-methods-jep-512\">Java 25<\/a> finalisierten <a href=\"#compact-source-files-and-instance-main-methods\">Vereinfachungen<\/a>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Du erf\u00e4hrst im Einzelnen:<\/p>\n\n\n\n<ul class=\"wp-block-list hc-checked-list\">\n<li>Was ist eine <code>main()<\/code>-Methode, und wof\u00fcr brauchen wir sie?<\/li>\n\n\n\n<li>Wie wird die <code>main()<\/code>-Methode aufgerufen? <\/li>\n\n\n\n<li>Was sind die Bestandteile der <code>main()<\/code>-Methode in Java, und was bedeuten sie?<\/li>\n\n\n\n<li>Wie kannst du die <code>main()<\/code>-Methode in modernen Java-Versionen wesentlich einfacher schreiben?<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"was-ist-eine-main-methode-in-java\">Was ist eine main()-Methode in Java?<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Damit ein Java-Programm gestartet werden kann, ben\u00f6tigt es eine <code>main()<\/code>-Methode. Diese Methode ist der Einstiegspunkt in das Programm. Die JVM (Java Virtual Machine) ruft beim Start eines Programms diese <code>main()<\/code>-Methode auf und f\u00fchrt den darin liegenden Java-Code aus.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"beispiel-fuer-eine-main-methode-in-java\">Beispiel f\u00fcr eine main()-Methode in Java<\/h3>\n\n\n\n<div class=\"wp-block-group is-nowrap is-layout-flex wp-container-core-group-is-layout-3a88641f wp-block-group-is-layout-flex\">\n<p class=\"wp-block-paragraph\">Ein einfaches Hello-World-Java-Programm mit einer <code>main()<\/code>-Methode sieht z. B. so aus:<\/p>\n<\/div>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-2\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">HelloWorld<\/span> <\/span>{\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n        System.out.println(<span class=\"hljs-string\">\"Hello world!\"<\/span>);\n    }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-2\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Um dieses Programm zu starten, speichere den Programmcode zun\u00e4chst in einer Datei mit dem Namen <code>HelloWorld.java<\/code>.<\/p>\n\n\n\n<div class=\"wp-block-group is-nowrap is-layout-flex wp-container-core-group-is-layout-3a88641f wp-block-group-is-layout-flex\">\n<p class=\"wp-block-paragraph\">Gib dann auf der Kommandozeile \/ in einem Terminal den folgenden Befehl ein:<\/p>\n<\/div>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-3\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">java HelloWorld.java<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-3\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Du solltest nun folgende Ausgabe sehen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-4\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">Hello world!<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-4\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Gl\u00fcckwunsch! Du hast dein erstes Java-Programm geschrieben und gestartet.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Aber warum war das so kompliziert?<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Was bedeuten all die Begriffe wie <code>public<\/code>, <code>class<\/code>, <code>static<\/code>, <code>void<\/code> usw. im Programmcode?<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die gute Nachricht: Das musst du als Anf\u00e4nger:in zun\u00e4chst gar nicht wissen. Denn: In modernen Java-Versionen geht das viel einfacher!<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Wie? Das wirst du im folgenden Abschnitt sehen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">(Falls es dich dennoch interessiert, findest du eine detaillierte Beschreibung aller Bestandteile der <code>main()<\/code>-Methode weiter unten im Abschnitt <a href=\"#syntax-der-java-main-methode\">Syntax der Java-main()-Methode<\/a>.)<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"vereinfachte-main-methode\">Vereinfachte main()-Methode<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">In <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-25-features\/#compact-source-files-and-instance-main-methods-jep-512\">Java 25<\/a> wurde die <code>main()<\/code>-Methode stark vereinfacht (die Vereinfachungen waren von Java 21 bis Java 24 als Preview-Feature verf\u00fcgbar).<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">In diesem Abschnitt zeige ich dir, was sich f\u00fcr dich \u00e4ndert. Die technischen Details hinter diesen \u00c4nderungen erf\u00e4hrst du im Abschnitt <a href=\"#compact-source-files-and-instance-main-methods\">Compact Source Files and Instance Main Methods<\/a>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Gehen wir noch einmal zur\u00fcck zum Hello-World-Beispiel aus dem ersten Abschnitt:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-5\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">HelloWorld<\/span> <\/span>{\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n        System.out.println(<span class=\"hljs-string\">\"Hello world!\"<\/span>);\n    }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-5\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Du musstest hier eine ganze Menge sogenannten \u201eBoilerplate Code\u201c schreiben \u2013 also Code, der in jedem Java-Programm immer wieder der gleiche w\u00e4re. Dabei ist das Einzige, was du sagen willst: \u201eBitte gib den Text \u201aHello World!\u2018 aus.\u201c<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Seit Java 25 (und in Java 21 bis 24 mit aktivierten Preview-Features) kannst du das viel k\u00fcrzer schreiben:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-6\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    IO.println(<span class=\"hljs-string\">\"Hello world!\"<\/span>);\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-6\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Die <code>main()<\/code>-Methode und der Ausgabebefehl <code>println<\/code> sind noch da \u2013 doch eine Menge Boilerplate-Code drum herum wurde gel\u00f6scht, und <code>System.out.println()<\/code> wurde zu <code>IO.println()<\/code> verk\u00fcrzt.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Somit m\u00fcssen sich Java-Anf\u00e4nger:innen keine Gedanken mehr \u00fcber <code>public<\/code>, <code>class<\/code>, <code>static<\/code> usw. machen. Diese Begriffe k\u00f6nnen dann eingef\u00fchrt werden, wenn sie wirklich gebraucht werden.<\/p>\n\n\n\n<div class=\"wp-block-uagb-container uagb-block-8ae4ca2e alignfull uagb-is-root-container\">\n<div class=\"uagb-block-b769b372 uagb-infobox__content-wrap  uagb-infobox-icon-left uagb-infobox-left uagb-infobox-stacked-mobile uagb-infobox-image-valign-top \"><div class=\"uagb-ifb-icon-wrap\"><svg xmlns=\"https:\/\/www.w3.org\/2000\/svg\" viewBox=\"0 0 512 512\"><path d=\"M256 0C114.6 0 0 114.6 0 256s114.6 256 256 256s256-114.6 256-256S397.4 0 256 0zM256 128c17.67 0 32 14.33 32 32c0 17.67-14.33 32-32 32S224 177.7 224 160C224 142.3 238.3 128 256 128zM296 384h-80C202.8 384 192 373.3 192 360s10.75-24 24-24h16v-64H224c-13.25 0-24-10.75-24-24S210.8 224 224 224h32c13.25 0 24 10.75 24 24v88h16c13.25 0 24 10.75 24 24S309.3 384 296 384z\"><\/path><\/svg><\/div><div class=\"uagb-ifb-content\"><div class=\"uagb-ifb-title-wrap\"><\/div><p class=\"uagb-ifb-desc\">Seit Java 25 l\u00e4uft der Code direkt mit <code>java HelloWorld.java<\/code>. <br><br>Nur in den Preview-Versionen Java 21 bis 24 musstest du das Feature explizit aktivieren \u2013 z. B. mit <code>java --enable-preview --source 24 HelloWorld.java<\/code>.<\/p><\/div><\/div>\n<\/div>\n\n\n\n<p class=\"wp-block-paragraph\">Im folgenden Kapitel erf\u00e4hrst du, welche technischen Details hinter den Ver\u00e4nderungen stecken.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"compact-source-files-and-instance-main-methods\">Compact Source Files and Instance Main Methods<\/h2>\n\n\n\n<div class=\"wp-block-uagb-container uagb-block-aa712f79 alignfull uagb-is-root-container\">\n<div class=\"uagb-block-bcf7e38d uagb-infobox__content-wrap  uagb-infobox-icon-left uagb-infobox-left uagb-infobox-stacked-mobile uagb-infobox-image-valign-top \"><div class=\"uagb-ifb-icon-wrap\"><svg xmlns=\"https:\/\/www.w3.org\/2000\/svg\" viewBox=\"0 0 512 512\"><path d=\"M256 0C114.6 0 0 114.6 0 256s114.6 256 256 256s256-114.6 256-256S397.4 0 256 0zM256 128c17.67 0 32 14.33 32 32c0 17.67-14.33 32-32 32S224 177.7 224 160C224 142.3 238.3 128 256 128zM296 384h-80C202.8 384 192 373.3 192 360s10.75-24 24-24h16v-64H224c-13.25 0-24-10.75-24-24S210.8 224 224 224h32c13.25 0 24 10.75 24 24v88h16c13.25 0 24 10.75 24 24S309.3 384 296 384z\"><\/path><\/svg><\/div><div class=\"uagb-ifb-content\"><div class=\"uagb-ifb-title-wrap\"><\/div><p class=\"uagb-ifb-desc\">In Java 24 hie\u00df dieses Feature \u201eSimple Source Files and Instance Main Methods\u201c, davor \u201eImplicitly Declared Classes and Instance Main Methods\u201c.<\/p><\/div><\/div>\n<\/div>\n\n\n\n<p class=\"wp-block-paragraph\">Im vorherigen Abschnitt hast du erfahren, dass eine Java-<code>main()<\/code>-Methode ohne Klasse, ohne <code>public static<\/code> und ohne <code>String[] args<\/code> geschrieben werden kann und dass f\u00fcr die Ausgabe statt <code>System.out.println(...)<\/code> das k\u00fcrzere <code>IO.println(...)<\/code> gen\u00fcgt.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Damit ist der folgende Code ein g\u00fcltiges und vollst\u00e4ndiges Java-Programm:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-7\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    IO.println(<span class=\"hljs-string\">\"Hello world!\"<\/span>);\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-7\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Dieser Abschnitt beschreibt detailliert die \u00c4nderungen, die diese Vereinfachung erm\u00f6glicht haben.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Im Folgenden beschreibe ich die f\u00fcnf Bestandteile des Features: kompakte Quelldateien, implizit deklarierte Klassen, Instanz-Main-Methoden, die neue Klasse <code>java.lang.IO<\/code> f\u00fcr die Konsolenausgabe und den automatischen Import des <code>java.base<\/code>-Moduls.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"compact-source-files\">Compact Source Files<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Eine Java-Datei ohne explizite Klassendeklaration, also ohne beispielsweise <code>public class HelloWorld<\/code>, wird als \u201eCompact Source File\u201c, also \u201ekompakte Quelldatei\u201c bezeichnet.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"implizit-deklarierte-klassen\">Implizit deklarierte Klassen<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Aus dem in einer kompakten Quelldatei enthaltenen Code erzeugt der Java-Compiler eine sogenannte \u201eimplizit deklarierte Klasse\u201c mit einem vom Compiler festgelegten Namen. In der Praxis ist das der Name der Datei ohne die <code>.java<\/code>-Endung.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Wenn du beispielsweise die Datei <code>HelloWorld.java<\/code> kompilierst, erzeugt der Compiler die Datei <code>HelloWorld.class<\/code> \u2013 und wenn du diese z. B. mit deiner IDE dekompilierst, siehst du, dass auch der Klassenname <code>HelloWorld<\/code> ist.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Auf diesen Namen darfst du dich allerdings nicht verlassen: Er ist implementierungsspezifisch und kann sich \u00e4ndern.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">F\u00fcr implizite Klassen gelten die folgenden Besonderheiten:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Eine implizit deklarierte Klasse liegt immer im unbenannten Paket (so wie eine regul\u00e4re Klasse ohne <code>package<\/code>-Definition).<\/li>\n\n\n\n<li>Eine implizit deklarierte Klasse ist grunds\u00e4tzlich <code>final<\/code>, von ihr kann also nicht geerbt werden.<\/li>\n\n\n\n<li>Eine implizit deklarierte Klasse kann keine Interfaces implementieren oder von anderen Klassen erben.<\/li>\n\n\n\n<li>Auf eine implizit deklarierte Klasse kann nicht \u00fcber den vom Compiler festgelegten Namen zugegriffen werden, d. h. andere Klassen k\u00f6nnen eine implizit deklarierte Klasse nicht instanziieren, und keine Methoden darauf aufrufen, auch keine statischen.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Eine implizit deklarierte Klasse kann jedoch Methoden auf sich selbst aufrufen, d. h. Methoden, die in derselben <code>.java<\/code>-Datei definiert sind, so wie in folgendem Beispiel:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-8\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    IO.println(greeting());\n}\n\n<span class=\"hljs-function\">String <span class=\"hljs-title\">greeting<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-string\">\"Hello, World!\"<\/span>;\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-8\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Da auf eine implizit deklarierte Klasse von au\u00dferhalb nicht zugegriffen werden kann, muss sie immer eine <code>main()<\/code>-Methode enthalten.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"instanz-main-methoden\">Instanz-Main-Methoden<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Instanz-Main-Methoden sind nicht-statische <code>main()<\/code>-Methoden, also <code>main()<\/code>-Methoden ohne das <code>static<\/code>-Keyword. Folgende <code>main()<\/code>-Methoden sind erlaubt:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>nicht statische Instanz-Methoden,<\/li>\n\n\n\n<li>Methoden mit dem Sichtbarkeitslevel <code>public<\/code>, <code>protected<\/code> oder package-private (ohne Modifier),<\/li>\n\n\n\n<li>Methoden mit oder ohne <code>String[]<\/code>-Parameter.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Hier sind ein paar Beispiele:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><code>void main()<\/code><\/li>\n\n\n\n<li><code>void main(String[] args)<\/code><\/li>\n\n\n\n<li><code>public void main()<\/code><\/li>\n\n\n\n<li><code>protected static void main(String[] args)<\/code><\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Statische und nicht-statische Methoden mit gleicher Signatur sowie Methoden mit unterschiedlichen Visibility-Modifiern bei gleicher Signatur schlie\u00dfen sich gegenseitig aus und f\u00fchren zu einem \u201emethod is already defined\u201c-Compiler-Fehler.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Es ist allerdings m\u00f6glich, dass gleichzeitig eine <code>main()<\/code>-Methode mit <code>String[]<\/code>-Parameter und eine <code>main()<\/code>-Methode ohne Parameter in derselben <code>.java<\/code>-Datei existieren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-9\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n    <span class=\"hljs-comment\">\/\/ . . .<\/span>\n}\n\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">protected<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    <span class=\"hljs-comment\">\/\/ . . .<\/span>\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-9\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">F\u00fcr diesen Fall wurde festgelegt, dass die Methode mit <code>String[]<\/code>-Parameter Priorit\u00e4t hat, im Beispiel also <code>void main(String[] args)<\/code> gestartet werden w\u00fcrde.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Dahinter steckt die R\u00fcckw\u00e4rtskompatibilit\u00e4t: Schon vor den Vereinfachungen durfte eine Klasse neben der klassischen Einstiegsmethode <code>public static void main(String[] args)<\/code> eine weitere, \u00fcberladene <code>main()<\/code>-Methode ohne Parameter enthalten \u2013 als Einstiegspunkt diente aber immer nur die Variante mit <code>String[]<\/code>-Parameter. Genau dieses Verhalten bleibt erhalten, damit bestehende Programme unver\u00e4ndert starten.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"konsoleninteraktion-mit-java-lang-io\">Konsoleninteraktion mit java.lang.IO<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">In der dritten Preview-Phase der \u00c4nderungen, in <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-23-features\/#implicitly-declared-classes-and-instance-main-methods-third-preview-jep-477\">Java 23<\/a>, wurde die neue <code>IO<\/code>-Klasse eingef\u00fchrt. Seit der Finalisierung in Java 25 stellt sie f\u00fcnf statische Methoden bereit:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><code>void print(Object obj)<\/code> \u2013 gibt den \u00fcbergebenen Text oder die Text-Repr\u00e4sentation des \u00fcbergebenen Objekts auf der Konsole aus \u2013 ohne Zeilenumbruch am Ende.<\/li>\n\n\n\n<li><code>void println(Object obj)<\/code> \u2013 gibt den \u00fcbergebenen Text oder die Text-Repr\u00e4sentation des \u00fcbergebenen Objekts auf der Konsole aus \u2013 mit Zeilenumbruch am Ende.<\/li>\n\n\n\n<li><code>void println()<\/code> \u2013 gibt nur einen Zeilenumbruch aus, also eine leere Zeile.<\/li>\n\n\n\n<li><code>String readln(String prompt)<\/code> \u2013 zeigt den \u00fcbergebenen Prompt an, nimmt eine Benutzereingabe entgegen und gibt diese zur\u00fcck.<\/li>\n\n\n\n<li><code>String readln()<\/code> \u2013 nimmt eine Benutzereingabe ohne vorherigen Prompt entgegen und gibt diese zur\u00fcck.<\/li>\n<\/ul>\n\n\n\n<div class=\"wp-block-uagb-container uagb-block-3b9d7799 alignfull uagb-is-root-container\">\n<div class=\"uagb-block-5c1f1b71 uagb-infobox__content-wrap  uagb-infobox-icon-left uagb-infobox-left uagb-infobox-stacked-mobile uagb-infobox-image-valign-top \"><div class=\"uagb-ifb-icon-wrap\"><svg xmlns=\"https:\/\/www.w3.org\/2000\/svg\" viewBox=\"0 0 512 512\"><path d=\"M256 0C114.6 0 0 114.6 0 256s114.6 256 256 256s256-114.6 256-256S397.4 0 256 0zM256 128c17.67 0 32 14.33 32 32c0 17.67-14.33 32-32 32S224 177.7 224 160C224 142.3 238.3 128 256 128zM296 384h-80C202.8 384 192 373.3 192 360s10.75-24 24-24h16v-64H224c-13.25 0-24-10.75-24-24S210.8 224 224 224h32c13.25 0 24 10.75 24 24v88h16c13.25 0 24 10.75 24 24S309.3 384 296 384z\"><\/path><\/svg><\/div><div class=\"uagb-ifb-content\"><div class=\"uagb-ifb-title-wrap\"><\/div><p class=\"uagb-ifb-desc\">In Java 23 und Java 24 lag diese Klasse noch im Paket <code>java.io<\/code>, und eine implizit deklarierte Klasse importierte ihre Methoden automatisch \u2013 du konntest <code>println()<\/code> also ohne qualifizierenden Klassennamen-Pr\u00e4fix aufrufen.<br><br>In Java 25 wurde die <code>IO<\/code>-Klasse in das Paket <code>java.lang<\/code> verschoben, und der automatische Import der <code>IO<\/code>-Methoden wurde wieder entfernt. Das bedeutet: Seit Java 25 schreibst du entweder <code>IO.println()<\/code> \u2013 oder du importierst die <code>println()<\/code>-Methode statisch:<br><br><code>import static java.lang.IO.*;<\/code><br><br>Mit dieser Import-Deklaration kannst du <code>println()<\/code> und die anderen <code>IO<\/code>-Methoden auch in Java 25 ohne Klassennamen-Pr\u00e4fix aufrufen.<\/p><\/div><\/div>\n<\/div>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"automatischer-import-des-java-base-moduls\">Automatischer Import des java.base-Moduls<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Viele Standardklassen sind auch in kleinen Programmen n\u00fctzlich. Damit du daf\u00fcr nicht jedes Mal einen Import schreiben musst, importiert eine kompakte Quelldatei automatisch das gesamte <code>java.base<\/code>-Modul \u2013 so, als st\u00fcnde am Dateianfang die Deklaration <code>import module java.base;<\/code><\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Klassen aus h\u00e4ufig genutzten Paketen wie <code>java.util<\/code>, <code>java.io<\/code> oder <code>java.math<\/code> kannst du dadurch ohne expliziten Import verwenden:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-10\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    <span class=\"hljs-keyword\">var<\/span> names = List.of(<span class=\"hljs-string\">\"Anna\"<\/span>, <span class=\"hljs-string\">\"Ben\"<\/span>, <span class=\"hljs-string\">\"Carla\"<\/span>);\n    <span class=\"hljs-keyword\">for<\/span> (<span class=\"hljs-keyword\">var<\/span> name : names) {\n        IO.println(name);\n    }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-10\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\"><code>List<\/code> ist hier sofort verf\u00fcgbar, obwohl kein <code>import java.util.List;<\/code> im Code steht. <\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Sobald dein Programm w\u00e4chst und du es in eine regul\u00e4re Klasse \u00fcberf\u00fchrst, f\u00e4llt dieser automatische Import weg. Dann erg\u00e4nzt du die n\u00f6tigen Imports selbst \u2013 beispielsweise mit einer Modul-Import-Deklaration <code>import module java.base;<\/code> am Dateianfang. Wie diese Modul-Import-Deklarationen genau funktionieren, erf\u00e4hrst du im Artikel <a href=\"https:\/\/www.happycoders.eu\/de\/java\/module-importieren\/\">import module in Java: Module Import Declarations<\/a>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"die-historie-der-aenderungen\">Die Historie der \u00c4nderungen<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Zum Abschluss noch ein Blick darauf, wie sich das Feature \u00fcber die Java-Versionen hinweg entwickelt hat:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Alles begann in <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-21-features\/#unnamed-classes-and-instance-main-methods-preview-jep-445\">Java 21<\/a> mit einem Preview-Feature mit dem kompliziert klingenden Namen \u201eUnnamed Classes and Instance Main Methods\u201c (definiert in <a href=\"https:\/\/openjdk.org\/jeps\/445\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 445<\/a>).<\/li>\n\n\n\n<li>In <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-22-features\/#implicitly-declared-classes-and-instance-main-methods-second-preview-jep-463\">Java 22<\/a> wurde das Feature in die noch kompliziertere Bezeichnung \u201eImplicitly Declared Classes and Instance Main Methods\u201c umgenannt (definiert in <a href=\"https:\/\/openjdk.org\/jeps\/463\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 463<\/a>).<\/li>\n\n\n\n<li>In <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-23-features\/#implicitly-declared-classes-and-instance-main-methods-third-preview-jep-477\">Java 23<\/a> wurde das Feature noch einmal verbessert (<a href=\"https:\/\/openjdk.org\/jeps\/477\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 477<\/a>).<\/li>\n\n\n\n<li>In <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-24-features\/#simple-source-files-and-instance-main-methods-fourth-preview-jep-495\">Java 24<\/a> wurde das Feature umbenannt in \u201eSimple Source Files and Instance Main Methods\u201c, bleibt aber weiter im Preview-Stadium (<a href=\"https:\/\/openjdk.org\/jeps\/495\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 495<\/a>).<\/li>\n\n\n\n<li>In <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-25-features\/#compact-source-files-and-instance-main-methods-jep-512\">Java 25<\/a> wurde das Feature unter dem Namen \u201eCompact Source Files and Instance Main Methods\u201c finalisiert (<a href=\"https:\/\/openjdk.org\/jeps\/512\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 512<\/a>).<\/li>\n<\/ul>\n\n\n<div class=\"convertkit-form wp-block-convertkit-form\" style=\"\"><script async data-uid=\"1427197203\" src=\"https:\/\/happycoders.kit.com\/1427197203\/index.js\" data-jetpack-boost=\"ignore\" data-no-defer=\"1\" data-no-optimize=\"1\" nowprocket><\/script><\/div>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"syntax-der-java-main-methode\">Syntax der Java-main()-Methode<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Dieser Abschnitt beschreibt die klassische Syntax der <code>main()<\/code>-Methode, wie sie vor den Vereinfachungen galt \u2013 und in gr\u00f6\u00dferen Programmen weiterhin gilt. Klassischerweise ist eine <code>main()<\/code>-Methode in eine Klasse eingebettet, und ihre Syntax ist fest vorgegeben:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-11\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">MyMainMethodDemo<\/span> <\/span>{\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n        <span class=\"hljs-comment\">\/\/ code to execute<\/span>\n    }\n    <span class=\"hljs-comment\">\/\/ possibly more code<\/span>\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-11\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Nur der Name der Klasse, im Beispiel <code>MyMainMethodDemo<\/code>, und der Name des Parameters, im Beispiel <code>args<\/code>, d\u00fcrfen frei gew\u00e4hlt werden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Wenn ein Programm aus mehreren Klassen besteht, d\u00fcrfen beliebig viele dieser Klassen eine <code>main()<\/code>-Methode enthalten. Zum Start eines Programms wird, wie zu Beginn des Artikels gezeigt, der Name der Klasse angegeben, deren <code>main()<\/code>-Methode gestartet werden soll.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Was bedeuten die einzelnen Elemente?<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"public-class-mymainmethoddemo\">public class MyMainMethodDemo<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Mit dieser ersten Codezeile wird eine <a href=\"https:\/\/de.wikipedia.org\/wiki\/Klasse_(Objektorientierung)\" target=\"_blank\" rel=\"noopener\">Klasse<\/a> im Sinne der objektorientierten Programmierung eingeleitet. <code>MyMainMethodDemo<\/code> ist der Name der Klasse. Java-Code ist immer innerhalb von Klassen angeordnet. <\/p>\n\n\n\n<div class=\"wp-block-uagb-container uagb-block-91599ad7 alignfull uagb-is-root-container\">\n<div class=\"uagb-block-cd44bca2 uagb-infobox__content-wrap  uagb-infobox-icon-left uagb-infobox-left uagb-infobox-stacked-mobile uagb-infobox-image-valign-top \"><div class=\"uagb-ifb-icon-wrap\"><svg xmlns=\"https:\/\/www.w3.org\/2000\/svg\" viewBox=\"0 0 512 512\"><path d=\"M256 0C114.6 0 0 114.6 0 256s114.6 256 256 256s256-114.6 256-256S397.4 0 256 0zM256 128c17.67 0 32 14.33 32 32c0 17.67-14.33 32-32 32S224 177.7 224 160C224 142.3 238.3 128 256 128zM296 384h-80C202.8 384 192 373.3 192 360s10.75-24 24-24h16v-64H224c-13.25 0-24-10.75-24-24S210.8 224 224 224h32c13.25 0 24 10.75 24 24v88h16c13.25 0 24 10.75 24 24S309.3 384 296 384z\"><\/path><\/svg><\/div><div class=\"uagb-ifb-content\"><div class=\"uagb-ifb-title-wrap\"><\/div><p class=\"uagb-ifb-desc\">Mit <a href=\"#compact-source-files-and-instance-main-methods\">kompakten Quelldateien und Instanz-Main-Methoden<\/a> ist dies nicht mehr erforderlich.<\/p><\/div><\/div>\n<\/div>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"public-static-void-mainstring-args\">public static void main(String[] args)<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Mit der zweiten Zeile, der sogenannten Methodensignatur, wird eine <a href=\"https:\/\/de.wikipedia.org\/wiki\/Methode_(Programmierung)\" target=\"_blank\" rel=\"noopener\">Methode<\/a> eingeleitet. Methoden enthalten den auszuf\u00fchrenden Programmcode.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"public\">public<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\"><code>public<\/code> ist ein sogenannter <a href=\"https:\/\/de.wikipedia.org\/wiki\/Sichtbarkeit_(Programmierung)\" target=\"_blank\" rel=\"noopener\">Sichtbarkeitsmodifikator<\/a>. Eine Klasse sowie die darin enthaltene <code>main()<\/code>-Methode m\u00fcssen <code>public<\/code>, also \u00f6ffentlich sein, damit die JVM die <code>main()<\/code>-Methode aufrufen und den darin enthaltenen Programmcode ausf\u00fchren kann.<\/p>\n\n\n\n<div class=\"wp-block-uagb-container uagb-block-41d58166 alignfull uagb-is-root-container\">\n<div class=\"uagb-block-480b6a83 uagb-infobox__content-wrap  uagb-infobox-icon-left uagb-infobox-left uagb-infobox-stacked-mobile uagb-infobox-image-valign-top \"><div class=\"uagb-ifb-icon-wrap\"><svg xmlns=\"https:\/\/www.w3.org\/2000\/svg\" viewBox=\"0 0 512 512\"><path d=\"M256 0C114.6 0 0 114.6 0 256s114.6 256 256 256s256-114.6 256-256S397.4 0 256 0zM256 128c17.67 0 32 14.33 32 32c0 17.67-14.33 32-32 32S224 177.7 224 160C224 142.3 238.3 128 256 128zM296 384h-80C202.8 384 192 373.3 192 360s10.75-24 24-24h16v-64H224c-13.25 0-24-10.75-24-24S210.8 224 224 224h32c13.25 0 24 10.75 24 24v88h16c13.25 0 24 10.75 24 24S309.3 384 296 384z\"><\/path><\/svg><\/div><div class=\"uagb-ifb-content\"><div class=\"uagb-ifb-title-wrap\"><\/div><p class=\"uagb-ifb-desc\">Mit <a href=\"#compact-source-files-and-instance-main-methods\">kompakten Quelldateien und Instanz-Main-Methoden<\/a> ist dies nicht mehr erforderlich.<\/p><\/div><\/div>\n<\/div>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"static\">static<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">In der Objektorientierung wird zwischen statischen Methoden und Instanzmethoden unterschieden. Statische Methoden k\u00f6nnen aufgerufen werden, ohne dass eine Instanz der sie umgebenden Klasse \u2013 also ein Objekt \u2013 erzeugt werden muss. Instanzmethoden k\u00f6nnen hingegen nur auf einem Objekt aufgerufen werden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die <code>main()<\/code>-Methode in Java muss statisch sein, um ohne Instanziierung der Klasse \u2013 also ohne Erzeugung eines Objekts dieser Klasse \u2013 aufrufbar zu sein.<\/p>\n\n\n\n<div class=\"wp-block-uagb-container uagb-block-946b31e6 alignfull uagb-is-root-container\">\n<div class=\"uagb-block-f12d16d6 uagb-infobox__content-wrap  uagb-infobox-icon-left uagb-infobox-left uagb-infobox-stacked-mobile uagb-infobox-image-valign-top \"><div class=\"uagb-ifb-icon-wrap\"><svg xmlns=\"https:\/\/www.w3.org\/2000\/svg\" viewBox=\"0 0 512 512\"><path d=\"M256 0C114.6 0 0 114.6 0 256s114.6 256 256 256s256-114.6 256-256S397.4 0 256 0zM256 128c17.67 0 32 14.33 32 32c0 17.67-14.33 32-32 32S224 177.7 224 160C224 142.3 238.3 128 256 128zM296 384h-80C202.8 384 192 373.3 192 360s10.75-24 24-24h16v-64H224c-13.25 0-24-10.75-24-24S210.8 224 224 224h32c13.25 0 24 10.75 24 24v88h16c13.25 0 24 10.75 24 24S309.3 384 296 384z\"><\/path><\/svg><\/div><div class=\"uagb-ifb-content\"><div class=\"uagb-ifb-title-wrap\"><\/div><p class=\"uagb-ifb-desc\">Mit <a href=\"#compact-source-files-and-instance-main-methods\">kompakten Quelldateien und Instanz-main-Methoden<\/a> ist dies nicht mehr erforderlich.<\/p><\/div><\/div>\n<\/div>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"void\">void<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Methoden k\u00f6nnen Werte zur\u00fcckgeben, z. B. gibt die Methode <code>Math.random()<\/code> eine Zufallszahl zur\u00fcck. Eine <code>main()<\/code>-Methode hat jedoch keinen R\u00fcckgabewert. Und genau das wird durch den Bezeichner <code>void<\/code> angegeben.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"string-args\">String[] args<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Hierbei handelt es sich um einen <a href=\"https:\/\/de.wikipedia.org\/wiki\/Parameter_(Informatik)\" target=\"_blank\" rel=\"noopener\">Parameter der Methode<\/a>. <code>String[]<\/code> ist der Typ des Parameters: ein <code>String<\/code>-Array. Und <code>args<\/code> ist der Name des Parameters. Dieser Name darf ge\u00e4ndert werden. Beim Start eines Programms k\u00f6nnen sogenannte Kommandozeilenparameter \u00fcbergeben werden, z. B. so:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-12\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">java HelloWorld.java happy coders out there<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-12\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Diese Parameter werden als <code>String<\/code>-Array an die <code>main()<\/code>-Methode \u00fcbergeben und k\u00f6nnen dort z. B. so ausgelesen und ausgegeben werden:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-13\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">HelloWorld<\/span> <\/span>{\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n        System.out.print(<span class=\"hljs-string\">\"Hello\"<\/span>);\n        <span class=\"hljs-keyword\">for<\/span> (String arg : args) {\n            System.out.print(<span class=\"hljs-string\">\" \"<\/span> + arg);\n        }\n        System.out.println(<span class=\"hljs-string\">\"!\"<\/span>);\n    }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-13\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Wenn du dieses Programm wie oben aufrufst, bekommst du folgende Ausgabe:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-14\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">Hello happy coders out there!<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-14\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"fazit\">Fazit<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Die <code>main()<\/code>-Methode ist der Startpunkt eines jeden Java-Programms. Ohne diese kann kein Java-Programm starten. Klassischerweise ist die Syntax einer <code>main()<\/code>-Methode starr vorgegeben:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-15\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">HelloWorld<\/span> <\/span>{\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n        System.out.println(<span class=\"hljs-string\">\"Hello world!\"<\/span>);\n    }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-15\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Seit <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-25-features\/#compact-source-files-and-instance-main-methods-jep-512\">Java 25<\/a> (und in Java 21 bis 24 mit aktivierten Preview-Features) kannst du dieselbe <code>main()<\/code>-Methode wie folgt schreiben:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-16\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    IO.println(<span class=\"hljs-string\">\"Hello world!\"<\/span>);\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-16\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Das macht es insbesondere Java-Anf\u00e4nger:innen leichter, die Sprache zu erlernen. Konzepte, die erst f\u00fcr gr\u00f6\u00dfere Programme relevant werden, wie Klassen, die Unterscheidung in statische und Instanzmethoden, Sichtbarkeitsmodifikatoren wie <code>public<\/code>, <code>protected<\/code> und <code>private<\/code> sowie grobgranulare Strukturen wie Pakete und Module k\u00f6nnen so dann eingef\u00fchrt werden, wenn sie gebraucht werden.<\/p>\n<aside><p>Wenn dir der Artikel weitergeholfen hat, w\u00fcrde ich mich sehr \u00fcber eine positive Bewertung auf meinem <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">ProvenExpert-Profil<\/a> freuen. Dein Feedback hilft mir, meine Inhalte weiter zu verbessern und motiviert mich, neue informative Artikel zu schreiben.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">Bewertung abgeben<\/a><\/p>\r\n                        <p>Du m\u00f6chtest \u00fcber alle neuen Java-Features auf dem Laufenden sein? Dann <a href=\"#\" data-formkit-toggle=\"d8ee997126\">klicke hier<\/a>, um dich f\u00fcr den HappyCoders-Newsletter anzumelden.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"#\" data-formkit-toggle=\"d8ee997126\">Newsletter-Anmeldung<\/a><\/p><\/aside>","protected":false},"excerpt":{"rendered":"<p>Entdecke alles \u00fcber die main-Methode in Java, den Startpunkt eines jeden Java-Programms. Erfahre mehr \u00fcber die Bestandteile, Aufrufe und die neuesten Vereinfachungen in den Java-Versionen 21 bis 23.<\/p>\n","protected":false},"author":1,"featured_media":40696,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_seopress_titles_title":"","_seopress_titles_desc":"Die main()-Methode ist der Startpunkt jedes Java-Programms. Erfahre, wie sie aufgebaut ist \u2013 und wie du sie seit Java 25 deutlich k\u00fcrzer schreibst.","_seopress_robots_index":"","_seopress_robots_follow":"","_seopress_robots_imageindex":"","_seopress_robots_snippet":"","_seopress_robots_primary_cat":"","_seopress_robots_breadcrumbs":"","_seopress_robots_freeze_modified_date":"","_seopress_robots_custom_modified_date":"","_seopress_robots_canonical":"","_seopress_social_fb_title":"","_seopress_social_fb_desc":"","_seopress_social_fb_img":"","_seopress_social_fb_img_attachment_id":0,"_seopress_social_fb_img_width":0,"_seopress_social_fb_img_height":0,"_seopress_social_twitter_title":"","_seopress_social_twitter_desc":"","_seopress_social_twitter_img":"","_seopress_social_twitter_img_attachment_id":0,"_seopress_social_twitter_img_width":0,"_seopress_social_twitter_img_height":0,"_seopress_redirections_value":"","_seopress_redirections_enabled":"","_seopress_redirections_enabled_regex":"","_seopress_redirections_logged_status":"","_seopress_redirections_param":"","_seopress_redirections_type":0,"_seopress_analysis_target_kw":"java main method,java main methode,java main-methode,main-methode in java,main() methode in java","_seopress_news_disabled":"","_seopress_video_disabled":"","_seopress_video":[],"_seopress_pro_schemas_manual":[],"_seopress_pro_rich_snippets_disable_all":"","_seopress_pro_rich_snippets_disable":[],"_seopress_pro_schemas":[],"_uag_custom_page_level_css":"","_wp_convertkit_post_meta":{"form":"-1","landing_page":"","tag":"0","restrict_content":"0"},"_metis_text_type":"standard","_metis_text_length":15417,"_post_count":0,"footnotes":""},"categories":[64],"tags":[219],"class_list":["post-40683","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-grundlagen"],"uagb_featured_image_src":{"full":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method.jpg",1770,986,false],"thumbnail":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method.jpg",150,84,false],"medium":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method.jpg",300,167,false],"medium_large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method.jpg",768,428,false],"large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method.jpg",1024,570,false],"feature_thumb_224":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-224x125.jpg",224,125,true],"feature_thumb_336":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-336x187.jpg",336,187,true],"feature_thumb_504":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-504x281.jpg",504,281,true],"feature_thumb_672":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-672x374.jpg",672,374,true],"half_400":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-400x223.jpg",400,223,true],"half_600":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-600x334.jpg",600,334,true],"full_800":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-800x446.jpg",800,446,true],"full_944":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-944x526.jpg",944,526,true],"full_1200":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-1200x668.jpg",1200,668,true],"wide_1180":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-1180x490.jpg",1180,490,true],"wide_1770":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method-1770x735.jpg",1770,735,true],"1536x1536":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method.jpg",1536,856,false],"2048x2048":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2024\/05\/java-main-method.jpg",1770,986,false]},"uagb_author_info":{"display_name":"Sven Woltmann","author_link":"https:\/\/www.happycoders.eu\/de\/author\/sven\/"},"uagb_comment_info":0,"uagb_excerpt":"Entdecke alles \u00fcber die main-Methode in Java, den Startpunkt eines jeden Java-Programms. Erfahre mehr \u00fcber die Bestandteile, Aufrufe und die neuesten Vereinfachungen in den Java-Versionen 21 bis 23.","public_identification_id":"17b31d442bc54e4bb8b9d29e8d5a0e1f","private_identification_id":"c0c3ad9c22b84127a845290a697a5df8","_links":{"self":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/40683","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/comments?post=40683"}],"version-history":[{"count":17,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/40683\/revisions"}],"predecessor-version":[{"id":56740,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/40683\/revisions\/56740"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media\/40696"}],"wp:attachment":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media?parent=40683"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/categories?post=40683"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/tags?post=40683"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}