带着问题高效学Android：关于Java与Kotlin泛型你应该知道的知识点(1)

我的面试宝典：一线互联网大厂Java核心面试题库

以下是我个人的一些做法，希望可以给各位提供一些帮助：

整理了很长一段时间，拿来复习面试刷题非常合适，其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等，且还会持续的更新…可star一下！

283页的Java进阶核心pdf文档

Java部分：Java基础，集合，并发，多线程，JVM，设计模式

数据结构算法：Java算法，数据结构

开源框架部分：Spring，MyBatis，MVC，netty，tomcat

分布式部分：架构设计，Redis缓存，Zookeeper，kafka，RabbitMQ，负载均衡等

微服务部分：SpringBoot，SpringCloud，Dubbo，Docker

还有源码相关的阅读学习

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

请问Pair和Pair是继承关系吗？

答案：不是，他们之间没有什么关系

但是泛型类可以继承或者扩展其他泛型类，比如List和ArrayList

通配符与PECS

---

正是因为前面所述的，Pair和Pair没有任何关系,而我们有时候需要用到类之前的继承关系

为解决这个问题，于是提出了一个通配符类型 ?

有两种使用方式：

？ extends X 表示类型的上界，类型参数是X的子类

？ super X 表示类型的下界，类型参数是X的超类

这两种 方式从名字上来看，特别是super，很有迷惑性，下面我们来仔细辨析这两种方法。

？ extends X

表示传递给方法的参数，必须是X的子类（包括X本身）

public static void print2(GenericType<? extends Fruit> p){

System.out.println(p.getData().getColor());

}

public static void use2(){

GenericType a = new GenericType<>();

print2(a);

GenericType b = new GenericType<>();

print2(b);

}

但是对泛型类GenericType来说，如果其中提供了get和set类型参数变量的方法的话，set方法是不允许被调用的，会出现编译错误

GenericType<? extends Fruit> c = new GenericType<>();

Apple apple = new Apple();

Fruit fruit = new Fruit();

//set会报错

//c.setData(apple);

//c.setData(fruit);

//get是可以的

Fruit x = c.getData();

get方法则没问题，会返回一个Fruit类型的值。

为何？

道理很简单，？extends X 表示类型的上界，类型参数是X的子类，那么可以肯定的说，get方法返回的一定是个X（不管是X或者X的子类）编译器是可以确定知道的。但是set方法只知道传入的是个X，至于具体是X的那个子类，不知道。

总结：主要用于安全地访问数据，可以访问X及其子类型，并且不能写入非null的数据。

？ super X

表示传递给方法的参数，必须是X的超类（包括X本身）

public static void printSuper(GenericType<? super Apple> p){

System.out.println(p.getData());

}

public static void useSuper(){

GenericType fruitGenericType = new GenericType<>();

GenericType appleGenericType = new GenericType<>();

GenericType hongFuShiGenericType = new GenericType<>();

GenericType orangeGenericType = new GenericType<>();

printSuper(fruitGenericType);

printSuper(appleGenericType);

printSuper(hongFuShiGenericType);

printSuper(orangeGenericType);

}

但是对泛型类GenericType来说，如果其中提供了get和set类型参数变量的方法的话，set方法可以被调用的，且能传入的参数只能是X或者X的子类

//表示GenericType的类型参数的下界是Apple

GenericType<? super Apple> x = new GenericType<>();

x.setData(new Apple());

x.setData(new HongFuShi());

//x.setData(new Fruit());

Object data = x.getData();

get方法只会返回一个Object类型的值。

为何？

？super X 表示类型的下界，类型参数是X的超类（包括X本身），那么可以肯定的说，get方法返回的一定是个X的超类，那么到底是哪个超类？不知道，但是可以肯定的说，Object一定是它的超类，所以get方法返回Object。编译器是可以确定知道的。对于set方法来说，编译器不知道它需要的确切类型，但是X和X的子类可以安全的转型为X。

**总结：**主要用于安全地写入数据，可以写入X及其子类型

无限定的通配符 ?

表示对类型没有什么限制，可以把？看成所有类型的父类，如Pair< ?>；

比如：

ArrayList al=new ArrayList(); 指定集合元素只能是T类型

ArrayList al=new ArrayList();集合元素可以是任意类型，这种没有意义，一般是方法中，只是为了说明用法。

在使用上：

？ getFirst() ： 返回值只能赋给 Object，；

void setFirst(?) ： setFirst 方法不能被调用， 甚至不能用 Object 调用；

PECS原则

上面讲解的extend与super的使用，其实可以用PECS原则来总结：

PECS指“Producer Extends，Consumer Super”。换句话说，如果参数化类型表示一个生产者，就使用<? extends T>；如果它表示一个消费者，就使用<? super T>

总结 ? extends 和 the ? super 通配符的特征，我们可以得出以下结论

• 如果你想从一个数据类型里获取数据，使用 ? extends 通配符

• 如果你想把对象写入一个数据结构里，使用 ? super 通配符

• 如果你既想存，又想取，那就别用通配符。

虚拟机是如何实现泛型的？什么是泛型擦除？

---

泛型思想早在C++语言的模板（Template）中就开始生根发芽，在Java语言处于还没有出现泛型的版本时，只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。，由于Java语言里面所有的类型都继承于java.lang.Object，所以Object转型成任何对象都是有可能的。但是也因为有无限的可能性，就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间，编译器无法检查这个Object的强制转型是否成功，如果仅仅依赖程序员去保障这项操作的正确性，许多ClassCastException的风险就会转嫁到程序运行期之中。

泛型技术在C#和Java之中的使用方式看似相同，但实现上却有着根本性的分歧，C#里面泛型无论在程序源码中、编译后的IL中（Intermediate Language，中间语言，这时候泛型是一个占位符），或是运行期的CLR中，都是切实存在的，List＜int＞与List＜String＞就是两个不同的类型，它们在系统运行期生成，有自己的虚方法表和类型数据，这种实现称为类型膨胀，基于这种方法实现的泛型称为真实泛型。

Java语言中的泛型则不一样，它只在程序源码中存在，在编译后的字节码文件中，就已经替换为原来的原生类型（Raw Type，也称为裸类型）了，并且在相应的地方插入了强制转型代码，因此，对于运行期的Java语言来说，ArrayList＜int＞与ArrayList＜String＞就是同一个类，所以泛型技术实际上是Java语言的一颗语法糖，Java语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。

将一段Java代码编译成Class文件，然后再用字节码反编译工具进行反编译后，将会发现泛型都不见了，程序又变回了Java泛型出现之前的写法，泛型类型都变回了原生类型

public static String method(List stringList){

System.out.println(“List”);

return “OK”;

}

public static Integer method(List stringList){

System.out.println(“List”);

return 1;

}

上面这段代码是不能被编译的，因为参数List＜Integer＞和List＜String＞编译之后都被擦除了，变成了一样的原生类型List＜E＞，擦除动作导致这两种方法的特征签名变得一模一样。

为什么泛型擦除后get不需要类型转换？

因为类型擦除的问题，所以所有的泛型类型变量最后都会被替换为原始类型。这样就引起了一个问题，既然都被替换为原始类型，那么为什么我们在获取的时候，不需要进行强制类型转换呢？看下ArrayList和get方法：

public E get(int index) {

RangeCheck(index);

return (E) elementData[index];

}

看以看到，在return之前，会根据泛型变量进行强转。 写了个简单的测试代码：

public class Test {

public static void main(String[] args) {

ArrayList list=new ArrayList();

list.add(new Date());

Date myDate=list.get(0);

}

然后反编了下字节码，如下

public static void main(java.lang.String[]);

Code:

0: new #16 // class java/util/ArrayList

3: dup

4: invokespecial #18 // Method java/util/ArrayList."<init

😦)V

7: astore_1

8: aload_1

9: new #19 // class java/util/Date

12: dup

13: invokespecial #21 // Method java/util/Date.“”😦)

16: invokevirtual #22 // Method java/util/ArrayList.add:(L

va/lang/Object;)Z

19: pop

20: aload_1

21: iconst_0

22: invokevirtual #26 // Method java/util/ArrayList.get:(I

java/lang/Object;

25: checkcast #19 // class java/util/Date

28: astore_2

29: return

看第22 ，它调用的是ArrayList.get()方法，方法返回值是Object，说明类型擦除了。然后第25，它做了一个checkcast操作，即检查类型#19， 在在上面找#19引用的类型，他是 9: new #19 // class java/util/Date 是一个Date类型，即做Date类型的强转。 所以不是在get方法里强转的，是在你调用的地方强转的

kotlin泛型

---

kotlin泛型中引入了in和out

Out (协变)

如果你的类是将泛型作为内部方法的返回，那么可以用 out：

interface Production {

fun produce(): T

}

可以称其为 production class/interface，因为其主要是产生（produce）指定泛型对象。因此，可以这样来记：produce = output = out。

相当于Java中的? extends T

In(逆变)

如果你的类是将泛型对象作为函数的参数，那么可以用 in：

interface Consumer {

fun consume(item: T)

}

可以称其为 consumer class/interface，因为其主要是消费指定泛型对象。因此，可以这样来记：consume = input = in。

相当于Java中的? super T

Invariant(不变)

如果既将泛型作为函数参数，又将泛型作为函数的输出，那就既不用 in 或 out。

interface ProductionConsumer {

fun produce(): T

fun consume(item: T)

}

"父类泛型对象可以赋值给子类泛型对象，用 in；

子类泛型对象可以赋值给父类泛型对象，用 out。"

关于In out使用的例子，可见：Kotlin 泛型中的 in 和 out

如何进阶Android？

对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！

1、确定好方向，梳理成长路线图

不用多说，相信大家都有一个共识：无论什么行业，最牛逼的人肯定是站在金字塔端的人。所以，想做一个牛逼的程序员，那么就要让自己站的更高，成为技术大牛并不是一朝一夕的事情，需要时间的沉淀和技术的积累。

关于这一点，在我当时确立好Android方向时，就已经开始梳理自己的成长路线了，包括技术要怎么系统地去学习，都列得非常详细。

知识梳理完之后，就需要进行查漏补缺，所以针对这些知识点，我手头上也准备了不少的电子书和笔记，这些笔记将各个知识点进行了完美的总结。

2、通过源码来系统性地学习

只要是程序员，不管是Java还是Android，如果不去阅读源码，只看API文档，那就只是停留于皮毛，这对我们知识体系的建立和完备以及实战技术的提升都是不利的。

真正最能锻炼能力的便是直接去阅读源码，不仅限于阅读各大系统源码，还包括各种优秀的开源库。

3、阅读前辈的一些技术笔记

分享

1、算法大厂——字节跳动面试题

2、2000页互联网Java面试题大全

3、高阶必备，算法学习

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

05f3c4b4049e9e5658b309bf9cb782be.png)

3、阅读前辈的一些技术笔记

分享

1、算法大厂——字节跳动面试题

[外链图片转存中…(img-ns4zLbGm-1715538036767)]

2、2000页互联网Java面试题大全

[外链图片转存中…(img-Bzy1rExy-1715538036768)]

3、高阶必备，算法学习

[外链图片转存中…(img-UXvHESTM-1715538036768)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取