目录

• 在集合中使用泛型
• 自定义泛型

在集合中使用泛型

/*
 * 在集合中使用泛型：
 * ① 在实例化集合类是，可以指明具体的泛型类型
 * ② 指明完之后，在集合类或接口中凡是定义类或接口时，内部结构使用到类的泛型的位置，都指定为实例化时泛型的类型
 * ③ 泛型的类型必须是类，不能是基本数据类型。包装类
 * ④ 如果实例化时没有指明泛型类型，默认类型为Object类型
 *
 * */

//在集合中使用泛型,以ArrayList举例
    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(12);
        list.add(23);
        list.add(45);
        list.add(89);
        //编译时，就会进行类型检查，保证数据安全
//        list.add("tin");
        //方式一：
        for(Integer score:list){
//            int stuScore = score;
//            System.out.println(stuScore);
            System.out.print(score + " ");
            //12 23 45 89
        }


        //方式二：
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            int stuScore = iterator.next();
            System.out.print(stuScore + " ");
            //12 23 45 89
        }
    }
    //在集合中使用泛型,以HashMap举例
    @Test
    public void test03(){
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("Tom",34);
        map.put("Jerry",78);
        map.put("Jack",90);
        //map.put(34,21);//编译不通过

        Set<Map.Entry<String,Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String,Integer>> iterator = entry.iterator();
        while(iterator.hasNext()){
            Map.Entry<String,Integer> e = iterator.next();
            System.out.println("姓名：" + e.getKey() + " 分数：" + e.getValue());
        }
    }

自定义泛型

order.java

package com.pan;

public class Order <T>{
    String orderName;
    int orderId;

    T orderT;
    public Order(){};
    public Order(String orderName, int orderId, T orderT){
        this.orderId = orderId;
        this.orderName = orderName;
        this.orderT = orderT;
    }

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

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系,跟类是不是泛型没有关系
    public <E> List<E> copyFromArrayToList(E[] arr) {
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr) {
            list.add(e);
        }
        return list;
    }
}

subOrder.java

package com.pan;

public class subOrder extends Order<Integer>{//不再是泛型类
}

class subOrder1<T> extends Order<T>{//依然是泛型类
    
}

@Test
    public void test4(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //如果定义了泛型，建议在实例化时指明类的泛型。
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");//这种方式不建议

        //建议使用这种方式
        Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");
        order1.setOrderT("order:ABBA");
    }

    @Test
    public void test5(){
        subOrder sub1 = new subOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不需要指明泛型。
        sub1.setOrderT(1122);

        subOrder1<String> sub2 = new subOrder1<>();
        sub2.setOrderT("order2...");
    }

@Test
    public void test6(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3,4};
        List<Integer> list = order.copyFromArrayToList(arr);
        System.out.println(list);
    }//[1, 2, 3, 4]

** 注意**

class Father<T1,T2>{}
/*子类不保留父类的泛型*/
//①没有类型 擦除
class Son1 extends Father{//等价于class Son extends Father<Object,Object>{};

}
class Daughter1<A,B> extends Father{
    
}
//②具体类型
class Son2 extends Father<Integer,String>{
    
}
class Daughter2<A,B> extends Father<Integer,String>{
    
}
/*子类保留父类的泛型*/
//①全部保留
class Son3<T1,T2> extends Father<T1,T2>{
    
}
class Daughter3<T1,T2,A,B>extends Father<T1,T2>{
    
}
//②部分保留
class Son4<T2> extends Father<Integer,T2>{
    
}
class Daughter4<T2,A,B> extends Father<Integer,T2>{
    
}