java - 理解java中的有界泛型。重点是什么？

Question

我试图理解有界类型，但不太明白它们的意义。

有一个example提供此用例的有界泛型:

public class NaturalNumber<T extends Integer> {

    private T n;

    public NaturalNumber(T n)  { this.n = n; }

    public boolean isEven() {
        return n.intValue() % 2 == 0;
    }

    // ...
}

如果您要限制可以作为参数化类型的类，为什么不完全忘记参数化并拥有:

public class NaturalNumber {

    private Integer n;

    public NaturalNumber(Integer n)  { this.n = n; }

    public boolean isEven() {
        return n.intValue() % 2 == 0;
    }

    // ...
}

然后任何扩展/实现 Integer 的类都可以与此类一起使用。

另外，还有一个附带问题:当 Java Integer 类是 Final 类时，T 如何在第一个示例中扩展 Integer？

Answer 1

How is T extending Integer in the first example when the Java Integer class is final?

T只能是Integer ，所以这里的“延伸”纯粹是象征性的。 (我从旁注开始，因为事实上，这是一个泛型毫无用处的例子。我真的不知道为什么教程认为这是一个内容丰富的演示。事实并非如此。)

<小时/>

假设T extends Number :

class Example<T extends Number> {
    private T num;

    void setNum(T num) { this.num = num; }
    T    getNum()      { return num;     }
}

所以一般来说，泛型的要点是你可以这样做:

Example<Integer> e = new Example<>();
e.setNum( Integer.valueOf(10) );
// returning num as Integer
Integer i = e.getNum();
// and this won't compile
e.setNum( Double.valueOf(10.0) );

泛型是 parametric polymorphism 的一种形式，本质上它让我们能够重用涉及所涉及类型的通用代码。

那么界限有什么意义呢？

这里的界限意味着 T必须是Number或 Number 的子类，所以我们可以调用 Number 的方法在 T 的实例上。 Number不幸的是，它本身通常是一个无用的基类(因为精度问题)，但它可能让我们做一些有趣的事情，例如:

class Example<T extends Number> extends Number {
//                              ^^^^^^^^^^^^^^
    ...
    @Override
    public int intValue() {
        return num.intValue();
    }
    // and so on
}

例如，更常见的是查找 T extends Comparable<T>这让我们可以用 T 做一些更有意义的事情。我们可能有这样的东西:

// T must be a subclass of Number
// AND implement Comparable
Example<T extends Number & Comparable<T>>
        implements Comparable<Example<T>> {
    ...
    @Override
    public int compareTo(Example<T> that) {
        return this.num.compareTo(that.num);
    }
}

现在我们的Example类有一个自然的顺序。即使我们不知道是什么，我们也可以对其进行排序 T实际上是在类体内。

如果我们结合这些概念，那么:

• 泛型允许“外部世界”指定实际类型，并且
• 边界允许“内部世界”使用共性，

我们可以构建如下结构:

static <T extends Comparable<T>> T min(T a, T b) {
    return (a.compareTo(b) < 0) ? a : b;
}

{
    // returns "x"
    String s = min("x", "z");
    // returns -1
    Integer i = min(1, -1);
}