「java泛型上限和下线」java泛型上下边界

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

本文目录一览：

• 1、java泛型中的下限
• 2、Java 泛型 Class
• 3、java泛型
• 4、java 泛型问题
• 5、怎么区别java泛型的上限和下限？？

java泛型中的下限

这个要比较起来说明的，设置你所谓的上限下限是在参数声明的时候，其他情况不行

1 首先确定的泛型在new时只能new确定的泛型，且其可以使用add方法添加此类型和其子类的实例

2 如上面说的，这样类型就被定义的死死的，不利于多态，所以才有了? extends Xxx这种形式，表示list可以为泛型Xxx或者Xxx的子类型，但是这样也有弊端，就是你不能再用add方法，换句话说这样的泛型只能用来做参数传递读取里面的值，无法添加。

3 那么我还想add怎么办，于是有了? super Xxx的形式，这样在作为参数传递时候可以传递Xxx以及Xxx父类型的list进来，但是add只能是Xxx或者Xxx的子类（这个到哪都一样，没什么可说的），至于具体怎么用看你的需求了，好处坏处是参考着来的，谁也没比谁好到哪去，只能说各有各的方式，基本算回答你的问题了，下面的算额外附赠，望采纳

4 List? 任何类型可以传递进来，但不能再add

5 ListObject 只能是类型Object，可以add

6 ?和? extends Object意义相同

Java 泛型 Class

泛型中? 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泛型

java泛型是1.5引进的一个新概念.

本题对于"? super T"和"? extends T",我从书上摘个经典的例子给你看看,如果不能理解,那么你就参考以下书籍慢慢体会,循序渐进!

"? super T"和"? extends T",都是java泛型通配符,而用法又有区别,

还有super 和extends 不是java类关系中的超类和继承的意思,他是通配符的下限和上限限制.

下面看一个通配符得高级用法:

在这一部分，我们来考虑一些通配符得高级用法。我们已经看到了上限通配符在从一个数据结构中进行读取的几个例子。现在考虑相反的情况，一个只写的数据结构。

接口Sink是这种情况的一个简单例子。

interface SinkT {

void flush(T t);

}

我们可以想象他被如下面的代码一样使用。方法writeAll() 被设计来把集合coll的所有元素flush到sink snk，并且返回最后一个flush的元素。

public static T T writeAll(CollectionT coll, SinkT snk) {

T last = null;

for (T t : coll) {

last = t;

snk.flush(last);

}

return last;

}

SinkObject s;

CollectionString cs;

String str = writeAll(cs, s); // 非法的调用!!

像上面所写，writeAll() 的调用是非法的，因为没有有效的类型参数可以被推断出来。String 或 Object都不是T的合适的类型，因为Collection的元素和 Sink的元素必须是同样的类型。

我们可以解决这个问题，通过使用通配符来修改writeAll()的方法签名，如下：

T T writeAll(Collection? extends T coll, SinkT snk) { … }

String str = writeAll(cs, s); //可以调用但是返回值类型错误

这个调用现在是合法的，但是赋值产生错误，因为推断出的返回值类型是 Object因为T 匹配了Sink的类型，Object。

解决方案是使用一种我们还没有见过的有限制的通配符：有下限的通配符。语法 ? super T 表示T的一个未知的父类（或者是T自己）。这跟我们用? extends T 表示T的一个未知的子类是对应的。

T T writeAll(CollectionT coll, Sink? super T snk) { … }

String str = writeAll(cs, s); // YES!!!

使用这个语法，这个调用是合法的，推断出来的T是String，正是我们想要的。

现在让我们看一个更现实的例子。一个 java.util.TreeSetE 代表一个有序的元素是E类型的树。创建一个TreeSet的一个方法是传递一个 Comparator 对象给构造函数。这个Comparator将会用来按照需要对TreeSet进行排序。

TreeSet(ComparatorE c)

Comparator 接口是核心：

interface ComparatorT { int compare(T fst, T snd); }

假定我们要创建一个 TreeSetString 并传递一个合适的 Comparator，我们需要传一个能比较String的Comparator。这可以是一个 ComparatorString，也可以是一个 ComparatorObject。然而我们不能用ComparatorObject来调用上面的构造函数。我们可以使用一个有下限的通配符来得到我们需要的灵活性：

TreeSet(Comparator? super E c)

这允许任何可用的Comparator被传递进去。

作为使用下限通配符最终的例子，让我们来看看方法 Collections.max()，它返回一个集合中的最大的元素。

现在，为了让max()能工作，传进来的集合中的所有元素必须实现 Comparatable接口。而且，他们必须都能够被彼此比较（all be comparable to each other）。第一个尝试是：

public static T extends ComparableT T max(CollectionT coll)

就是说，方法的参数是某一个能和自己进行比较的T的集合。这限制太严格了。

为什么？考虑一个能和任何对象进行比较的类型：

class Foo implements ComparableObject {...} ...

CollectionFoo cf = ...;

Collections.max(cf); // 应该能工作

cf 中的每个元素都可以和每个cf中的其他元素进行比较，因为每个这样的元素都是一个Foo,它可以和任意的对象进行比较，也可以和另一个Foo进行比较。

但是，使用上面的方法签名，我们发现这个调用被拒绝。推断出来的类型必须是Foo，但是Foo没有实现接口 ComparableFoo。

T 精确的(exactly)和自己能比较是不需要的。所需要的是 T能够和它的父类中的一个进行比较，这导出：（注：Collections.max()的实际方法签名更复杂，我们在第10部分再讨论。）

public static T extends Comparable? super T T max(CollectionT coll)

这个推论对大多数想让 Comparable 对任意类型生效的用法中都有效：你总是应该使用 Comparable? super T。

总之，如果你有一个只使用类型参数T作为参数的API，它的使用应该利用下限通配符( ? super T )的好处。相反的，如果API只返回T，你应该使用上限通配符( ? extends T )来给你的客户端更大的灵活性。

（原文：This reasoning applies to almost any usage of Comparable that is intended to work for arbitrary types: You always want to use Comparable? super T.

In general, if you have an API that only uses a type parameter T as an argument, its uses should take advantage of lower bounded wildcards (? super T). Conversely, if the API only returns T, you'll give your clients more flexibility by using upper bounded wildcards (? extends T). ）。

如果你想比较深刻的了解java泛型那么

建议你看看Java1.5泛型指南

中文链接地址:

英文pdf格式地址:

java 泛型问题

对T的一个限定

T 是任意的

T extends Info

限定 T 的范围：所有满足这样语法的 Info i = new xxx(); 的 xxx

不能继承接口，也没说不让这样写，什么规矩都是人家定的

怎么区别java泛型的上限和下限？？

您好，提问者：

上限：? extends 父类

下限：? super 子类

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