Generische Methoden

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy. Lektion 55 von 87.

Während generische Klassen dafür sorgen, dass ganze Klassen mit unterschiedlichen Typen arbeiten können, benötigen Sie manchmal nur eine einzige Methode, die generisch ist. Eine generische Methode deklariert ihren eigenen Typparameter, unabhängig von generischen Parametern auf Klassenebene.

Der Typparameter steht in der Methodensignatur vor dem Rückgabetyp:

public class Utility {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

String[] names = {"Alice", "Bob"};
Integer[] numbers = {1, 2, 3};

Utility.printArray(names);    // Funktioniert mit String[]
Utility.printArray(numbers);  // Funktioniert mit Integer[]

Beachte <T>, das zwischen den Modifikatoren und dem Rückgabetyp steht. Dadurch wird T als Typparameter für diese bestimmte Methode deklariert. Der Compiler leitet den tatsächlichen Typ aus den Argumenten ab, die du übergibst.

Generische Methoden können auch den generischen Typ zurückgeben:

public static <T> T getFirst(T[] array) {
    if (array.length > 0) {
        return array[0];
    }
    return null;
}

String first = getFirst(new String[]{"a", "b"});  // Gibt "a" zurück

Bei Bedarf kannst du mehrere Typparameter verwenden:

public static <K, V> void printPair(K key, V value) {
    System.out.println(key + ": " + value);
}

printPair("Age", 25);        // String und Integer
printPair(1, "First");       // Integer und String

Generische Methoden sind besonders nützlich in Hilfsklassen, wenn du flexible, wiederverwendbare Operationen benötigst, ohne eine generische Klasse zu erstellen.

Aufgabe

Einfach

Erstellen wir ein Utility-Toolkit, das die Flexibilität generischer Methoden demonstriert. Du erstellst eine Klasse mit wiederverwendbaren Methoden, die mit jedem Typ funktionieren, und zeigst dabei, wie generische Methoden unabhängig von generischen Klassen existieren können.

Du organisierst deinen Code über zwei Dateien:

ArrayUtils.java: Erstelle eine Utility-Klasse mit generischen Methoden für die Arbeit mit Arrays. Deine Klasse soll drei statische generische Methoden enthalten:
getLast – Eine generische Methode, die ein Array vom Typ T entgegennimmt und das letzte Element zurückgibt. Wenn das Array leer ist, gib null zurück.

swap – Eine generische Methode, die ein Array vom Typ T und zwei ganzzahlige Indizes entgegennimmt und anschließend die Elemente an diesen Positionen vertauscht. Diese Methode gibt nichts zurück.

printWithLabel – Eine generische Methode mit zwei Typparametern K und V. Sie nimmt ein Label vom Typ K und einen Wert vom Typ V entgegen und gibt sie anschließend im Format [label]: [value] aus.
Main.java: Setze deine generischen Methoden ein! Du erhältst vier Eingaben: zwei Wörter (Strings) und zwei Zahlen (Ganzzahlen).
Erstelle zunächst ein String[]-Array, das beide Wörter enthält. Verwende getLast, um das letzte Element abzurufen, und gib Folgendes aus: Last word: [result]

Erstelle als Nächstes ein Integer[]-Array, das beide Zahlen enthält. Rufe swap auf, um die Elemente an den Indizes 0 und 1 zu vertauschen, und gib anschließend Folgendes aus: After swap: [first], [second]

Demonstriere schließlich die generische Methode mit zwei Parametern, indem du printWithLabel zweimal aufrufst:
- Einmal mit dem ersten Wort als Label und der ersten Zahl als Wert
- Einmal mit der ersten Zahl als Label und dem zweiten Wort als Wert

Du erhältst vier Eingaben in dieser Reihenfolge: erstes Wort, zweites Wort, erste Zahl, zweite Zahl.

Beachte, wie jede Methode ihren eigenen Typparameter mit <T> oder <K, V> vor dem Rückgabetyp deklariert. Der Compiler leitet die tatsächlichen Typen aus den Argumenten ab, die du übergibst: Du musst sie beim Aufrufen der Methoden nicht ausdrücklich angeben!

Probier es selbst

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Eingaben lesen
        String firstWord = scanner.nextLine();
        String secondWord = scanner.nextLine();
        int firstNumber = scanner.nextInt();
        int secondNumber = scanner.nextInt();
        
        // TODO: Erstelle ein String[]-Array, das beide Wörter enthält
        
        // TODO: Verwende ArrayUtils.getLast, um das letzte Element zu erhalten
        // Ausgabe: "Last word: [result]"
        
        // TODO: Erstelle ein Integer[]-Array, das beide Zahlen enthält
        
        // TODO: Rufe ArrayUtils.swap auf, um die Elemente an den Indizes 0 und 1 zu tauschen
        // Ausgabe: "After swap: [first], [second]"
        
        // TODO: Rufe ArrayUtils.printWithLabel mit firstWord als label und firstNumber als value auf
        
        // TODO: Rufe ArrayUtils.printWithLabel mit firstNumber als label und secondWord als value auf
    }
}