「java接口泛型上限」java泛型上下限

今天给各位分享java接口泛型上限的知识，其中也会对java泛型上下限进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、Java泛型
• 2、java泛型的规则限制
• 3、java中如何求出泛型的最大值?
• 4、java泛型:设置限定，类型变量T和U是同时实施限定吗？

Java泛型

泛型中? extends T和? super T 差别

? extends T和? super T含有JAVA5.0的新的概念。由于它们的外表导致了很多人误解了它们的用途：

1.?

extends T首先你很容易误解它为继承于T的所有类的集合，这是大错特错的，相信能看下去你一定见过或用过List?

extends T吧？为什么我说理解成一个集合是错呢？如果理解成一个集合那为什么不用ListT来表示？所以?

extends

T不是一个集合，而是T的某一种子类的意思，记住是一种，单一的一种，问题来了，由于连哪一种都不确定，带来了不确定性，所以是不可能通过

add（）来加入元素。你或许还觉得为什么add(T)不行?因为? extends

T是T的某种子类，能放入子类的容器不一定放入超类，也就是没可能放入T。

2.? super T这里比较容易使用，没? extends T这么多限制，这里的意思是，以T类为下限的某种类，简单地说就是T类的超类。但为什么add(T)可以呢？因为能放入某一类的容器一定可以放入其子类，多态的概念。

擦除

也

许泛型最具挑战性的方面是擦除（erasure），这是 Java

语言中泛型实现的底层技术。擦除意味着编译器在生成类文件时基本上会抛开参数化类的大量类型信息。编译器用它的强制类型转换生成代码，就像程序员在泛型出

现之前手工所做的一样。区别在于，编译器开始已经验证了大量如果没有泛型就不会验证的类型安全约束。

通过擦除实现泛型的含意是很重要的，并

且初看也是混乱的。尽管不能将ListInteger 赋给ListNumber，因为它们是不同的类型，但是

ListInteger 和 ListNumber 类型的变量是相同的类！要明白这一点，请评价下面的代码：

new ListNumber().getClass() == new ListInteger().getClass()

编译器只为 List 生成一个类。当生成了 List 的字节码时，将很少剩下其类型参数的的跟踪。

当

生成泛型类的字节码时，编译器用类型参数的擦除替换类型参数。对于无限制类型参数（V），它的擦除是

Object。对于上限类型参数（K extends ComparableK），它的擦除是其上限（在本例中是

Comparable）的擦除。对于具有多个限制的类型参数，使用其最左限制的擦除。

如果检查生成的字节码，您无法说出 ListInteger 和 ListString 的代码之间的区别。类型限制 T 在字节码中被 T 的上限所取代，该上限一般是 Object。

多重限制

一个类型参数可以具有多个限制。当您想要约束一个类型参数比如说同时为 Comparable 和 Serializable 时，这将很有用。多重限制的语法是用“与”符号分隔限制：

class CT extends Comparable? super TSerializable

通配符类型可以具有单个限制 —— 上限或者下限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。

类型形参和类型实参

在

参数化类的定义中，占位符名称（比如 CollectionV 中的 V）叫做类型形参（type

parameter），它们类似于方法定义中的形式参数。在参数化类的变量的声明中，声明中指定的类型值叫做类型实参（type

argument），它们类似于方法调用中的实际参数。但是实际中二者一般都通称为“类型参数”。所以给出定义：

interface CollectionV { ... }

和声明：

CollectionString cs = new HashSetString();

那么，名称 V（它可用于整个 Collection 接口体内）叫做一个类型形参。在 cs 的声明中，String 的两次使用都是类型实参（一次用于 CollectionV，另一次用于 HashSetV）。

关

于何时可以使用类型形参，存在一些限制。大多数时候，可以在能够使用实际类型定义的任何地方使用类型形参。但是有例外情况。不能使用它们创建对象或数组，

并且不能将它们用于静态上下文中或者处理异常的上下文中。还不能将它们用作父类型（class FooT extends

T），不能用于 instanceof 表达式中，不能用作类常量。

类似地，关于可以使用哪些类型作为类型实参，也存在一些限制。类型实参

必须是引用类型（不是基本类型）、通配符、类型参数，或者其他参数化类型的实例化。所以您可以定义

ListString（引用类型）、List?（通配符）或者

ListList?（其他参数化类型的实例化）。在带有类型形参 T 的参数化类型的定义中，您也可以声明

ListT（类型形参）。

java泛型的规则限制

1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。

2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

3、泛型的类型参数可以有多个。

4、泛型的参数类型可以使用extends语句，例如T extends superclass。习惯上称为“有界类型”。

5、泛型的参数类型还可以是通配符类型。例如Class? classType = Class.forName("java.lang.String");

泛型还有接口、方法等等，内容很多，需要花费一番功夫才能理解掌握并熟练应用。在此给出我曾经了解泛型时候写出的两个例子（根据看的印象写的），实现同样的功能，一个使用了泛型，一个没有使用，通过对比，可以很快学会泛型的应用，学会这个基本上学会了泛型70%的内容。

例子一：使用了泛型 class GenT {    private T ob; // 定义泛型成员变量    public Gen(T ob) {        this.ob = ob;    }    public T getOb() {        return ob;    }    public void setOb(T ob) {        this.ob = ob;    }    public void showType() {        System.out.println("T的实际类型是: " + ob.getClass().getName());    }}public class GenDemo {    public static void main(String[] args) {        // 定义泛型类Gen的一个Integer版本        GenInteger intOb = new GenInteger(88);        intOb.showType();        int i = intOb.getOb();        System.out.println("value= " + i);        System.out.println("----------------------------------");        // 定义泛型类Gen的一个String版本        GenString strOb = new GenString("Hello Gen!");        strOb.showType();        String s = strOb.getOb();        System.out.println("value= " + s);    }}例子二：没有使用泛型 class Gen2 {    private Object ob; // 定义一个通用类型成员    public Gen2(Object ob) {        this.ob = ob;    }    public Object getOb() {        return ob;    }    public void setOb(Object ob) {        this.ob = ob;    }    public void showTyep() {        System.out.println("T的实际类型是: " + ob.getClass().getName());    }}public class GenDemo2 {    public static void main(String[] args) {        // 定义类Gen2的一个Integer版本        Gen2 intOb = new Gen2(new Integer(88));        intOb.showTyep();        int i = (Integer) intOb.getOb();        System.out.println("value= " + i);        System.out.println("---------------------------------");        // 定义类Gen2的一个String版本        Gen2 strOb = new Gen2("Hello Gen!");        strOb.showTyep();        String s = (String) strOb.getOb();        System.out.println("value= " + s);    }}运行结果：

两个例子运行Demo结果是相同的,控制台输出结果如下：

T的实际类型是:

java.lang.Integer

value= 88

----------------------------------

T的实际类型是: java.lang.String

value= Hello Gen!

Process finished with exit code 0

看明白这个，以后基本的泛型应用和代码阅读就不成问题了。

java中如何求出泛型的最大值?

用擂台法压，定义一个中间变量maxStu等于stu1的年龄值，

拿maxStu和stu2年龄值比，如果stu2大，maxStu等于大的stu2，否则maxStu不变。

stu3和maxStu比，如果stu3大，maxStu等于大的stu3，否则maxStu不变。

一个for循环比较集合中的年龄属性。

java泛型:设置限定，类型变量T和U是同时实施限定吗？

不是，在Java中T, U表示指定了2个泛型，T、U

如果要对泛型限制：

如T, U extends Comparable

表示泛型U限定了必须为 Comparable 的子类，而T没有

如T extends Comparable, U extends Comparable

表示泛型T和U都限定为 Comparable 的子类

注由于 Comparable 是个接口，因此“ Comparable 的子类 ” 正确的描述为实现了 Comparable 接口的类

T, U extends Comparable Serializable表示：

T 为任意类型，没有限制

U 有限制，为现实了Comparable 和 Serializable 接口的类

关于java接口泛型上限和java泛型上下限的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。