Java Methoden definieren und aufrufen – Anleitung für Einsteiger
- Marcel Schmidtpeter
- 16. Apr.
- 5 Min. Lesezeit
Stell dir vor, du sitzt an deinem ersten Java-Projekt - egal ob in der Berufsschule, im Uni-Praktikum oder im ersten Job. Dein Programm berechnet die Mehrwertsteuer für verschiedene Produkte. Und zwar zum fünften Mal, weil du die gleiche Rechnung überall reinkopiert hast. Ändert sich der Steuersatz, musst du jede Stelle einzeln anpassen. Frustrierend, oder?
Genau hier kommen Java Methoden ins Spiel. Eine Methode ist ein benannter Codeblock, den du einmal definierst und dann beliebig oft aufrufen kannst. Stell dir das wie ein Kochrezept vor: Du schreibst es einmal auf und kannst es immer wieder benutzen, ohne jedes Mal neu zu überlegen, wie die Zubereitung funktioniert.
Was ist eine Java Methode?
Eine Java Methode ist ein benannter, wiederverwendbarer Codeblock innerhalb einer Klasse, der eine bestimmte Aufgabe ausführt. Methoden können Parameter (Eingabewerte) entgegennehmen und einen Rückgabewert liefern. Sie helfen dir, Code zu strukturieren und Wiederholungen zu vermeiden.
Drei gute Gründe, warum du Methoden brauchst:
Wiederverwendbarkeit - Code einmal schreiben, überall nutzen
Übersichtlichkeit - Komplexe Programme werden in kleine, verständliche Teile zerlegt
Wartbarkeit - Fehler musst du nur an einer Stelle korrigieren
Merke: Methoden sind das Grundgerüst sauberen Java-Codes. Ohne sie wird jedes Projekt schnell unübersichtlich.
Mehr zu den Grundlagen der Programmierung in Java findest du in den offiziellen Oracle Tutorials.
Wie ist eine Java Methode aufgebaut?
Jede Java Methode besteht aus einem Rückgabetyp, dem Methodennamen, einer Parameterliste und dem Methodenkörper. Der Methodenkörper ist der Code zwischen den geschweiften Klammern, der die eigentliche Arbeit erledigt.
Die allgemeine Syntax sieht so aus:
Hier ist ein einfaches, lauffähiges Beispiel:
Lass uns die Bestandteile im Detail anschauen:
Bestandteil | Bedeutung | Beispiel |
`public` | Sichtbarkeit - wer darf die Methode aufrufen | `public`, `private`, `protected` |
`static` | Klassenmethode - aufrufbar ohne Objekt | `static` oder leer |
`int` | Rückgabetyp - welcher Datentyp kommt zurück | `int`, `String`, `boolean`, `void` |
`addiere` | Methodenname - frei wählbar | Kleinbuchstaben, camelCase |
`(int a, int b)` | Parameter - welche Eingabewerte die Methode erwartet | Beliebig viele oder leer `()` |
`return a + b` | Rückgabe - was die Methode zurückliefert | Muss zum Rückgabetyp passen |
Sichtbarkeit bestimmt, von wo aus du die Methode aufrufen darfst. `public` heißt: jeder darf. `private` heißt: nur innerhalb derselben Klasse. `static` bedeutet, dass die Methode zur Klasse selbst gehört, nicht zu einem Objekt. Für deine ersten kleinen Programme in der `main`-Methode kannst du `public static` als Standard merken.
Werden Objekte verwendet (wie in der objektorientierten Programmierung), lässt du `static` weg und arbeitest mit Instanzen.
Merke: Jede Methode mit einem Rückgabetyp (alles außer `void`) muss ein `return`-Statement haben. Der Wert hinter `return` muss zum deklarierten Typ passen.
Was bedeuten Parameter und Rückgabewert?
Parameter sind Variablen, die du einer Methode beim Aufruf mitgibst. Der Rückgabewert ist das Ergebnis, das die Methode an den Aufrufer zurückliefert.
Stell dir eine Methode wie einen Getränkeautomaten vor: Du wirfst Geld ein (Parameter), drückst einen Knopf (Methodenaufruf) und bekommst ein Getränk (Rückgabewert).
Methoden ohne Rückgabewert (void)
Manchmal möchtest du nur etwas ausführen, ohne einen Wert zurückzubekommen. Dafür nutzt du den Rückgabetyp `void` (englisch für "nichts"):
Diese Methode gibt Text auf der Konsole aus, liefert aber keinen Wert zurück. Deshalb steht `void` als Rückgabetyp und es gibt kein `return`.
Methoden mit Rückgabewert
Wenn deine Methode ein Ergebnis berechnen soll, deklarierst du den passenden Datentyp:
Beim Aufruf speicherst du das Ergebnis in einer Variablen:
Falls du bei Datentypen wie `double` oder `int` noch unsicher bist, schau dir auch mal die Erklärungen auf W3Schools zu Java Datentypen an.
Wie ruft man eine Methode auf?
Einen Methodenaufruf machst du, indem du den Methodennamen und die benötigten Argumente in Klammern schreibst. Bei `static`-Methoden genügt der Name, bei Objektmethoden setzt du einen Punkt davor.
Wichtig: Die Anzahl und Typen der Argumente beim Aufruf müssen mit der Definition übereinstimmen. `addiere(10, 20)` funktioniert, weil zwei `int`-Werte erwartet werden. `addiere("zehn", "zwanzig")` würde einen Compiler-Fehler produzieren.
Praxisbeispiel: Ein einfacher Taschenrechner
Hier ist ein vollständiges, lauffähiges Beispiel mit verschiedenen Methodenarten. Beachte, dass wir Umlaute in Strings und Variablennamen im Code vermeiden, um Fehler zu vermeiden.
Dieses Beispiel zeigt alle wichtigen Kombinationen:
`zeigeMenue()`: Kein Parameter, kein Rückgabewert (`void`)
`addiere()`: Zwei Parameter, Rückgabewert (`double`)
`pruefeObPositiv()`: Ein Parameter, `boolean` als Rückgabe
Was ist Methodenüberladung in Java?
Java unterstützt keine Standardwerte für Parameter (anders als Python oder C++). Stattdessen nutzt du Methodenüberladung - du definierst mehrere Methoden mit demselben Namen, aber unterschiedlichen Parameterlisten:
Java erkennt anhand der Anzahl und Typen der Argumente, welche Version gemeint ist. Dieses Konzept findest du überall in Java-Bibliotheken - zum Beispiel bei `System.out.println()`, das für fast jeden Datentyp überladen ist.
Welche Fehler passieren oft bei Java Methoden?
Fehler 1: Fehlendes return-Statement
Warum? Java erwartet, dass eine Methode mit Rückgabetyp immer einen Wert zurückgibt. Ohne `return` gibt es einen Compiler-Fehler.
Fehler 2: Falsche Parametertypen beim Aufruf
Java ist streng typisiert - die Datentypen beim Aufruf müssen exakt zu den deklarierten Parametern passen.
Fehler 3: void-Methode mit return-Wert
Bei `void`-Methoden darfst du keinen Wert nach `return` schreiben. Ein leeres `return;` für einen vorzeitigen Abbruch ist aber erlaubt.
FAQ: Häufige Fragen zu Java Methoden
Was ist der Unterschied zwischen Parameter und Argument?
Der Parameter ist die Variable in der Methodendefinition (der Platzhalter). Das Argument ist der konkrete Wert beim Aufruf. Bei `public static int addiere(int a, int b)` sind `a` und `b` die Parameter. Bei `addiere(5, 3)` sind `5` und `3` die Argumente.
Kann eine Methode mehrere Werte zurückgeben?
Direkt nicht - eine Methode hat genau einen Rückgabetyp. Aber du kannst ein Array oder ein Objekt zurückgeben, um mehrere Werte zu verpacken:
Wann brauche ich static und wann nicht?
`static` brauchst du für Hilfsmethoden, die keinen Zugriff auf Objektdaten benötigen. In der objektorientierten Programmierung arbeitest du meist mit Instanzmethoden - dann lässt du `static` weg.
Was ist die Signatur einer Methode?
Die Methodensignatur besteht aus dem Methodennamen und den Parametertypen. Sie ist entscheidend für die Methodenüberladung: `addiere(int, int)` und `addiere(double, double)` haben unterschiedliche Signaturen.
Übungstipp: Methoden selbst schreiben
Nimm dir 15 Minuten Zeit und schreibe folgende Methoden in eine Klasse:
`istGerade(int zahl)` - gibt `true` zurück, wenn die Zahl gerade ist
`istVolljaehrig(int alter)` - prüft, ob jemand 18 oder älter ist
`gibInfo()` - gibt deinen Namen auf der Konsole aus (kein Parameter, kein Rückgabewert)
Rufe alle Methoden in `main` auf und teste sie
Lösung für die erste Methode:
Falls du bei Schleifen oder Bedingungen noch Nachholbedarf hast, schau dir die verlinkten Beiträge an.
Fazit
Java Methoden sind der Baustein für sauberen, wartbaren Code. Du kennst jetzt die Grundlagen: Methoden mit und ohne Parameter definieren, Rückgabewerte nutzen, Methoden überladen und typische Anfängerfehler vermeiden. Wenn du beim Üben feststeckst - egal ob in der Ausbildung, im Studium oder im Berufseinstieg - wir bei study-it.education helfen dir mit individueller Online-Nachhilfe. Wir holen dich genau da ab, wo du stehst, und machen dich zum selbstständigen Programmierer.
Kommentare