集合框架——泛型机制的使用

泛型的作用：用来约束java传参数的数据类型的一种规则

泛型的使用场景：
1、可以在接口之上使用泛型
2、可以在类之上使用泛型
3、可以在方法之上使用泛型
4、方法的参数可以使用泛型

接下来进行测试
测试文件

/**
 * 测试泛型
 * 泛型的使用场景：
 * 1、泛型可以使用在及接口之上
 * 2、泛型可以用在类上
 * 3、泛型可以使用在方法返回值类型上
 * 4、泛型可以使用在参数之上
 *
 * 泛型：就是也用来约束程序编写时数据类的一种规则。
 */
@Test
public void m1(){
    Sum<Integer,String > sum = new Sum<Integer,String>();
    sum.A1(1,"大炮仗");
    System.out.println(Sum.A2("我是一个寂寞的人"));
}

面向对象文件

public class Sum<T,E> {
    //类里面的一般方法
    public void A1(T a,E b){
        System.out.println("当前的元素是："+a+" "+b);
    }
    //类里面有参数返回值的静态方法
    public static <E>E A2(E b){//只能有一个返回值对象
        return b;
    }
/**
 * 从主函数里面传过来什么参数，该参数就初始化为类型
 * 还可以在同一个主函数下重复调用
 */
}

运行结果

泛型通配符（形式）:

?
? extends T
? super T

特别注意
使用泛型通配符?的时候不能使用add方法添加元素，原因是？号的类型不能确定，所以不能添加元素，但是可以将另外一个集合引用对象赋值于它。

报错结果为：

@Test
public void m2(){
    /**
     * 注意：使用泛型通配符<?>时，不能用.add()的方法添加元素，原因是?号的数据类型不知道
     * 但是可以将可以将另一个引用对象赋值给他，因为这个引用对象的数据类型已经都确定了
     */
    List<?> list = new ArrayList<>();
    List list01 = new ArrayList<>();
    list01.add(222);
    list01.add("dfegrt");
    list = list01;
    list01.forEach(new Consumer() {
        @Override
        public void accept(Object o) {
            System.out.println("list01当前的元素是："+o);
        }
    });
}

或者：

@Test
public void m1(){
    Sum<?,?> sum = new Sum<>();
    Sum<Integer,String > sum01 = new Sum<>();
    sum01.A1(1,"大炮仗");
    sum = sum01;
    System.out.println(Sum.A2("我是一个寂寞的人"));
}

测试泛型机制的上限：

   /**
     * 测试泛型的上限
     *使用形式：
     * ? extends T：？表示只能是T的一个子类或本类
     */
    @Test
    public void m3(){
        List<? extends A> list = new ArrayList<>();//继承也可以多态哦
        B b = new B();
//        list.add(b);
      /**
       * 不能够添加：原因是A的子类可能不止一个（就算只有一个也不行），所以?号的类型不能确定，所以不能添加
       * 但是也可以把其他引用对象赋值给它
       */
      List<B> list1 = new ArrayList<>();
      list1.add(b);
      list = list1;
    }
    @Test
    public void m4(){
        List<? extends A> list = new ArrayList<>();//继承也可以多态哦
        C c = new C();//此处的C不是A的子类
        List<C> list2 = new ArrayList<>();
        list2.add(c);
        list = list2;//会报错，原因是C类没有继承A类
    }

总结：
泛型机制的上限? extends T：？表示只能是T的一个子类或本类，可以用于将已知确定数据类型引用对象赋值给它使用。(不能将父类用.add()方法添加进去)

泛型机制的下限

    /**
     * 测试泛型机制的下限
     * ? super T:?号表示是T类的父类或者本类
     */
    @Test
    public void m5(){
        List<? super B> list = new ArrayList();
        List<A> list01 = new ArrayList();
        B b = new B();
        A a = new A();
        C c = new C();
        list.add(b);//b是本类自己的引用对象
        list.add(c);
//        list.add(a);//a是B的父类对象,不能添加的原因是：子类对象完全可以确定
        list01.add(a);
        list = list01;
        list01.add(a);
	list = list01;
	System.out.println(list.get(1));
    }

报错结果

小结：
如果要添加元素监视使用下限? extends T形式
如果要把一个集合的对象引用赋值给另外一个集合，建议使用
上限? extends T的形式