Java 泛型，上界（生产者），下界（消费者）总结

Java泛型

1，什么是泛型

Java泛型是J2 SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

2，作用

第一是泛化。可以用T代表任意类型Java语言中引入泛型是一个较大的功能增强不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了，这带来了很多好处。

第二是类型安全。泛型的一个主要目标就是提高ava程序的类型安全，使用泛型可以使编译器知道变量的类型限制，进而可以在更高程度上验证类型假设。如果不用泛型，则必须使用强制类型转换，而强制类型转换不安全，在运行期可能发生ClassCast Exception异常，如果使用泛型，则会在编译期就能发现该错误。

第三是消除强制类型转换。泛型可以消除源代码中的许多强制类型转换，这样可以使代码更加可读，并减少出错的机会。

第四是向后兼容。支持泛型的Java编译器（例如JDK1.5中的Javac）可以用来编译经过泛型扩充的Java程序（Generics Java程序），但是现有的没有使用泛型扩充的Java程序仍然可以用这些编译器来编译。

3，泛型定义及使用

包括类泛型，接口泛型，方法泛型

在讲泛型之前，先要了解一个概念：泛型擦除

泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。

List l1 = new ArrayList();
List l2 = new ArrayList();
        
System.out.println(l1.getClass() == l2.getClass());

打印的结果为 true 是因为 List和 List在 jvm 中的 Class 都是 List.class。

泛型信息被擦除了。

• 3.1，泛型类和泛型接口

如果定义的一个类或接口有一个或多个类型变量，则可以使用泛型。泛型类型变量由尖括号界定，放在类或接口名的后面，下面定义尖括号中的T称为类型变量。意味着一个变量将被一个类型替代，替代类型变量的值将被当作参数或返回类型。对于List接口来说，当一个实例被创建以后，T将被当作一个函数的参数。下面分别是泛型类、泛型接口的定义：

• 3.1.1，泛型类定义

//泛型类定义
class Generic{
    T property;

    Generic(T property){
        this.property = property;
    }

    T getProperty(){
        return property;
    }
}

class Generic1{
    T name;
    A age;
    P price;

    Generic1(T name ,A age,P price){
        this.name = name;
        this.age =age;
        this.price = price;
    }

    public A getAge() {
        return age;
    }

    public T getName() {
        return name;
    }

    public P getPrice() {
        return price;
    }
}

• 3.1.2，泛型接口定义

//泛型接口定义
interface TInterface {
    void printInfo(T info);
}

class ShowInfo implements TInterface{

    @Override
    public void printInfo(T info) {
        System.out.println("info = " + info);
    }
}

• 3.1.3，泛型方法定义

//泛型方法定义
public static  T getGenericProperties(T pro){
        return new Generic(pro).getProperty();
}

//泛型可变参数
public static  void printArgs(T... args){
    int i=0;
    for(T arg:args){
        System.out.println("arg"+ i++ +" = " + arg);
    }
}

3.2，泛型使用

• 3.2.1，泛型类调用

public static void main(String args[]) {
    
    //泛型的类型实参，只能是类类型的，不能是基础类型
    //如果按下下面这种方式写的话会报错，举个例子：
    //int a= 8888；
    //Generic aInt = new Generic(a);
    //上面这种写法，编译器会报错
    Generic gStr = new Generic("name");
    Generic gInt = new Generic(888);
    Generic gFloat = new Generic(88.88f);
    
    System.out.println("gstr  = "+gStr.getProperty()+",gInt = "+gInt.getProperty()+",gFloat = "+gFloat.getProperty());
}

运行结果如下：

gstr  = name,gInt = 888,gFloat = 88.88

定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

参考如下写法：

public static void main(String args[]) {
    Generic gStr = new Generic("name");
    Generic gInt = new Generic(888);
    Generic gFloat = new Generic(88.88);
    System.out.println("gstr  = "+gStr.getProperty()+",gInt = "+gInt.getProperty()+",gFloat = "+gFloat.getProperty());

}

运行结果如下：

gstr  = name,gInt = 888,gFloat = 88.88

由此结果可知，使用泛型，能够方便的使用不同类型的数据，可以很好的提高针对不同类型数据处理时，代码的复用性。

这里说一个原始类型：

缺少实际类型变量的泛型就是一个原始类型，举个例子：

Generic gStr = new Generic("name");

这里Generic就是Generic的原始类型

 

注意：

1. 泛型实参不能使用基础类型，必须是类类型的
2. 不能对确切的泛型类型使用instanceof操作，如下面编写会报错

if(gInt instanceof Generic){
            
}

//只能写为如下方式：
if(gInt instanceof Generic){
            
}

• 3.2.2，泛型接口调用

public static void main(String args[]) {
    ShowInfo info = new ShowInfo();
    info.printInfo(8);
    info.printInfo("xxxxxxx");
}

运行结果如下：

info = 8
info = xxxxxxx

3.2.3，泛型方法调用

public static void main(String args[]) {
    System.out.println("getGenericProperties = " + getGenericProperties(8)+","+getGenericProperties("x8x8x8"));
    printArgs(888,888.888,"dddsg");
}

运行结果如下：

getGenericProperties = 8,x8x8x8
arg0 = 888
arg1 = 888.888
arg2 = dddsg

4，泛型上界（生产者Producer），下界（消费者Consumer）

1. 上界，通配符表示为，只能读取，不能写入（生产者只能读取）；使用固定上边界的通配符的泛型可以接收T及其所有子类类型的数据，这里的T可以是类也可以是接口
2. 下界，通配符表示为，只能写入，不能读取（消费者只能写入）；所有固定下边界的通配符的泛型可以接收T及其所有超类类型的数据。

这里有个小技巧记忆，我们将上面两种通配符表示为：PECS

PECS：Producer extends Consumer super

• 4.1，泛型上界的基础用法

举个例子，我们都知道Integer是Number的子类，但是List并不是List的子类，编译器没法知道他们的继承关系，上代码：

public static void main(String args[]) {
    List nums = new ArrayList<>();
    List integers = new ArrayList<>();
    //Integer是Number的子类，但是List并不是List的子类，故不能直接赋值
    //nums = integers; //此处编译器会报错
    //但是通过通配符？List就可以赋值了
    List numbers = new ArrayList<>();
    //? extends Number定义上界为Number，所以变量numbers可以接受Number和Number的所有子类赋值
    numbers = integers;
    List floats = new ArrayList<>();
    numbers = floats;

    //在集合中使用泛型通配符，要记得PECS规则，生产者只能读取，不能写入（除了null）
    numbers.add(null); //编译器不会报错
    numbers.add(999); //编译器会报错
    //上界通配符无法写入，但是可以正常读取
    Number num = numbers.get(0);
    //如果要获取的类型是Number的子类，则必须使用强制类型转换
    int i = (Integer)numbers.get(0);
    
}

1，通过上界通配符，就可以接受T以及T子类类型的数据赋值，上述例子中，Integer和Float都是Number的子类；

2，上界（生产者）不能写入，此处注意null是所有引用类型都有的元素，可以add成功，其他类型元素均不行。这是因为在给numbers调用add方法的时候，编译器无法确定具体添加的是List、List、还是List等其他类型，这样会导致类型不一致的问题，这样就和泛型的初衷相悖了，故Java为了保证类型的一致性，禁止这样做。

换个说法可能好理解一些：子类可以赋值给父类对象，但是父类对象是无法直接赋值给子类对象的（需要强制转换）；

原因也很好理解，因为子类继承自父类，自然拥有父类的所有属性，所以子类对象可以赋值给父类；但是父类对象无法直接赋值给子类对象，原因是子类对象可能会添加新的属性、方法，那么父类对象中是没有这些子类新添加的属性的，会造成数据丢失。

故上界可以应用于一些只读的场景，如果需要既能读，又能写，那么只能用确定的泛型类型，比如List这样List就只能接受Integer类型的数据，同时也可以进行读写操作；既能读，又能写的场景就无法使用？通配符了。

同样用之前我们自己写的Generic类做个测试，代码如下：

public static void main(String args[]) {
    Generic gStr = new Generic("name");
    Generic gInt = new Generic(888);
    Generic gFloat = new Generic(88.88f);
    
    Generic gNum = new Generic(999);
    gNum = gInt; //此处编译器会报错，Generic和Generic没有任何继承关系
    gNum = gFloat; //此处编译器会报错，Generic和Generic没有任何继承关系
    //我们可以用上界通配符，让gNum可以接受Number以及Number的子类
    Generic gNum1 = new Generic(999);
    gNum1 = gInt; //可以正常赋值
    gNum1 = gFloat;//可以正常赋值
}

4.2 ，泛型下界的基础用法

下界通配符，可以接受T类以及T的所有父类的赋值，在集合中使用时，可以add所有T类以及T子类的数据，看代码：

class Base {
    String name;
    int age;

    void printProPerties(){
        System.out.println("name = "+name+",age = "+age);
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Person extends Base {

    String addr;

    Person(){

    }

    Person(String addr,String name,int age){
        this.addr = addr;
        this.name = name;
        this.age = age;
    }

    @Override
    void printProPerties() {
        //super.printProPerties();
        System.out.println("addr = "+addr);
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public void setAge(int age) {
        super.setAge(age);
        System.out.println("Persion setAge");
    }

    @Override
    public void setName(String name) {
        super.setName(name);
        System.out.println("Persion setAge");
    }
}

public static void main(String args[]) {
    ArrayList list2 = new ArrayList<>();
    //用add方法添加的时候，只能接受Person类以及Person子类类型
    //注意在集合中使用时，只能接受下界和下界的子类型，比如调用集合的add方法，那么只能接受Person和Person的子类
    Person person = new Person();
    Base base = new Base();
    list2.add(person);
    list2.add(base);//此处会报错
    //如果要添加，只能通过强制转换，但要小心数据丢失
    list2.add((Person) base);//此处不会报错

    //消费者只能写入，不能读取
    Base base1 = list2.get(0);//此处会报错，因为消费者只能写入，不能读取
    //如果一定要读取，那么需要通过显式的强制转换，告诉编译器，具体要接收那种类型的数据
    Base base2 = (Base)list2.get(0);//此处不会报错    
    Person person1= (Person)list2.get(0);//此处不会报错

    List list3 = new ArrayList<>();
    list2 = list3;//此处会报错，要知道List并不是List的父类，注意文章开头提到的类型擦除

    //换成我们之前的Generic类
    Generic gb = new Generic(base);
    Generic gp1 = new Generic(person);
    gp1 = gb;//此处会报错，Generic 和Generic没有继承关系
    Generic gp2 = new Generic(person);
    gp2 = gb;//使用下界通配符，可以正常编译，不会报错，因为在此处Base是Person的父类，而下界通配符就是可以接受下界（Person）以及下界（Person）的超类赋值的。
    
}

关于下界通配符：

下界通配符可以接受下界以及任何下界的超类的赋值

但是在List中使用时候，list添加的时候只能接受下界以及下界的子类，这个跟下界在其他泛型类中的使用是不同的，这个需要注意。

总结：

1. java中，Array是不能使用泛型的
2. List