[JAVA] Punkt 30: Favar generische Methoden

30. Wählen Sie eine generische Methode

• Algorithmische Methoden (binäre Suche und Sortierung) in Sammlungen sind generische Methoden.
• Das Schreiben einer generischen Methode ähnelt dem Schreiben eines generischen Typs. Wenn Sie wie unten in Rohform schreiben, wird eine Warnung angezeigt.

// Uses raw types - unacceptable! (Item 26)
public static Set union(Set s1, Set s2) {
    Set result = new HashSet(s1);
    result.addAll(s2);
    return result;
}

Um die Warnung zu entfernen und typsicher zu machen, schreiben Sie den Typparameter wie folgt zwischen den Methodenmodifikator und den Rückgabewert der Methode.

// Generic method
public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
    Set<E> result = new HashSet<>(s1);
    result.addAll(s2);
    return result;
}

• Möglicherweise benötigen Sie ein Objekt, das unveränderlich ist, sich aber an viele verschiedene Typen anpassen kann. Da Generika durch Löschen implementiert werden, kann ein Objekt alle erforderlichen Typparameter verarbeiten. Es ist jedoch erforderlich, eine statische Factory-Methode zu schreiben, mit der wiederholt ein Objekt des erforderlichen Typs erstellt wird. Dieses Muster wird als generische Singleton-Factory bezeichnet und zum Generieren von Funktionsobjekten (Item42) verwendet.
• Wenn Sie eine Funktion benötigen, die sich selbst zurückgibt, können Sie die Fuction.identity-Methode verwenden, die sich jedoch perfekt zur Erklärung eignet. Daher werde ich sie im Folgenden beschreiben. identity_fnZuunaryoperator<t>Ich bekomme eine Warnung, wenn ich zu wirkeidentity関数は引数Zu変更せずに返却するので、warningZu抑制することができる。

package tryAny.effectiveJava;

import java.util.function.UnaryOperator;

public class GenericsTest7 {
    public static void main(String[] args) {
        String[] strings = { "jute", "hemp", "nylon" };
        UnaryOperator<String> sameString = identityFunction();
        for (String s : strings)
            System.out.println(sameString.apply(s));
        Number[] numbers = { 1, 2.0, 3L };
        UnaryOperator<Number> sameNumber = identityFunction();
        for (Number n : numbers)
            System.out.println(sameNumber.apply(n));

    }

    // Generic singleton factory pattern
    private static UnaryOperator<Object> IDENTITY_FN = (t) -> t;

    @SuppressWarnings("unchecked")
    public static <T> UnaryOperator<T> identityFunction() {
        return (UnaryOperator<T>) IDENTITY_FN;
    }

}

• Wenn ein Typparameter in einer Darstellung definiert wird, die eine eigene Typvariable enthält, wird er als rekursive Grenze bezeichnet. Rekursive Grenzen sind der `` `Vergleichbaren``` Schnittstelle zugeordnet.

public interface Comparable<T> {
    int compareTo(T o);
}

• Die Methoden `Collection Neuanordnung, Sortierung und maximale / minimale Ableitung verwenden Elemente, die `` Comparable``` implementieren. Diese Verfahren erfordern Elemente, die miteinander verglichen werden können und wie folgt ausgedrückt werden.

// Using a recursive type bound to express mutual comparability
public static <E extends Comparable<E>> E max(Collection<E> c);

<e extends comparable<e>>Repräsentiert "jedes Element e vergleichbar mit sich selbst". Das Folgende ist die Max-Methode unter Verwendung rekursiver Grenzen.

package tryAny.effectiveJava;

import java.util.Collection;
import java.util.Objects;

public class GenericsTest8 {
    // Returns max value in a collection - uses recursive type bound
    public static <E extends Comparable<E>> E max(Collection<E> c) {
        if (c.isEmpty())
            throw new IllegalArgumentException("Empty collection");
        E result = null;
        for (E e : c)
            if (result == null || e.compareTo(result) > 0)
                result = Objects.requireNonNull(e);
        return result;
    }

}

Die obige Methode löst eine IllegalArgumentException aus, wenn die Liste leer ist. Eine gute Alternative ist ein Rückgabewert von `Optional <E>`.

• Rekursive Grenzen können komplexer, aber selten sein. Wenn Sie die in diesem Kapitel behandelten Redewendungen, die Verwendung von Platzhaltern (Punkt 31) und den simulierten Selbsttyp (Punkt 2) verstehen, können Sie sich mit den meisten rekursiven Grenzen befassen, mit denen Sie tatsächlich konfrontiert sind.