EMZETT.
Login

Emzett Wiki

Java: Methoden

Properties1
tagsprogrammiersprachen, java

5 Min. Lesezeit

Kurz: Eine Methode ist ein benannter Codeblock, den du aufrufen kannst. Sie vermeidet Wiederholungen und gliedert das Programm.

Teil des Kurses Java

Kapitel 8 von 22 im Kurs Java (Abschnitt „Methoden und Datenstrukturen“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Eine Methode ist ein benannter Codeblock, den du aufrufen kannst. Sie vermeidet Wiederholungen und gliedert das Programm.

public class Methoden {
    static int addiere(int a, int b) {
        return a + b;
    }
 
    static void gruss(String name) {
        System.out.println("Hallo " + name + "!");
    }
 
    static boolean istGerade(int n) {
        return n % 2 == 0;
    }
 
    public static void main(String[] args) {
        System.out.println(addiere(3, 4));
        gruss("Mia");
        System.out.println(istGerade(10) + " " + istGerade(7));
        int ergebnis = addiere(addiere(1, 2), 3);
        System.out.println(ergebnis);
    }
}

Ausgabe:

7
Hallo Mia!
true false
6

Aufbau: Sichtbarkeit [static] Rückgabetyp name(Parameter) { Rumpf }. Methoden mit Rückgabewert enden mit return; void heißt “gibt nichts zurück”.

Parameter werden kopiert

Java übergibt alles per Wert: Primitive Werte werden kopiert. Bei Objekten wird der Verweis kopiert. Die Methode kann also das Objekt verändern, aber nicht die Variable des Aufrufers neu setzen:

import java.util.*;
 
public class Wert {
    static void erhoehe(int x) { x++; }                       // ändert nur die Kopie
    static void anhaengen(List<String> l) { l.add("neu"); }   // ändert das gemeinsame Objekt
    static void ersetzen(List<String> l) { l = new ArrayList<>(); l.add("woanders"); }  // wirkt nicht nach außen
 
    public static void main(String[] args) {
        int a = 5;
        erhoehe(a);
        List<String> liste = new ArrayList<>(List.of("alt"));
        anhaengen(liste);
        ersetzen(liste);
        System.out.println(a + " " + liste);
    }
}

Ausgabe:

5 [alt, neu]

Überladen (Overloading)

Mehrere Methoden dürfen denselben Namen haben, wenn sich ihre Parameter unterscheiden:

public class Ueberladen {
    static int flaeche(int seite) { return seite * seite; }
    static int flaeche(int breite, int hoehe) { return breite * hoehe; }
    static double flaeche(double radius) { return Math.PI * radius * radius; }
 
    public static void main(String[] args) {
        System.out.println(flaeche(4) + " " + flaeche(3, 5) + " " + String.format("%.2f", flaeche(1.0)));
        System.out.println(String.valueOf(42) + String.valueOf(true) + String.valueOf('c'));   // aus der Standardbibliothek
    }
}

Ausgabe:

16 15 3.14
42truec

Der Rückgabetyp allein reicht zum Überladen nicht.

Varargs

Mit ... nimmt eine Methode beliebig viele Argumente:

public class Variabel {
    static int summe(int... zahlen) {
        int s = 0;
        for (int z : zahlen) s += z;
        return s;
    }
    static String verbinde(String trenner, String... teile) {
        return String.join(trenner, teile);
    }
    public static void main(String[] args) {
        System.out.println(summe() + " " + summe(5) + " " + summe(1, 2, 3, 4));
        System.out.println(verbinde(" - ", "a", "b", "c"));
    }
}

Ausgabe:

0 5 10
a - b - c

Rekursion

public class Rekursion {
    static long fakultaet(int n) {
        if (n <= 1) return 1;                    // Abbruchbedingung
        return n * fakultaet(n - 1);
    }
    static int fib(int n) { return n < 2 ? n : fib(n - 1) + fib(n - 2); }
    static int ggt(int a, int b) { return b == 0 ? a : ggt(b, a % b); }
 
    public static void main(String[] args) {
        System.out.println(fakultaet(10) + " " + fakultaet(20));
        System.out.println(fib(20) + " " + ggt(48, 18));
    }
}

Ausgabe:

3628800 2432902008176640000
6765 6

Zu tiefe Rekursion löst einen StackOverflowError aus. Bei großen Tiefen nimmst du eine Schleife.

static oder nicht?

  • static-Methoden gehören zur Klasse und werden ohne Objekt aufgerufen (Math.sqrt(4)).
  • Nicht-statische Methoden gehören zu einem Objekt und arbeiten mit dessen Daten (siehe Kapitel Klassen).
  • Aus main (static) kannst du nur andere static-Methoden direkt aufrufen.

Gute Methoden

  • Eine Methode, eine Aufgabe
  • Sprechender Name als Verb: berechneSumme, istGueltig
  • Wenige Parameter (höchstens drei bis vier)
  • Prüfe Eingaben am Anfang und wirf bei Fehlern passende Ausnahmen
  • Dokumentiere mit Javadoc:
public class Doku {
    /**
     * Berechnet den Bruttopreis.
     *
     * @param netto  Nettopreis in Euro, nicht negativ
     * @param mwst   Steuersatz als Anteil, z. B. 0.19
     * @return der Bruttopreis
     * @throws IllegalArgumentException wenn netto negativ ist
     */
    static double brutto(double netto, double mwst) {
        if (netto < 0) throw new IllegalArgumentException("netto < 0");
        return netto * (1 + mwst);
    }
    public static void main(String[] args) {
        System.out.printf("%.2f%n", brutto(100, 0.19));
    }
}

Ausgabe:

119.00

Merke

  • static Rückgabetyp name(Parameter) { ... return wert; }
  • Parameter werden kopiert; bei Objekten der Verweis
  • Überladen: gleicher Name, andere Parameter
  • Varargs int... zahlen; Rekursion braucht eine Abbruchbedingung
  • Eine Methode, eine Aufgabe; mit Javadoc dokumentieren

Übungsaufgabe

Schreibe istPrimzahl(int), ggt(int, int) und potenz(int, int) und teste sie.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Schleifen

Weiter: Arrays

Alle Kapitel: Java im Überblick

Graphansicht

Backlinks