摘要：好了，有了这样的背景知识，我们可以来看一下上界通配了，在中，可以使用来界定一个上界，的意思是所有属于的子类，是上界，不能突破天界啊，我们具体化一下，的意思就是，所有的子类都可以匹配这个通配符。
1、上界通配符
首先，需要知道的是，Java语言中的数组是支付协变的，什么意思呢？看下面的代码：
static class A extends Base{
void f() {
System.out.println("A.f");
}
}
static class B extends A {
void f() {
System.out.println("B.f");
}
}
static class C extends B {
void f() {
System.out.println("C.f");
}
}
static {
A[] arrayA = new A[3];
arrayA[0] = new A();
arrayA[1] = new B();
arrayA[2] = new C();
for (A item : arrayA) {
item.f();
}
}
//output
A.f
B.f
C.f
我们明明让数组的类型为A，但是向其中加入B、C也是可以行得通的，为什么呢？我们发现B继承了A，属于A的子类，C继承了B，属于B的子类，Java中的继承是可以传递的，所以C依然属于A的子类，所以B和C都是A的子类，另外一点，在Java中，类型向上转换是非常自然的，不需要强制转换会自动进行，也就是说，B和C的实例都可以自动转换为类型A的实例。好了，有了这样的背景知识，我们可以来看一下上界通配了，在java中，可以使用 来界定一个上界，的意思是所有属于Type的子类，Type是上界，不能突破天界啊，我们具体化一下，的意思就是，所有A的子类都可以匹配这个通配符。所有我们的B、C的实例以及他们的子类的实例都可以匹配，但是Base就不可以，因为Base是A的父类，而我们的上界是A啊，所以当然不能是Base了。很自然的，我们有下面的代码：
A a = new B();
A b = new C();
C c = new C();
List list = new ArrayList();
list.add(a);
list.add(b);
list.add(c);
我们觉得很自然这样做是无可厚非的，对吧？但是编译器很显然不允许我们这样做，为什么？我们的list的类型使用了上界通配符啊，而且匹配的是所有A的子类，而我们add的都是A的子类啊，为什么不可以呢？我们再来看一下，我们的list可以持有任何A的子类对象，也就是A、B、C的实例都是可以的，那我们是不是可以把认为是的子类呢？呢？我们暂且认为是可以这样吧，那看下面的这个方法：
void joke(List list) {
A a = new B();
A b = new C();
C c = new C();
list.add(a);
list.add(b);
list.add(c);
}
当然上面的代码是无法通过编译的，我们分析一下为什么，记住是设定上界，所以，joke方法的参数是开放的，我们可以传进去一个的list，也可以是一个的list，还可以是一个的list。因为下面的代码是可以通过编译的：
private static void jokeIn(List list) {
//
}
static {
List list = new ArrayList<>();
List list1 = new ArrayList<>();
List list2 = new ArrayList<>();
jokeIn(list);
jokeIn(list1);
jokeIn(list2);
}
好吧，问题来了，当我们传到joke方法中的参数是List的时候，方法内部的add都是可以接受的，但是当我们传进去的参数是List的时候，list.add(a)明显是无法成功的，因为我们的list将可以允许持有B的子类，但是A不在这个范围里面，所以是不合法的，当传进去的是List的时候呢？连list.add(B)也不允许了。所以这就是问题所在，所以不允许这样的代码通过编译是明智的，因为我们不能总是保证调用joke方法的用户会严格传进来一个List的参数。
那怎么使用上界呢？换句话说，如何来产生一个List的list呢？还记得一开始我们说的数组协变吗？下面的代码使用了java语言数组具有协变能力来产生一个具有上界的list：
List list = Arrays.asList(a, b);
Arrays.asList(T ... data)使用了ArrayList的一个构造函数：
ArrayList(E[] array) {
a = Objects.requireNonNull(array);
}
可以看到使用了数组的协变，使得我们可以在Arrays.asList里面传递进去所以A的子类对象。
2、下界通配符
上界定义了可以达到了最高点，超出就是违法的；而下界则是说明了底线，你只能比底线更高级，低于底线就是违法的。在java里面，可以使用来表达下界的意义，具体一点，表达的和是两个相反的方向，前者是说所有基于A的基类，后者是说所有基于A的子类，我们再来看一下下面这个方法：
void joke(List list) {
A a = new B();
A b = new C();
C c = new C();
list.add(a);
list.add(b);
list.add(c);
}
此时的joke方法的参数是List，此时List和List都变成了List的父类了，因为实际上List和List表达的能力比List更强，也就是List包含了List和List，而List则包含了List，好了，说明了这些之后，我们再来看一下对joke方法的调用会出现哪些情况：
static {
List list = new ArrayList<>();
List list1 = new ArrayList<>();
List list2 = new ArrayList<>();
jokeIn(list);
jokeIn(list1); // error
jokeIn(list2); //error
}
好吧，问题出现了，我们可以将List 的参数传递给joke，因为这正是我们需要的，而我们也知道List的表达能力在List和中是最低的，所以，当我们将一个表达能力强于List的参数传递给joke之后，编译器报错了。当然，这仅仅是为了说明所谓下界的界定。
有了下界，我们可以使用下面的代码来为我们工作了：
List lists = new ArrayList<>();
lists.add(a);
lists.add(b);
lists.add(c);
解释一下，lists里面的元素类型是这样一种类型，这种类型是A的基类，我们只是界定了下界，只要高于这个下界，就可以被lists接收，而b、c的基类都是A，可以被lists接收，所以上面的代码是可以工作的。
3、无界通配符
有了上界和下界，还有无界，需要说明的一点是，不能同时使用上界和下界，因为有无界啊（开玩笑的）！！
我们在java中使用来表达无界，对于，目前来讲锁表达的意思是：
我是想要java的范型来编写这段代码，我在这里并不是想使用原生类
型，但是在当前这种情况下，泛型参数可以持有任何类型。
----来自《java编程思想》15.10.3 无界通配符（686页）
使用无界通配符的一种场景是：如果向一个使用的方法传递了一个原生类型，那么对编译器来说可能会推断出实际的参数类型，使得这个方法可以回转并且调用另外一个使用这个确切类型的方法。这叫做“类型捕获”，看下面的代码：
static class Holder{ private T data; public Holder() { } public Holder(T data) { this.data =data; } public T getData() { return data; } public void setData(T data) { this.data = data; } } static void actual(Holder holder) { System.out.println(holder.getData()); } static void func(Holder holder) { actual(holder); } static { Holder holder = new Holder<>("hujian"); func(holder); }
可以看到，actual的参数是具体的T，而func的参数是无界的，这里发生了一件参数类型捕获的事情，在调用func的时候，类型被捕获，而可以在actual方法中使用我们从func中传递进来的无界参数。
可以使用无界通配符来接收多个类型的对象，然后根据不同的类型来交付给不同的方法来处理，可以回忆一下操作系统的中断处理程序的处理方法，通过安装一些中断类型和与之对应的handler，然后通过控制程序来将中断处理信号分发到不同的handler中处理，其实思想是一样的，可以看一下下面的代码来理解这个模型：
staticvoid actual(Holder holder) { T data = holder.getData(); if (data instanceof String) { actual((String) data); } else if (data instanceof Integer) { actual((Integer) data); } else if (data instanceof Double) { actual((Double) data); } } static void actual(String holder) { System.out.print("string:" + holder); } static void actual(Integer holder) { System.out.println("Integer:" + holder); } static void actual(Double holder) { System.out.println("double:" + holder); } static void func(Holder holder) { actual(holder); }
文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。
转载请注明本文地址：https://www.ucloud.cn/yun/70560.html
摘要：虚拟机中并没有泛型类型对象，所有的对象都是普通类。其原因就是泛型的擦除。中数组是协变的，泛型是不可变的。在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一个父类的最小级，直到。 引入泛型的主要目标有以下几点： 类型安全 泛型的主要目标是提高 Java 程序的类型安全 编译时期就可以检查出因 Java 类型不正确导致的 ClassCastException 异常 符合越早出...
摘要：使用强转的话，只能强转成和它的基类，如果强转成的子类的话，有可能会报运行时异常。拥有类型，它是的子类型因此，我们可以将赋给类型为的变量在声明处设置后，就可以和或它的子类进行比较了。 欢迎关注我的博客：songjhhs blog原文连接：对比Java泛型中的extends/super和Kotlin的out/in 在 Java 泛型中，有一个叫做通配符上下界 bounded wildca...
摘要：泛型方法泛型类中可以定义静态非静态的泛型方法。上述泛型类会被替换成下面形式一般使用第一个限定类型替换变为原始类型，没有限定类型，使用替换。 引言 在面向对象的世界里，我们如果需要一个容器来盛装对象。举个例子：一个篮子。我们可以用这个篮子装苹果，也可以用这个篮子装香蕉。基于 OOP 的思想，我们不希望为苹果和香蕉分别创建不同的篮子；同时，我们希望放进篮子里的是苹果，拿出来的还是苹果。于是...
摘要：代码使用泛型类中不依赖于类型参数的方法。委托依赖于动态绑定，因为它要求给定的方法调用可以在运行时调用不同的代码段。委托捕获操作并将其发送给另一个对象。委托可以被看作是在对象层次上的复用机制，而继承是类层次上的复用机制。 大纲 设计可复用的类 继承和重写 重载（Overloading） 参数多态和泛型编程 行为子类型与Liskov替换原则 组合与委托 设计可复用库与框架 API和库...
摘要：静态变量是被泛型类的所有实例所共享的。所以引用能完成泛型类型的检查。对于这个类型系统，有如下的一些规则相同类型参数的泛型类的关系取决于泛型类自身的继承体系结构。事实上，泛型类扩展都不合法。 前言 和C++以模板来实现静多态不同，Java基于运行时支持选择了泛型，两者的实现原理大相庭径。C++可以支持基本类型作为模板参数，Java却只能接受类作为泛型参数；Java可以在泛型类的方法中取得...
阅读 3444·2021-11-18 10:02
阅读 3660·2021-09-13 10:25
阅读 1906·2021-07-26 23:38
阅读 2547·2019-08-30 15:44
阅读 2239·2019-08-30 13:51
阅读 1206·2019-08-26 11:35
阅读 2254·2019-08-26 10:29
阅读 3426·2019-08-23 14:56
