Java基础-泛型

前提

专业术语有时候比较难懂，

胖子觉得，用不严谨的说法，泛型的白话解释就是：

传入的任意对象（注意是对象）

泛型一般有三种：泛型类、泛型接口、泛型方法

泛型类：典型泛型类—ArrayList

public class A<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

//这样可以
A<Integer> a1 = new A();
A<String> a2 = new A();

//这样不行
A<int> a3 = new A();

泛型接口：典型泛型接口—List

public interface IA<T> {
    T next();
}

//第一种
public class A<T> implements IA<T> {
    @Override
    public T next() {
        return null;
    }
}

//第二种
public class A implements IA<String> {
    @Override
    public String next() {
        return null;
    }
}

泛型方法：典型的泛型方法—Objects下的requireNonNull

public static <T> T requireNonNull(T var0) {
    if (var0 == null) {
        throw new NullPointerException();
    } else {
        return var0;
    }
}
//使用
Integer integer = null;
Objects.requireNonNull(integer);//这里会抛一个NullPointerException

敲黑板

泛型里，最烧脑的，应该属于extends、super了。

说到底，extends、super其实就是用来约束传入的泛型的

比如：

extends

//<T extends 可以多个>，
//规则：
//<T extends 类&接口&接口>,类有且只能有一个，接口可以有多个。有类的情况下，类必须是第一个
public class AClass<T> {
     private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
};

-------
public class BClass{};
public class CClass extends BClass{};

-----
public class DClass{};

-----
public static void print(AClass<? extends BClass> par) {

}

//使用
AClass<CClass> cClass = new AClass();
AClass<BClass> bClass = new AClass();
AClass<DClass> dClass = new AClass();

print(cClass);
print(bClass);
print(dClass);//编译不通过。因为DClass不是BClass的派生类

//接着
AClass<? extends BClass> aClass = new AClass();
BClass bClass1 = new BClass();
CClass cClass1 = new CClass();
        
aClass.setT(bClass1);//编译不通过。因为set时，编译器只知道set的是BClass的子类，但具体是哪一个子类，编译器是无法知道的。
aClass.setT(cClass1);//编译不通过。
        
BClass bClass = aClass.getT();//这样可以。因为插入的肯定是BClass的派生类

为什么呢？请了解PECS原则
     PECS原则全称"Producer Extends, Consumer Super"，即上界生产，下界消费。
     通俗点：频繁往外读取内容的，适合用上界Extends

super

public static void main(String[] args) {
    AClass<BClass> bClass = new AClass();
    AClass<CClass> cClass = new AClass();

    print(bClass);
    print(cClass);//编译错误。CClass不是BClass的超类
     
    //再来
     
     AClass<? super BClass> bClass = new AClass();

     bClass.setT(new CClass());
     bClass.setT(new BClass());
     bClass.setT(new Object());//这里编译错误。因为如果插入的是BClass的超类，编译器就无法安全的转型为BClass。

     Object t = bClass.getT();//可以get，但是返回的是Object。因为编译器没办法知道返回的是什么超类，但是可以确定，肯定是Object的子类
     
     //这里胖子有疑问？
    	//既然jdk限制不让set超类，那get时，不就可以返回最上级的父类类吗？为什么还是返回Object呢？
     //有大神知道，可以告知小弟一下。
     
     
     //PECS原则全称"Producer Extends, Consumer Super"，即上界生产，下界消费。
     //经常往里插入的，适合用下界Super
     
}

public static void print(AClass<? super BClass> par) {
    System.out.println(par.getT());
}

最后

AClass<BClass> bClass = new AClass();
AClass<CClass> cClass = new AClass();


bClass和cClass没有什么实质性关系。在编译时，编译器会有一个叫“泛型擦除”，
     
执行  javap -c -s "路径"
     
     
     public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    Code:
       0: new           #2                  // class com/java/basic/Generic/AClass
       3: dup
       4: invokespecial #3                  // Method com/java/basic/Generic/AClass."<init>":()V
       7: astore_1
       8: new           #2                  // class com/java/basic/Generic/AClass
      11: dup
      12: invokespecial #3                  // Method com/java/basic/Generic/AClass."<init>":()V
                  
                  
------
                  
最后会变成：
         AClass bClass = new AClass();
	    AClass cClass = new AClass();         

结束

放空自己，重新出发。