Day 16 (泛型)

 

目录

一、概念

二、自定义泛型类

三、泛型类

四、通配符

---

一、概念

    @Test
    public void test(){
        //在集合中使用泛型:ArrayList
        ArrayList list = new ArrayList();
        list.add(12);
        list.add(1);
        list.add(2);
        list.add(0);

        //遍历方式一：采用foreach
        for (Integer score : list) {
            System.out.println(score);
        }
        //遍历方式二：采用Iterator
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Integer stuScore = iterator.next();
            System.out.println(stuScore);
        }
    }

         * 集合的输出利用Iterator接口完成；Map没有提供直接的Iterator接口
         * 使用Collection保存数据，直接保存所有对象
         * 使用Map保存数据时，所保存的key和value自动包装成Map.Entry接口对象
         *
         * Map利用Iterator：
         *      1、利用entrySet()方法将Map中的数据转换为Set接口实例；
         *      2、使用Set中的迭代iterator()方法
         *      3、每一次迭代都是取出Map.Entry接口实例，在创建该接口实例，调用getKey()                         
         *       getValue()方法获取相应的key-value值

//HashMap中使用泛型
    @Test
    public void test1(){
        //直接指定key-value的类型
        HashMap map = new HashMap<>();
        map.put("aa",100);
        map.put("bb",900);
        map.put("cc",200);
        map.put("dd",300);
        map.put("ee",400);
        
        Set> set = map.entrySet();
        Iterator> iterator = set.iterator();
        while (iterator.hasNext()){
            Map.Entry e = iterator.next();
            System.out.println(e.getKey() + "==" + e.getValue());
        }
    }

二、自定义泛型类

父类为泛型类

//泛型类
class Order {
    String name;
    int Id;

    //类的内部结构可以使用类的泛型
    T orderT;

    public Order(){}

    public Order(String name, int Id, T orderT) {
        this.name = name;
        this.Id = Id;
        this.orderT = orderT;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "GenericClass{" +
                "name='" + name + ''' +
                ", Id=" + Id +
                ", orderT=" + orderT +
                '}';
    }
}

 子类继承泛型类：

//subOrder1是泛型类
class subOrder1 extends Order{}

//subOrder继承Order  并指明泛型   此时subOrder不是泛型类
class subOrder extends Order{}

    //实例化 泛型类 时 指明为String类型
 Order order1 = new Order("marry",22,"aa");

        //子类在继承带泛型的父类时，已经指明了泛型，则在实例化时不需要指明了
        subOrder subOrder = new subOrder();
        subOrder.setOrderT(123);

        //在继承时为指明类型 则实例化需要指明类型
        subOrder1 subOrder1 = new subOrder1<>();
        subOrder1.setOrderT("string类型");

子类继承泛型类的情况： 

class Father{}
//子类不保留父类的泛型
    //(1)没有类型，擦除  
class son1 extends Father{}
    //(2)具体类型  
class son2 extends Father{}
//子类保留父类的泛型
    //(1)全部保留
class son3 extends Father{}
    //(2)部分保留
class son4 extends Father{}

class Father{}
//子类不保留父类的泛型
    //(1)没有类型，擦除
class son1 extends Father{}  //子类另外指明泛型
    //(2)具体类型
class son2 extends Father{}
//子类保留父类的泛型
    //(1)全部保留
class son3 extends Father{}
    //(2)部分保留
class son4 extends Father{}

三、泛型类

在Order泛型类中声明一个泛型方法，其中泛型方法的泛型参数E与该类的泛型参数T没有关系 

泛型方法1：

    //返回值是一个List,并且声明为泛型结构
    //传入T类型的数组：比如形参int[] arr 则返回值为int型的集合
    //此处可以将该方法声明为static，因为泛型方法与所处的类没有关系，在该方法调用的时候才确定泛型参数的类型
    public static  List show(E[] arr){
        ArrayList list = new ArrayList<>();
        for(E t : arr){  //遍历arr，并将arr的每一值赋给T类型的变量t
            list.add(t);  //将变量t添加到集合list中去
        }
        return list;
    }

    //测试泛型方法
    @Test
    public void test(){
        //泛型类指明为String类型
        Order order = new Order<>();
        //声明一个double型的数组
        Double[] arr = {1.0, 2.0, 4.5, 6.8};
        //调用泛型类中的泛型方法，在调用时，指明泛型参数的类型
        List list = order.show(arr);//与类的泛型参数可以无关
        System.out.println(list);  //[1.0, 2.0, 4.5, 6.8]
    }

泛型方法2：

    //定义返回值类型为A的泛型方法
    public  A method(A a){
        return a;
    }

        //调用泛型方法
        int i = 6;
        System.out.println(order.method(i)); //6

四、通配符

一般形式的通配符：

        List