Java Methoden definieren und aufrufen – Anleitung für Einsteiger

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:

1. Wiederverwendbarkeit - Code einmal schreiben, überall nutzen

2. Übersichtlichkeit - Komplexe Programme werden in kleine, verständliche Teile zerlegt

3. 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:

Rueckgabetyp methodenName(parameter1, parameter2) {
  // Methodenkoerper - hier steht der Code
  return rueckgabewert;
}

Hier ist ein einfaches, lauffähiges Beispiel:

public class MethodenBeispiel {

  public static void main(String[] args) {
    int ergebnis = addiere(5, 3);
    System.out.println("Ergebnis: " + ergebnis);
  }

  public static int addiere(int a, int b) {
    return a + b;
  }
}

Lass uns die Bestandteile im Detail anschauen:

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"):

public static void gruesse(String name) {
  System.out.println("Hallo " + name + ", willkommen bei Java!");
}

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:

public static double berechneMehrwertsteuer(double betrag) {
  double steuersatz = 0.19; // 19% in Deutschland
  return betrag * steuersatz;
}

Beim Aufruf speicherst du das Ergebnis in einer Variablen:

double steuer = berechneMehrwertsteuer(100.0);
System.out.println("Mehrwertsteuer: " + steuer + " Euro");
// Ausgabe: Mehrwertsteuer: 19.0 Euro

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.

public class MethodenDemo {

  public static void main(String[] args) {
    sagHallo(); // ohne Parameter
    gruessePerson("Anna"); // mit einem Parameter
    int summe = addiere(10, 20); // Ergebnis in Variable speichern
    System.out.println(summe); // gibt 30 aus
  }

  public static void sagHallo() {
    System.out.println("Hallo!");
  }

  public static void gruessePerson(String name) {
    System.out.println("Hallo " + name + "!");
  }

  public static int addiere(int x, int y) {
    return x + y;
  }
}

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.

public class Taschenrechner {

  public static void main(String[] args) {
    zeigeMenue();

    double ergebnisAddition = addiere(15.5, 4.5);
    System.out.println("Addition: " + ergebnisAddition);

    double ergebnisSubtraktion = subtrahiere(20.0, 7.5);
    System.out.println("Subtraktion: " + ergebnisSubtraktion);

    boolean positiv = pruefeObPositiv(ergebnisAddition);
    System.out.println("Ergebnis positiv? " + positiv);
  }

  // Ohne Parameter, ohne Rueckgabe
  public static void zeigeMenue() {
    System.out.println("=== Taschenrechner ===");
    System.out.println("Verfuegbare Operationen:");
    System.out.println("- Addition");
    System.out.println("- Subtraktion");
  }

  // Zwei Parameter, mit Rueckgabe
  public static double addiere(double a, double b) {
    return a + b;
  }

  public static double subtrahiere(double a, double b) {
    return a - b;
  }

  // Ein Parameter, boolean als Rueckgabe
  public static boolean pruefeObPositiv(double wert) {
    return wert > 0;
  }
}

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:

public class Begruesung {

  public static void main(String[] args) {
    gruesse(); // "Hallo!"
    gruesse("Max"); // "Hallo Max!"
    gruesse("Max", "Morgen"); // "Guten Morgen Max!"
  }

  public static void gruesse() {
    System.out.println("Hallo!");
  }

  public static void gruesse(String name) {
    System.out.println("Hallo " + name + "!");
  }

  public static void gruesse(String name, String zeit) {
    System.out.println("Guten " + zeit + " " + name + "!");
  }
}

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

// FALSCH - Compiler-Fehler!
public static int berechneAlter() {
  int alter = 25;
  // return fehlt!
}

// RICHTIG
public static int berechneAlter() {
  int alter = 25;
  return alter;
}

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

// FALSCH - String statt int
addiere("zehn", "zwanzig");

// RICHTIG
addiere(10, 20);

Java ist streng typisiert - die Datentypen beim Aufruf müssen exakt zu den deklarierten Parametern passen.

Fehler 3: void-Methode mit return-Wert

// FALSCH
public static void gruesse() {
  return "Hallo"; // Compiler-Fehler!
}

// RICHTIG
public static void gruesse() {
  System.out.println("Hallo");
}

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:

public static int[] gibMinMax(int[] zahlen) {
  int min = zahlen[0];
  int max = zahlen[0];
  for (int i = 1; i < zahlen.length; i++) {
  if (zahlen[i] < min) min = zahlen[i];
  if (zahlen[i] > max) max = zahlen[i];
  }
  return new int[]{min, max};
}

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.

// Instanzmethode
public int berechneFlaeche() {
  return laenge * breite;
}

// Aufruf ueber ein Objekt
Rechteck r = new Rechteck(5, 3);

int flaeche = r.berechneFlaeche();

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:

1. `istGerade(int zahl)` - gibt `true` zurück, wenn die Zahl gerade ist

2. `istVolljaehrig(int alter)` - prüft, ob jemand 18 oder älter ist

3. `gibInfo()` - gibt deinen Namen auf der Konsole aus (kein Parameter, kein Rückgabewert)

4. Rufe alle Methoden in `main` auf und teste sie

Lösung für die erste Methode:

public static boolean istGerade(int zahl) {
  return zahl % 2 == 0; // Modulo: Rest bei Division durch 2
}

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.