Zum Inhalt springen

Statische Methoden

Unsere Programme stehen bisher komplett in main. Das wird schnell unübersichtlich – und wer den Primzahltest an drei Stellen braucht, schreibt ihn dreimal. Mit Methoden gibst du einem Stück Code einen Namen und rufst es auf, so oft du willst.

  • eigene statische Methoden schreiben und aufrufen
  • Werte als Parameter übergeben und ein Ergebnis zurückgeben
  • Methoden überladen
  • Methoden einer anderen Klasse aufrufen
Linien.java
package de.drv;
public class Linien {
public static void main(String[] args) {
linie(20);
System.out.println("Java-Schulung");
linie(20);
}
public static void linie(int laenge) {
for (int i = 0; i < laenge; i++) {
System.out.print("-");
}
System.out.println();
}
}
Terminal-Fenster
--------------------
Java-Schulung
--------------------

Die Methode linie steht neben main in der Klasse – nicht darin. Ihr Kopf hat mehrere Teile:

Teil Beispiel Bedeutung
Modifizierer public static vorerst immer so
Rückgabetyp void Was liefert die Methode zurück? void heißt: nichts.
Name linie nach Konvention ein Verb, in lowerCamelCase
Parameter (int laenge) Welche Werte bekommt die Methode beim Aufruf?

Beim Aufruf linie(20) wird der Wert 20 in den Parameter laenge kopiert, dann läuft der Rumpf der Methode. Danach geht es in main mit der nächsten Zeile weiter.

Die meisten Methoden berechnen etwas und geben das Ergebnis zurück:

Primzahlen.java
package de.drv;
public class Primzahlen {
public static void main(String[] args) {
for (int zahl = 2; zahl <= 50; zahl++) {
if (istPrim(zahl)) {
System.out.print(zahl + " ");
}
}
System.out.println();
}
public static boolean istPrim(int zahl) {
if (zahl < 2) {
return false;
}
for (int teiler = 2; teiler * teiler <= zahl; teiler++) {
if (zahl % teiler == 0) {
return false;
}
}
return true;
}
}
Terminal-Fenster
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47
  • Der Rückgabetyp boolean sagt: Diese Methode liefert einen Wahrheitswert.
  • return beendet die Methode sofort und gibt den Wert an den Aufrufer zurück. Deshalb braucht es hier weder break noch eine Hilfsvariable istPrim: Sobald ein Teiler gefunden ist, steht das Ergebnis fest.
  • Der Aufruf istPrim(zahl) steht dort, wo ein boolean gebraucht wird – hier direkt in der Bedingung des if.
  • Vergleiche mit der Lösung zu Primzahlen bis 100 aus dem Kapitel Schleifen: Die Schleife in main ist jetzt viel leichter zu lesen.

Eine Methode mit Rückgabetyp muss auf jedem Weg ein return erreichen. Fehlt es irgendwo, meldet Eclipse: This method must return a result of type boolean.

Kopie.java
package de.drv;
public class Kopie {
public static void main(String[] args) {
int wert = 5;
verdoppeln(wert);
System.out.println("danach: " + wert);
}
public static void verdoppeln(int zahl) {
zahl = zahl * 2;
System.out.println("in der Methode: " + zahl);
}
}
Terminal-Fenster
in der Methode: 10
danach: 5

Beim Aufruf wird der Wert von wert in den Parameter zahl kopiert. Ändert die Methode zahl, bleibt wert in main unberührt. Soll eine Methode ein Ergebnis liefern, gibt sie es mit return zurück.

Auch Variablen, die in einer Methode deklariert werden, gibt es nur dort. Jede Methode hat ihre eigenen Variablen – auch wenn sie gleich heißen.

Mehrere Methoden dürfen denselben Namen haben, wenn sich ihre Parameter unterscheiden – in Anzahl oder Typ:

Maximum.java
package de.drv;
public class Maximum {
public static void main(String[] args) {
System.out.println(max(3, 7));
System.out.println(max(3, 7, 5));
System.out.println(max(2.5, 1.5));
}
public static int max(int a, int b) {
if (a > b) {
return a;
}
return b;
}
public static int max(int a, int b, int c) {
return max(max(a, b), c);
}
public static double max(double a, double b) {
if (a > b) {
return a;
}
return b;
}
}
Terminal-Fenster
7
7
2.5

Java wählt anhand der Argumente beim Aufruf die passende Methode aus. Du kennst das schon: System.out.println gibt es für int, double, String und viele andere Typen – das sind alles überladene Methoden. Auch Math.max ist für int, long, float und double überladen.

Die Methode mit drei Parametern ruft übrigens die mit zwei auf: Methoden dürfen andere Methoden verwenden.

Hilfsmethoden, die man in vielen Programmen braucht, legt man in eine eigene Klasse:

MatheHilfe.java
package de.drv;
public class MatheHilfe {
/**
* Berechnet den größten gemeinsamen Teiler nach Euklid.
*
* @param a erste Zahl
* @param b zweite Zahl
* @return der größte gemeinsame Teiler von a und b
*/
public static int ggt(int a, int b) {
while (b != 0) {
int rest = a % b;
a = b;
b = rest;
}
return a;
}
}
Bruch.java
package de.drv;
public class Bruch {
public static void main(String[] args) {
int zaehler = 48;
int nenner = 18;
int teiler = MatheHilfe.ggt(zaehler, nenner);
System.out.println(zaehler + "/" + nenner + " = "
+ zaehler / teiler + "/" + nenner / teiler);
}
}
Terminal-Fenster
48/18 = 8/3

Aus einer anderen Klasse rufst du eine statische Methode mit Klassenname.methode(…) auf – genau wie Math.max(…) oder Integer.parseInt(…). Das waren schon immer statische Methoden, nur eben fremde.

Der Kommentar über ggt beginnt mit /** – das ist ein Javadoc-Kommentar. Er beschreibt, was die Methode tut, was die Parameter bedeuten (@param) und was zurückkommt (@return). Fahre in Bruch.java mit der Maus über ggt: Eclipse zeigt den Kommentar als Hilfe an – so, wie du es von Math kennst.

Meldung in Eclipse Ursache
This method must return a result of type … nicht jeder Weg durch die Methode endet mit return
Void methods cannot return a value return wert; in einer void-Methode
Type mismatch: cannot convert from void to int Ergebnis einer void-Methode soll gespeichert werden
The method ggt(int, int) … is not applicable for the arguments (int) falsche Anzahl oder falsche Typen beim Aufruf
Cannot make a static reference to the non-static method … static im Methodenkopf vergessen
Unreachable code Anweisung nach einem return
  1. Schreibe eine Methode istSchaltjahr(int jahr), die true oder false liefert. Teste sie in main mit 2024, 2026, 1900 und 2000.

  2. Schreibe eine Methode tageImMonat(int monat, int jahr). Für den Februar soll sie istSchaltjahr aus Aufgabe 1 verwenden.

    Lösung

    Lösung zu Aufgabe 1 und 2. Eine Methode, die nur eine Bedingung prüft, kann das Ergebnis der Bedingung direkt zurückgeben – ohne if.

    Kalender.java
    package de.drv;
    public class Kalender {
    public static void main(String[] args) {
    System.out.println("2024: " + istSchaltjahr(2024));
    System.out.println("2026: " + istSchaltjahr(2026));
    System.out.println("1900: " + istSchaltjahr(1900));
    System.out.println("2000: " + istSchaltjahr(2000));
    System.out.println("Februar 2024: " + tageImMonat(2, 2024));
    System.out.println("Februar 2026: " + tageImMonat(2, 2026));
    System.out.println("April 2026: " + tageImMonat(4, 2026));
    }
    public static boolean istSchaltjahr(int jahr) {
    return (jahr % 4 == 0 && jahr % 100 != 0) || jahr % 400 == 0;
    }
    public static int tageImMonat(int monat, int jahr) {
    return switch (monat) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11 -> 30;
    case 2 -> istSchaltjahr(jahr) ? 29 : 28;
    default -> 0;
    };
    }
    }
  3. Schreibe die Methoden fakultaet(int n), quersumme(long zahl) und ggt(int a, int b). Schreibe dann eine Methode kgv(int a, int b) für das kleinste gemeinsame Vielfache: kgV(a, b) = a / ggT(a, b) · b.

    Lösung

    In kgv wird erst geteilt, dann multipliziert – so bleiben die Zwischenergebnisse klein.

    Rechenhilfen.java
    package de.drv;
    public class Rechenhilfen {
    public static void main(String[] args) {
    System.out.println("5! = " + fakultaet(5));
    System.out.println("20! = " + fakultaet(20));
    System.out.println("Quersumme von 9876: " + quersumme(9876));
    System.out.println("ggT(12, 18) = " + ggt(12, 18));
    System.out.println("kgV(12, 18) = " + kgv(12, 18));
    }
    public static long fakultaet(int n) {
    long ergebnis = 1;
    for (int i = 2; i <= n; i++) {
    ergebnis *= i;
    }
    return ergebnis;
    }
    public static int quersumme(long zahl) {
    zahl = Math.abs(zahl);
    int summe = 0;
    while (zahl > 0) {
    summe += zahl % 10;
    zahl /= 10;
    }
    return summe;
    }
    public static int ggt(int a, int b) {
    while (b != 0) {
    int rest = a % b;
    a = b;
    b = rest;
    }
    return a;
    }
    public static int kgv(int a, int b) {
    return a / ggt(a, b) * b;
    }
    }
  4. Schreibe eine Methode zeile(char zeichen, int anzahl), die ein Zeichen mehrfach in einer Zeile ausgibt. Gib damit ein Dreieck aus:

    *
    **
    ***
    ****
    *****
    Lösung
    Dreieck.java
    package de.drv;
    public class Dreieck {
    public static void main(String[] args) {
    for (int i = 1; i <= 5; i++) {
    zeile('*', i);
    }
    }
    public static void zeile(char zeichen, int anzahl) {
    for (int i = 0; i < anzahl; i++) {
    System.out.print(zeichen);
    }
    System.out.println();
    }
    }
  5. Schreibe die Methoden celsiusInFahrenheit(double celsius) und fahrenheitInCelsius(double fahrenheit). Gib eine Tabelle von −10 °C bis 40 °C in Zehnerschritten aus.

    Lösung
    Temperaturtabelle.java
    package de.drv;
    public class Temperaturtabelle {
    public static void main(String[] args) {
    System.out.println(" °C °F");
    for (int celsius = -10; celsius <= 40; celsius += 10) {
    System.out.printf("%6d %6.1f%n", celsius, celsiusInFahrenheit(celsius));
    }
    System.out.printf("100 °F = %.1f °C%n", fahrenheitInCelsius(100));
    }
    public static double celsiusInFahrenheit(double celsius) {
    return celsius * 9 / 5 + 32;
    }
    public static double fahrenheitInCelsius(double fahrenheit) {
    return (fahrenheit - 32) * 5 / 9;
    }
    }