Java基础 -＞ 泛型＜E e＞

 /**
     * 泛型：ArrayList<String>:<>,里面是什么类型的，add就只能添加该类型的；
     *          必要是一个类，不能是基本数据类型（int），要用包装类integer；
     *      public class ArrayList<E> extends AbstractList<E>；
     *          ArrayList<Object>：就是所有类型的了；
     */
    @Test
    public void tset2(){
        ArrayList<String> stringArrayList = new ArrayList<>();
        stringArrayList.add("asd");
        stringArrayList.add("qwe");
        //java: 不兼容的类型: int无法转换为java.lang.String
        //stringArrayList.add(12);报错
        System.out.println(stringArrayList);//[asd, qwe]
        //遍历1：
        //iterator:一开始new的时候指定了类型，之后都是该类型的；
        Iterator<String> iterator = stringArrayList.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next() + "\t");//asd	qwe
        }
        System.out.println();
        //遍历2：
        for (Object obj : stringArrayList){
            System.out.print(obj + "\t");//asd	qwe	
        }
    }

/**
     * 泛型：Map：HashMap<integer，String>()，同List
     */
    @Test
    public void test3(){
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "11");
        map.put(2, "22");
        map.put(3, "33");
        //java: 不兼容的类型: java.lang.String无法转换为java.lang.Integer
        //map.put("3", "33");
        //遍历1:
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iterator = entrySet.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next() + "\t");//1=11	2=22	3=33
        }
        System.out.println();
        //遍历2:
        for (Object obj : map.entrySet()){
            System.out.print(obj + "\t");//1=11	2=22	3=33
        }

    }

自定义泛型类（接口）：

public class Test919<E> {
 @Test
    public void test4(){
        //T为integer类型
        Test919<Integer> test919 = new Test919<>();
        test919.setTest(13);
        System.out.println(test919.getTest());//13
        System.out.println(test919.toString());//Test919{name='null', old=0, test=13}
    }
    /**
     * 自定义泛型类
     */
    public String name = "aaa";
    public int old = 22;
    E test;

    public Test919() {
    }


    public E getTest() {
        return test;
    }

    public void setTest(E test) {
        this.test = test;
    }

    @Override
    public String toString() {
        return "Test919{" +
                "name='" + name + '\'' +
                ", old=" + old +
                ", test=" + test +
                '}';
    }

附加

	 /**
     * 静态方法不能使用泛型，异常类也不能使用
     */
    public static void show(){
        System.out.println(test);//报错
    }

public void shuZu(){
        //不允许这样new数组
        E[] es = new E[];
        
        //正确;强制转换
        E[] e = (E[]) new Object[10];
    }

泛型方法：

    /**
     * 泛型方法：与其他无关，类可以不是泛型，接口是不是泛型都与泛型方法本身无关
     *              可以使用static；
     * 	格式：public <T> class<T> method(T[]/T arr){}
     */
    public static <T> List<T> shuZu(T[] arr){
        ArrayList<T> arrayList = new ArrayList<>();
        for (T t : arr){
            arrayList.add(t);
        }
        return arrayList;
    }

通配符<？>:

        List<Object> list = new ArrayList<>();
        ArrayList<String> list1 = new ArrayList<>();
        //泛型不允许，出现string赋给object：子类赋给父类，都是平级的
        //list = list1;//报错
        ArrayList<String> list2 = new ArrayList<>();
        list1 = list2;
        //通配符：？
        //<?>:是所有泛型的父类，其他泛型都是平级的
        List<?> list3 = new ArrayList<>();
        //list = list3;报错；还是不识别，父泛型不能赋给子泛型
        list3 = list;//可以识别,任何的泛型都可以赋给<?>泛型
        list3 = list1;
        list3 = list2;
        //<?>泛型：缺点，<?>对象只能添加null，其他是如何类型都不允许添加进去了 
        //查
        Object o = list3.get(0);
        //删
        list3.remove(1);

通配符<？>附加:

    /**
     * ? extends Name:<?>只能作用于Name的子类（包含Name）：[-无穷，Name]
     * ? super Name：<?>只能作用于Name的父类（包含Name）：[Name,+无穷]
     */
    @Test
    public void test5(){
        List<? extends Person> list = null;
        List<? super Person> list1 = null;
        
        List<Student> list2 = null;
        List<Person> list3 = null;
        List<Object> list4 = null;

        list = list2;
        list = list3;
        //list = list4;会报错，Object不是Person的子类
        
        //list1 = list2;会报错，Student不是Person的父类
        list1 = list3;
        list1 = list4;
    }