_Kotlin_系列_ 二、Kotlin泛型

public void setData(Object data) {
setData((Integer) data);
}

public void setData(Integer data) {
System.out.println(“MyNode.setData”);
super.setData(data);
}
}

3、伪泛型

Java 中的泛型是一种特殊的语法糖，通过类型擦除实现，这种泛型称为伪泛型，我们可以反射绕过编译器泛型检查，添加一个不同类型的参数

//反射绕过编译器检查
public static void main(String[] args) {

List stringList = new ArrayList<>();
stringList.add(“erdai”);
stringList.add(“666”);

//使用反射增加一个新的元素
Class<? extends List> aClass = stringList.getClass();
try {
Method method = aClass.getMethod(“add”, Object.class);
method.invoke(stringList,123);
} catch (Exception e) {
e.printStackTrace();
}

Iterator iterator = stringList.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
//打印结果
erdai
666
123

4、泛型擦除进阶

下面我抛出一个在工作中经常会遇到的问题：

在进行网络请求的时候，传入一个泛型的实际类型，为啥能够正确的获取到该泛型类型，并利用 Gson 转换为实际的对象？

答：是因为在运行期我们可以使用反射获取到具体的泛型类型

What? 泛型不是在编译的时候被擦除了吗？为啥在运行时还能够获取到具体的泛型类型？🤔️

答：泛型中所谓的类型擦除，其实只是擦除 Code 属性中的泛型信息，在类常量池属性（Signature 属性、LocalVariableTypeTable 属性）中其实还保留着泛型信息，而类常量池中的属性可以被 class 文件，字段表，方法表等携带，这就使得我们声明的泛型信息得以保留，这也是我们在运行时可以反射获取泛型信息的根本依据

//这是反编译后的 JavaGenericClass.class 文件，可以看到 T
public class JavaGenericClass {

private T a;

public JavaGenericClass(T a) {
this.a = a;
}

public T getA() {
return a;
}

public void setA(T a) {
this.a = a;
}

//…
}

注意：Java 是在 JDK 1.5 引入的泛型，为了弥补泛型擦除的不足，JVM 的 class 文件也做了相应的修改，其中最重要的就是新增了 Signature 属性表和 LocalVariableTypeTable 属性表

我们看下下面这段代码：

class ParentGeneric {

}

class SubClass extends ParentGeneric{

}

class SubClass2 extends ParentGeneric {

}

public class GenericGet {

//获取实际的泛型类型
public static Type findGenericType(Class cls) {
Type genType = cls.getGenericSuperclass();
Type finalNeedType = null;
if (genType instanceof ParameterizedType) {
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
finalNeedType = params[0];
}
return finalNeedType;
}

public static void main(String[] args) {
SubClass subClass = new SubClass();
SubClass2 subClass2 = new SubClass2();
//打印 subClass 获取的泛型
System.out.println("subClass: " + findNeedClass(subClass.getClass()));
//打印subClass2获取的泛型
System.out.println("subClass2: " + findGenericType(subClass2.getClass()));
}
}

//运行这段代码 打印结果如下
subClass: class java.lang.String
subClass2: T

上面代码：

1、 SubClass 相当于对 ParentGeneric 做了赋值操作 T = String，我们通过反射获取到了泛型类型为 String

2、SubClass2 对 ParentGeneric没有做赋值操作 ，我们通过反射获取到了泛型类型为 T

这里大家肯定会有很多疑问？

1、为啥 1 中没有传入任何泛型的信息却能获取到泛型类型呢？

2、为啥 2 中我创建对象的时候传入的泛型是 Integer ，获取的时候变成了 T 呢？

现在我们来仔细分析一波：

上面我讲过，类型擦除其实只是擦除 Code 属性中的泛型信息，在类常量池属性中还保留着泛型信息，因此上面的 SubClass 和SubClass2 在编译的时候其实会保留各自的泛型到字节码文件中，一个是 String，一个是 T 。而 subClass 和 subClass2 是运行时动态创建的，这个时候你即使传入了泛型类型，也会被擦除掉，因此才会出现上面的结果，到这里，大家是否明了了呢？

如果还有点模糊，我们再来看一个例子：

class ParentGeneric {

}

public class GenericGet {
//获取实际的泛型类型
public static Type findGenericType(Class cls) {
Type genType = cls.getGenericSuperclass();
Type finalNeedType = null;
if (genType instanceof ParameterizedType) {
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
finalNeedType = params[0];
}
return finalNeedType;
}

public static void main(String[] args) {
ParentGeneric parentGeneric1 = new ParentGeneric();
ParentGeneric parentGeneric2 = new ParentGeneric(){};

//打印 parentGeneric1 获取的泛型
System.out.println("parentGeneric1: " + findGenericType(parentGeneric1.getClass()));
//打印 parentGeneric2 获取的泛型
System.out.println("parentGeneric2: " + findGenericType(parentGeneric2.getClass()));

}
}
//运行这段代码 打印结果如下
parentGeneric1: null
parentGeneric2: class java.lang.String

上述代码 parentGeneric1 和 parentGeneric2 唯一的区别就是多了 {}，获取的结果却截然不同，我们在来仔细分析一波：

1、 ParentGeneric 声明的泛型 T 在编译的时候其实是保留在了字节码文件中，parentGeneric1 是在运行时创建的，由于泛型擦除，我们无法通过反射获取其中的类型，因此打印了 null

这个地方可能大家又会有个疑问了，你既然保留了泛型类型为 T，那么我获取的时候应该为 T 才是，为啥打印的结果是 null 呢？

如果你心里有这个疑问，说明你思考的非常细致，要理解这个问题，我们首先要对 Java 类型（Type）系统有一定的了解，这其实和我上面写的那个获取泛型类型的方法有关：

//获取实际的泛型类型
public static Type findGenericType(Class cls) {
//获取当前带有泛型的父类
Type genType = cls.getGenericSuperclass();
Type finalNeedType = null;
//如果当前 genType 是参数化类型则进入到条件体
if (genType instanceof ParameterizedType) {
//获取参数类型 <> 里面的那些值,例如 Map<K,V> 那么就得到 [K,V]的一个数组
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
//将第一个泛型类型赋值给 finalNeedType
finalNeedType = params[0];
}
return finalNeedType;
}

上述代码我们需要先获取这个类的泛型父类，如果是参数化类型则进入到条件体，获取实际的泛型类型并返回。如果不是则直接返回 finalNeedType , 那么这个时候就为 null 了

在例1中：

SubClass1 subClass1 = new SubClass1();
SubClass2 subClass2 = new SubClass2<>();
System.out.println(subClass1.getClass().getGenericSuperclass());
System.out.println(subClass2.getClass().getGenericSuperclass());
//运行程序 打印结果如下
com.dream.java_generic.share.ParentGeneric<java.lang.String>
com.dream.java_generic.share.ParentGeneric

可以看到获取到了泛型父类，因此会走到条件体里面获取到实际的泛型类型并返回

在例2中:

ParentGeneric parentGeneric1 = new ParentGeneric();
System.out.println(parentGeneric1.getClass().getGenericSuperclass());
//运行程序 打印结果如下
class java.lang.Object

可以看到获取到的泛型父类是 Object，因此进不去条件体，所以就返回 null 了

2、parentGeneric2 在创建的时候后面加了 {}，这就使得 parentGeneric2 成为了一个匿名内部类，且父类就是 ParentGeneric，因为匿名内部类是在编译时创建的，那么在编译的时候就会创建并携带具体的泛型信息，因此 parentGeneric2 可以获取其中的泛型类型

通过上面两个例子我们可以得出结论：如果在编译的时候就保存了泛型类型到字节码中，那么在运行时我们就可以通过反射获取到，如果在运行时传入实际的泛型类型，这个时候就会被擦除，反射获取不到当前传入的泛型实际类型

例子1中我们指定了泛型的实际类型为 String，编译的时候就将它存储到了字节码文件中，因此我们获取到了泛型类型。例子2中我们创建了一个匿名内部类，同样在编译的时候会进行创建并保存了实际的泛型到字节码中，因此我们可以获取到。而 parentGeneric1 是在运行时创建的，虽然 ParentGeneric 声明的泛型 T 在编译时也保留在了字节码文件中，但是它传入的实际类型被擦除了，这种泛型也是无法通过反射获取的，记住上面这条结论，那么对于泛型类型的获取你就得心应手了

5、泛型获取经验总结

其实通过上面两个例子可以发现，当我们定义一个子类继承一个泛型父类，并给这个泛型一个类型，我们就可以获取到这个泛型类型

//定义一个子类继承泛型父类，并给这个泛型一个实际的类型
class SubClass extends ParentGeneric{

}

//匿名内部类，其实我们定义的这个匿名内部类也是一个子类，它继承了泛型父类，并给这个泛型一个实际的类型
ParentGeneric parentGeneric2 = new ParentGeneric(){};

因此如果我们想要获取某个泛型类型，我们可以通过子类的帮助去取出该泛型类型，一种良好的编程实践就是把当前需要获取的泛型类用 abstract 声明

3、边界

边界就是在泛型的参数上设置限制条件，这样可以强制泛型可以使用的类型，更重要的是可以按照自己的边界类型来调用方法

1）、Java 中设置边界使用 extends 关键字，完整语法结构：<T extends Bound> ，Bound 可以是类和接口，如果不指定边界，默认边界为 Object

2）、可以设置多个边界，中间使用 & 连接，多个边界中只能有一个边界是类，且类必须放在最前面，类似这种语法结构

<T extends ClassBound & InterfaceBound1 & InterfaceBound2>

下面我们来演示一下：

abstract class ClassBound{
public abstract void test1();
}

interface InterfaceBound1{
void test2();
}

interface InterfaceBound2{
void test3();
}

class ParentClass <T extends ClassBound & InterfaceBound1 & InterfaceBound2>{
private final T item;

public ParentClass(T item) {
this.item = item;
}

public void test1(){
item.test1();
}

public void test2(){
item.test2();
}

public void test3(){
item.test3();
}
}

class SubClass extends ClassBound implements InterfaceBound1,InterfaceBound2 {

@Override
public void test1() {
System.out.println(“test1”);
}

@Override
public void test2() {
System.out.println(“test2”);
}

@Override
public void test3() {
System.out.println(“test3”);
}
}

public class Bound {
public static void main(String[] args) {
SubClass subClass = new SubClass();
ParentClass parentClass = new ParentClass(subClass);
parentClass.test1();
parentClass.test2();
parentClass.test3();
}
}
//打印结果
test1
test2
test3

4、通配符

1、泛型的协变，逆变和不变

思考一个问题，代码如下：

Number number = new Integer(666);
ArrayList numberList = new ArrayList();//编译器报错 type mismatch

上述代码，为啥 Number 的对象可以由 Integer 实例化，而 ArrayList<Number> 的对象却不能由 ArrayList<Integer> 实例化？

要明白上面这个问题，我们首先要明白，什么是泛型的协变，逆变和不变

1）、泛型协变，假设我定义了一个 Class<T> 的泛型类，其中 A 是 B 的子类，同时 Class<A> 也是 Class<B> 的子类，那么我们说 Class 在 T 这个泛型上是协变的

2）、泛型逆变，假设我定义了一个 Class<T> 的泛型类，其中 A 是 B 的子类，同时 Class<B> 也是 Class<A> 的子类，那么我们说 Class 在 T 这个泛型上是逆变的

3）、泛型不变，假设我定义了一个 Class<T> 的泛型类，其中 A 是 B 的子类，同时 Class<B> 和 Class<A> 没有继承关系，那么我们说 Class 在 T 这个泛型上是不变的

因此我们可以知道 ArrayList<Number> 的对象不能由 ArrayList<Integer> 实例化是因为 ArrayList 当前的泛型是不变的，我们要解决上面报错的问题，可以让 ArrayList 当前的泛型支持协变，如下：

Number number = new Integer(666);
ArrayList<? extends Number> numberList = new ArrayList();

2、泛型的上边界通配符

1）、泛型的上边界通配符语法结构：<? extends Bound>，使得泛型支持协变，它限定的类型是当前上边界类或者其子类，如果是接口的话就是当前上边界接口或者实现类，使用上边界通配符的变量只读，不可以写，可以添加 null ，但是没意义

public class WildCard {
public static void main(String[] args) {
List integerList = new ArrayList();
List numberList = new ArrayList();
integerList.add(666);
numberList.add(123);

getNumberData(integerList);
getNumberData(numberList);
}

public static void getNumberData(List<? extends Number> data) {
System.out.println(“Number data :” + data.get(0));
}
}
//打印结果
Number data: 666
Number data: 123

问题：为啥使用上边界通配符的变量只读，而不能写？

1、<? extends Bound>,它限定的类型是当前上边界类或者其子类，它无法确定自己具体的类型，因此编译器无法验证类型的安全，所以不能写

2、假设可以写，我们向它里面添加若干个子类，然后用一个具体的子类去接收，势必会造成类型转换异常

3、泛型的下边界通配符

1）、泛型的下边界通配符语法结构：<? super Bound>，使得泛型支持逆变，它限定的类型是当前下边界类或者其父类，如果是接口的话就是当前下边界接口或者其父接口，使用下边界通配符的变量只写，不建议读

public class WildCard {

public static void main(String[] args) {
List numberList = new ArrayList();
List objectList = new ArrayList();
setNumberData(numberList);
setNumberData(objectList);
}

public static void setNumberData(List<? super Number> data) {
Number number = new Integer(666);
data.add(number);
}
}

问题：为啥使用下边界通配符的变量可以写，而不建议读？

1、<? super Bound>，它限定的类型是当前下边界类或者其父类，虽然它也无法确定自己具体的类型，但根据多态，它能保证自己添加的元素是安全的，因此可以写

2、获取值的时候，会返回一个 Object 类型的值，而不能获取实际类型参数代表的类型，因此建议不要去读，如果你实在要去读也行，但是要注意类型转换异常

4、泛型的无边界通配符

1）、无边界通配符的语法结构：<?>，实际上它等价于 <? extends Object>，也就是说它的上边界是 Object 或其子类，因此使用无界通配符的变量同样只读，不能写，可以添加 null ，但是没意义

public class WildCard {

public static void main(String[] args) {
List stringList = new ArrayList();
List numberList = new ArrayList();
List integerList = new ArrayList();
stringList.add(“erdai”);
numberList.add(666);
integerList.add(123);
getData(stringList);
getData(numberList);
getData(integerList);
}

public static void getData(List<?> data) {
System.out.println("data: " + data.get(0));
}
}
//打印结果
data: erdai
data: 666
data: 123

5、PECS 原则

泛型代码的设计，应遵循PECS原则（Producer extends Consumer super）：

1）、如果只需要获取元素，使用 <? extends T>

2）、如果只需要存储，使用 <? super T>

//这是 Collections.java 中 copy 方法的源码
public static void copy(List<? super T> dest, List<? extends T> src) {
//…
}

这是一个很经典的例子，src 表示原始集合，使用了 <? extends T>，只能从中读取元素，dest 表示目标集合，只能往里面写元素，充分的体现了 PECS 原则

6、使用通配符总结

1）、当你只想读取值的时候，使用 <? extends T>

2）、当你只想写入值的时候，使用 <? super T>

3）、当你既想读取值又想写入值的时候，就不要使用通配符

5、泛型的限制

1）、泛型不能显式地引用在运行时类型的操作里，如 instanceof 操作和 new 表达式，运行时类型只适用于原生类型

public class GenericLimitedClass {
private void test(){
String str = “”;
//编译器不允许这种操作
if(str instanceof T){

}
//编译器不允许这种操作
T t = new T();
}
}

2）、不能创建泛型类型的数组，只可以声明一个泛型类型的数组引用

public class GenericLimitedClass {
private void test(){
GenericLimitedClass[] genericLimitedClasses;
//编译器不允许
genericLimitedClasses = new GenericLimitedClass[10];
}
}

3）、不能声明类型为泛型的静态字段

public class GenericLimitedClass {
//编译器不允许
private static T t;
}

4）、泛型类不可以直接或间接地继承 Throwable

//编译器不允许
public class GenericLimitedClass extends Throwable {

}

5）、方法中不可以捕获类型参数的实例，但是可以在 throws 语句中使用类型参数

public class GenericLimitedClass {
private void test1() throws T{
try {

//编译器不允许
}catch (T exception){

}
}
}

6）、一个类不可以重载在类型擦除后有同样方法签名的方法

public class GenericLimitedClass {
//编译器不允许
private void test2(List stringList){

}

private void test2(List integerList){

}
}

6、问题

1）、类型边界和通配符边界有什么区别？

类型边界可以有多个，通配符边界只能有一个

2）、List<?> 和 List<Object> 一样吗？

不一样

1、 List<Object> 可读写，但是 List<?> 只读

2、List<?>可以有很多子类，但是 List<Object> 没有

二、Kotlin 泛型

Kotlin 泛型和 Java 泛型基本上是一样的，只不过在 Kotlin 上有些东西换了新的写法

1、泛型的基本用法

1）、在 Kotlin 中我们定义和使用泛型的方式如下：

//1、定义一个泛型类，在类名后面使用 这种语法结构就是为这个类定义一个泛型
class MyClass{
fun method(params: T) {

}
}
//泛型调用
val myClass = MyClass()
myClass.method(12)

//2、定义一个泛型方法，在方法名的前面加上 这种语法结构就是为这个方法定义一个泛型
class MyClass{
fun method(params: T){

}
}
//泛型调用
val myClass = MyClass()
myClass.method(12)
//根据 Kotlin 类型推导机制，我们可以把泛型给省略
myClass.method(12)

//3、定义一个泛型接口，在接口名后面加上 这种语法结构就是为这个接口定义一个泛型
interface MyInterface{
fun interfaceMethod(params: T)
}

对比 Java 中定义泛型，我们可以发现：在定义类和接口泛型上没有任何区别，在定义方法泛型时，Kotlin 是在方法名前面添加泛型，而 Java 是在返回值前面添加泛型

2、边界

1）、为泛型指定边界，我们可以使用 <T : Class> 这种语法结构，如果不指定泛型的边界，默认为 Any?

2）、如果有多个边界，可以使用 where 关键字，中间使用 : 隔开，多个边界中只能有一个边界是类，且类必须放在最前面

//情况1 单个边界
class MyClass1 {

var data: T? = null

fun method(params: T) {

}
}

//情况2 多个边界使用 where 关键字
open class Animal
interface Food
interface Food2

class MyClass2 where T : Animal, T : Food, T : Food2 {

fun method(params: T) where T : Animal, T : Food, T : Food2 {

}
}

3、泛型实化

泛型实化在 Java 中是不存在的，Kotlin 中之所以能实现泛型实化，是因为使用的内联函数会对代码进行替换，那么在内联函数中使用泛型，最终也会使用实际的类型进行替换

1）、使用内联函数配合 reified 关键字对泛型进行实化，语法结构如下：

inline fun getGenericType() {

}

实操一下：

inline fun getGenericType() = T::class.java

fun main() {
//泛型实化 这种情况在 Java 是会被类型擦除的
val result1 = getGenericType()
val result2 = getGenericType()
println(result1)
println(result2)
}
//打印结果
class java.lang.String
class java.lang.Number

2）、实际应用

在我们跳转 Activity 的时候通常会这么操作

val intent = Intent(mContext,TestActivity::class.java)
mContext.startActivity(intent)

有没有感觉写这种 TestActivity::class.java 的语法很难受，反正我是觉得很难受，那么这个时候我们就可以使用泛型实化换一种写法：

//定义一个顶层函数
inline fun startActivity(mContext: Context){
val intent = Intent(mContext,T::class.java)
mContext.startActivity(intent)
}

//使用的时候
startActivity(mContext)

这种写法是不是清爽了很多，那么在我们跳转 Activity 的时候，可能会携带一些参数，如下：

val intent = Intent(mContext,TestActivity::class.java)
intent.putExtra(“params1”,“erdai”)
intent.putExtra(“params2”,“666”)
mContext.startActivity(intent)

这个时候我们可以增加一个函数类型的参数，使用 Lambda 表达式去调用，如下：

inline fun startActivity(mContext: Context, block: Intent.() -> Unit){
val intent = Intent(mContext,T::class.java)
intent.block()
mContext.startActivity(intent)
}

//使用的时候
startActivity(mContext){
putExtra(“params1”,“erdai”)
putExtra(“params2”,“666”)
}

4、泛型协变，逆变和不变

1）、泛型协变的语法规则：<out T> 类似于 Java 的 <? extends Bound>，它限定的类型是当前上边界类或者其子类，如果是接口的话就是当前上边界接口或者实现类，协变的泛型变量只读，不可以写，可以添加 null ，但是没意义

open class Person
class Student: Person()
class Teacher: Person()

class SimpleData{

}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

总结

Android架构学习进阶是一条漫长而艰苦的道路，不能靠一时激情，更不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！

上面分享的字节跳动公司2021年的面试真题解析大全，笔者还把一线互联网企业主流面试技术要点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。

【Android高级架构视频学习资源】

Android部分精讲视频领取学习后更加是如虎添翼！进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！**

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

总结

Android架构学习进阶是一条漫长而艰苦的道路，不能靠一时激情，更不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！

上面分享的字节跳动公司2021年的面试真题解析大全，笔者还把一线互联网企业主流面试技术要点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。
[外链图片转存中…(img-jayUClRM-1713423698529)]

【Android高级架构视频学习资源】

Android部分精讲视频领取学习后更加是如虎添翼！进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！