Java Academy · Lektion

Rückgabewerte und Überladen

Lernen Sie return-Anweisungen, vorzeitige Rückgaben und das Überladen von Methoden nach Parameteranzahl und -typ kennen. Enthalten sind Demos zu varargs und zur Auswahl überladener Methoden.

Rückgabewerte und Überladen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 3 Lektionen.

Überblick

Ziel: Beherrschen Sie return-Anweisungen und das Überladen von Methoden. Sie sehen frühe Rückgaben (Guard Clauses), Überladungen nach Anzahl und Typ sowie eine kurze Varargs-Demo.

Rückgabe & Guard Clause

Return gibt einen Wert an den Aufrufer zurück und beendet die Methode. Guard Clauses (frühe Rückgaben) halten den Code einfach, indem sie Sonderfälle zuerst behandeln.

public class Main {
  // Double an integer and return the result
  static int doubleIt(int x) {
    return x * 2;
  }

  // Return a label using a simple early-return pattern (guard clause)
  static String parity(int n) {
    if (n % 2 == 0) {
      return "even";   // early return ends the method here
    }
    return "odd";       // otherwise this path executes
  }

  public static void main(String[] args) {
    System.out.println("doubleIt(7) = " + doubleIt(7));
    System.out.println("parity(10) = " + parity(10));
    System.out.println("parity(11) = " + parity(11));
  }
}

Mehrere Rückgaben

Eine frühe Rückgabe bei ungültigen Eingaben vermeidet tiefe Verschachtelungen. Hier wird bei einer Division durch null als einfache Richtlinie 0 zurückgegeben; später lernen Sie Ausnahmen kennen.

public class Main {
  // Safe integer division with simple validation
  static int safeDiv(int num, int den) {
    if (den == 0) {
      return 0; // simple policy: return 0 if denominator is zero
    }
    return num / den; // normal path
  }

  public static void main(String[] args) {
    System.out.println("safeDiv(8, 2) = " + safeDiv(8, 2));
    System.out.println("safeDiv(5, 0) = " + safeDiv(5, 0));
  }
}

Überladen: Anzahl

Überladen bedeutet: gleicher Methodenname, unterschiedliche Parameterliste. Eine Änderung der Parameteranzahl ist eine gültige Überladung.

public class Main {
  // Overload 1: max of two numbers
  static int max(int a, int b) {
    return (a > b) ? a : b;
  }
  // Overload 2: max of three numbers (different parameter COUNT)
  static int max(int a, int b, int c) {
    int m = (a > b) ? a : b;
    return (m > c) ? m : c;
  }
  public static void main(String[] args) {
    System.out.println("max(3, 9) = " + max(3, 9));
    System.out.println("max(3, 9, 5) = " + max(3, 9, 5));
  }
}

Überladen: Typen

Das Überladen nach Typ ermöglicht es Ihnen, denselben Namen für verwandte Operationen wiederzuverwenden. Gemischte numerische Argumente werden an die spezifischste passende Signatur angepasst.

public class Main {
  // Overload for integers
  static int add(int a, int b) {
    return a + b;
  }
  // Overload for doubles (different parameter TYPES)
  static double add(double a, double b) {
    return a + b;
  }
  public static void main(String[] args) {
    System.out.println("add(2, 3) = " + add(2, 3));           // calls int version
    System.out.println("add(2.5, 3.5) = " + add(2.5, 3.5));   // calls double version
    System.out.println("add(2, 3.5) = " + add(2, 3.5));       // numeric promotion chooses double version
  }
}

Überladen: Varargs

Varargs (int...) sammelt null oder mehr Argumente. Die Überladungsauflösung bevorzugt eine exakt passende Variante ohne Varargs, wenn eine solche vorhanden ist.

public class Main {
  // Specific overload for two ints
  static int sum(int a, int b) {
    return a + b;
  }
  // Varargs overload for many ints
  static int sum(int... nums) {
    int s = 0;
    for (int i = 0; i < nums.length; i = i + 1) s = s + nums[i];
    return s;
  }
  public static void main(String[] args) {
    // Exact match beats varargs
    System.out.println("sum(4, 5) = " + sum(4, 5));           // picks (int,int)
    System.out.println("sum(1,2,3,4) = " + sum(1, 2, 3, 4));  // uses varargs
  }
}

Prüfung des Überladens

Kurzprüfung: Welches Paar kann in einer Klasse eine gültige Überladung bilden?

Zusammenfassung & Nächstes

Zusammenfassung: Sie haben return und frühe Rückgaben verwendet, gültige Überladungen nach Anzahl und Typ erstellt und Varargs geübt. Als Nächstes geht es um den Gültigkeitsbereich und die Lebensdauer von Variablen und Methoden.

Häufig gestellte Fragen

Ist die Lektion „Rückgabewerte und Überladen“ kostenlos?

Ja — der vollständige Text von „Rückgabewerte und Überladen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Rückgabewerte und Überladen“?

Lernen Sie return-Anweisungen, vorzeitige Rückgaben und das Überladen von Methoden nach Parameteranzahl und -typ kennen. Enthalten sind Demos zu varargs und zur Auswahl überladener Methoden. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Rückgabewerte und Überladen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy