Java中泛型上下限及读写模式

在java中类的继承extends和super我们平常经常用到，但是还有上下限和读写模式需要了解，二者是不一样的东西

先定义FatherClass最为父类，ChildClass继承自FatherClass，SonClass继承自ChildClass

class FatherClass {
}

class ChildClass extends FatherClass {
}

class SonClass extends ChildClass {
}

1. 上限 extends关键字 可读不可写

上限 ：<? extends FatherClass>，?表示通配符，此句代表泛型的最高上限为FatherClass，为其传递的参数可以是任意FatherClass的子类。
通过extends修饰的泛型，拥有读取权限，没有修改写入权限

public class GenericTest<T extends String> {
    public FatherClass fatherClass = new FatherClass();
    public ChildClass childClass = new ChildClass();

    // extend 可读不可写
    // extend 上限 即list中的类型最高上限为FatherClass，可以是任意FatherClass的子类
    public void test1() {
        List<? extends FatherClass> list1 = new ArrayList<ChildClass>();
        FatherClass f = list1.get(0);// 可读
//        ChildClass c = (ChildClass) list1.get(0);// 可读，但是错误，

//        list1.add(fatherClass);// 不可写
//        list1.add(childClass);// 不可写


    }
}

2. 下限 super关键字 可写不可读

下限 ：<? super ChildClass>，?表示通配符，此句代表泛型的最低下限为ChildClass，为其传递的参数可以是任意ChildClass的子类。
通过extends修饰的泛型，拥有读取权限，没有修改写入权限

public class GenericTest<T extends String> {
    public FatherClass fatherClass = new FatherClass();
    public ChildClass childClass = new ChildClass();

    // ? super 可写不可读
    // ? super 下限，即list中的类型最低下限为childClass，可以是其任意父类
    public void test2() {
        List<? super ChildClass> list2 = new ArrayList<FatherClass>();
        // 不可读
//        FatherClass f =  list2.get(0);
//        ChildClass c =  list2.get(0);
        list2.add(childClass);
//        list2.add(fatherClass);
        list2.add(new SonClass());// 还能插入ChildClass的子类
    }
}

3. 应用

import java.util.ArrayList;
import java.util.List;

/**
 * java 泛型的上下限问题
 * 通配符  java  ?   kotlin *
 * 泛型的读取模式，与类中的extends没有关系
 *
 * T extends String 与上下限读取模式没有关系
 */
class FatherClass {
}

class ChildClass extends FatherClass {
}

class SonClass extends ChildClass {
}


public class GenericTest<T extends String> {
    public FatherClass fatherClass = new FatherClass();
    public ChildClass childClass = new ChildClass();


    // 可读不可写
    private void forShow(List<? extends FatherClass> list) {
        FatherClass f = list.get(0);

//        list.add(childClass);
//        list.add(fatherClass);
    }

    void test3() {
        List<ChildClass> list = new ArrayList<>();
        forShow(list);
    }

    // 可写不可读
    private void forAdd(List<? super ChildClass> list) {
//        list.add(fatherClass);// 错误，不支持父类？
        list.add(childClass);

        // 不可读
//        ChildClass c = list.get(0);
//        FatherClass f =  list.get(0);
    }

    void test04() {
        List<FatherClass> list = new ArrayList<>();
        forAdd(list);
    }

}