So verwenden Sie Platzhalter für obere und untere Grenzen für Java-Generika

Obergrenze

Die Obergrenze von Generika gibt an, dass der Typparameter eine Unterklasse einer bestimmten Klasse sein oder eine bestimmte Schnittstelle implementieren muss. Seine Syntax lautet T erweitert B, wobei T der generische Typparameter und B der Typ mit der Obergrenze ist. Der folgende Code zeigt beispielsweise eine generische Klasse Box, deren Typparameter T Number oder ihre Unterklasse sein muss: T extends B，其中T是泛型类型参数，B是上界类型。例如，下面的代码展示了一个泛型类 Box，它的类型参数T必须是 Number 或其子类：

public class Box<T extends Number> {
    private T value;
    public Box(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
}

在上面的代码中，我们使用了 extends 关键字来指定泛型类型参数的上界类型，这意味着泛型类型参数必须是 Number 或其子类。这样，我们就可以使用 Box 类来存储 Integer、Double、Float 等类型的值，因为它们都是 Number 的子类。另外，通过使用泛型的上界，我们可以确保 Box 类的实例中只存储 Number 类型的值，避免了类型转换异常的风险。

在使用泛型的时候，如果我们传入一个类型不符合上界限制的参数，则会在编译时发生错误，例如：

Box<String> box = new Box<>("Hello World");    // 编译错误：String 不是 Number 的子类

下界

泛型的下界指定了类型参数必须是某个类的超类或者是某个接口的实现类。它的语法形式为 T super B，其中T是泛型类型参数，B是下界类型。下面是一个示例，展示了一个泛型类 Box，它的类型参数T必须是 Object 或其超类：

public class Box<T super Object> {
    private T value;
    public Box(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
}

在上面的代码中，我们使用了 super 关键字来指定泛型类型参数的下界类型，这意味着泛型类型参数必须是 Object 或其超类。这样，我们就可以使用 Box 类来存储 Object、String、Integer、Double 等类型的值，因为它们都是 Object 的子类。另外，通过使用泛型的下界，我们可以确保 Box 类的实例中存储的值都是 Object 类型，避免了类型转换异常的风险。

在使用泛型的时候，如果我们传入一个类型不符合下界限制的参数，则会在编译时发生错误，例如：

Box<Integer> box = new Box<>(123);    // 编译错误：Integer 不是 Object 的超类

上下界通配符

有时候，我们需要在泛型中同时使用上界和下界的限制，此时可以使用通配符 ? 来表示未知类型。例如，下面的代码展示了一个泛型方法 copy，它可以将一个数组的元素复制到另一个数组中：

public static <T> void copy(List<? extends T> src, List<? super T> dest) {
    for (T t : src) {
        dest.add(t);
    }
}

在上面的代码中，我们使用了通配符 ? 来表示未知类型，它可以同时满足 src 参数是 T 类型或其子类，dest 参数是 Trrreee

Im obigen Code verwenden wir The extends Das Schlüsselwort wird verwendet, um den Obergrenzentyp des generischen Typparameters anzugeben, was bedeutet, dass der generische Typparameter Number oder seine Unterklasse sein muss. Auf diese Weise können wir die Klasse Box verwenden, um Werte von Typen wie Integer, Double, Float zu speichern. code> usw., weil sie alle Unterklassen von <code>Number sind. Darüber hinaus können wir durch die Verwendung der Obergrenze von Generika sicherstellen, dass nur Werte vom Typ Number in Instanzen der Klasse Box gespeichert werden, wodurch das Typrisiko vermieden wird Konvertierungsausnahmen. 🎜🎜Wenn wir bei der Verwendung von Generika einen Parameter übergeben, dessen Typ die Obergrenze nicht erreicht, tritt beim Kompilieren ein Fehler auf, zum Beispiel: 🎜rrreee🎜Untergrenze🎜🎜Die Untergrenze von Generika gibt an, dass der Typparameter muss sei eine bestimmte Oberklasse einer Klasse oder die Implementierungsklasse einer Schnittstelle. Seine Syntax ist T super B, wobei T der generische Typparameter und B der Typ mit der unteren Grenze ist. Hier ist ein Beispiel, das eine generische Klasse Box zeigt, deren Typparameter T Object oder seine Superklasse sein muss: 🎜rrreee🎜Im obigen Code haben wir den super Das Schlüsselwort code> wird verwendet, um den unteren Grenztyp des generischen Typparameters anzugeben, was bedeutet, dass der generische Typparameter <code>Object oder seine Oberklasse sein muss. Auf diese Weise können wir die Klasse Box verwenden, um Object, String, Integer, Double zu speichern code> und andere Arten von Werten, da sie alle Unterklassen von Object sind. Darüber hinaus können wir durch die Verwendung der Untergrenze von Generika sicherstellen, dass die in Instanzen der Klasse Box gespeicherten Werte alle vom Typ Object sind, wodurch das Risiko vermieden wird Ausnahmen bei der Typkonvertierung. 🎜🎜Wenn wir bei der Verwendung von Generika einen Parameter übergeben, dessen Typ nicht der Untergrenze entspricht, tritt beim Kompilieren ein Fehler auf, zum Beispiel: 🎜rrreee🎜Platzhalter für Ober- und Untergrenze🎜🎜Manchmal müssen wir Generika verwenden Gleichzeitig kann das Platzhalterzeichen ? unter Verwendung von Ober- und Untergrenzen zur Darstellung unbekannter Typen verwendet werden. Der folgende Code zeigt beispielsweise eine generische Methode copy, die die Elemente eines Arrays in ein anderes Array kopiert: 🎜rrreee🎜Im obigen Code haben wir das Platzhalterzeichen ?verwendet > um einen unbekannten Typ darzustellen, kann sowohl der Parameter src vom Typ T oder dessen Unterklasse als auch der Parameter dest vom Typ erfüllt sein T Einschränkungen für einen Typ oder seine Superklasse. Auf diese Weise können wir Elemente beliebigen Typs in eine andere Liste kopieren. Durch die Verwendung von Platzhaltern für Ober- und Untergrenzen können wir generische Methoden flexibler definieren und gleichzeitig die Typsicherheit gewährleisten. 🎜

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Platzhalter für obere und untere Grenzen für Java-Generika. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!