day_11_java高级编程_泛型_通配符 （560~574）

泛型

泛型：标签 ：将元素类型设置为参数–>泛型
相当于预先规定了当前集合存储的数据类型，再使用当前集合时，自动规范数据类型。
泛型只能是类，不能是基本数据类型,此类可以是任意类，不一定是包装类,没指定默认为Object

当使用泛型后，重写compateTo 和compare方法时不再需要（Obiect o instanceof 指定类）再强转了
因为集合中的类型已经规定了，不符合的添加不到集合中，所以直接renturn compare()的结果就可

    @Test
    public  void  test3(){

        ArrayList<Integer> i = new ArrayList<>();
        i.add(1);
        i.add(5);
        Iterator<Integer> iterator = i.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }


    @Test
    public  void  test4() {

        HashMap<String, Integer> map = new HashMap<>();
        map.put("杨森", 23);
        Set<Map.Entry<String, Integer>> entries = map.entrySet();//泛型嵌套
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> next = iterator.next();
            String key = next.getKey();
            Integer value = next.getValue();
            System.out.println(key + "-->" + value);

        }
    }
        @Test
        public  void  test5() {
            HashMap<goods, Integer> goodsIntegerHashMap = new HashMap<>();


        }

自定义泛型类：

public class fanxing<T> {
    private  String name;
    private  int  age;
    T      order;

将T作为一个数据类型使用，可以对order实现get set方法以及构造器中也可使用
在实现这个类的时候可以指明该T的具体类型，但必须是类，必能是基本数据类型

        @Test
        public  void  test5() {
            fanxing<Integer> fanxing = new fanxing<Integer>();
            fanxing.setOrder(133);
            System.out.println(fanxing.getOrder());
            //fanxing.setOrder("123");//非Integer 无法赋值
            System.out.println(fanxing.getOrder());

        }

当带泛型的类被继承时，子类不再需要再指定泛型

class testclas extends  fanxing<Integer>{
}

testclas testclas = new testclas();
testclas.setOrder(123);

也可不指定，子类同时为泛型类

class testclas1<T> extends  fanxing<T>{
}

静态结构不能使用泛型

// T[] arr = new T[10];//T不能直接实例化
T[] arr = (T[]) new Object[10];//通过声明Object再强转

泛型方法

泛型方法：是在调用方法的时候指明泛型的具体类型

    public <E> List<E> fun(E[] arr){
        ArrayList<E> es = new ArrayList<E>();
        System.out.println(es);
        
        return  es;
    }

例如：

    public <E> E fun(E[] arr){
        E e = arr[0];
        return  e;
        
    }
}

      @Test
        public void test6(){
            fanxing<Integer> integerfanxing = new fanxing<>();
            Integer[] integers = {1, 2, 3, 4, 5, 6};
            Integer fun = integerfanxing.fun(integers);
            System.out.println(fun);
        }

当调用fun时填入的数据类型会自动确定返回值的数据类型，因此泛型方法可以声明为static

List list1 = null;
List list2 = null;
虽然string是object的子类，但是此时list1与list2为两种毫无关系的对象，
不能将list2赋值给list1 List1 = List2 //报错
但是可以通过通配符,同时与List1、List2建立联系
List List3 = null;

public void fun(List<?> list){
System.out.println(list);
}

此方法可以传入list1也可传入list2
但是只能读不能写

List list1 = null; -----此时G是G<##>，或G<##的子类>父类
List list2 = null; -----此时G是G<##>，或G<##的父类>父类 //此时G中可以写入##类及其子类型的数据