Day 9 泛型

一、在集合中使用泛型

泛型：把元素的类型涉及成一个参数，这个类型参数叫做泛型（JDK 5.0）

在集合中使用泛型之前的情况：

public void test(){
     ArrayList list = new ArrayList();
     list.add(78);
     list.add(89);
     list.add(92);
     list.add("Tom");
     //问题一：类型不安全
     for(Object score : list){
        //问题二：强转时，有可能出现ClassCastException
        int stuScore = (Integer)score
        System.out.println(stuScore)
      }
}

在集合中使用泛型的情况：（以ArrayList为例）

public void test(){
     ArrayList<Integer> list = new ArrayList<Integer>();
     list.add(67);
     list.add(78);
     //编译时，会进行类型检查，下行代码会报错
     list.add("Tom");
     //方式一：
     for(Integer score : list){
         //避免了强转操作
         int stuScore = score
         System.out.println(stuScore)
         }
     //方式二：
     Iterator<Integer> iter = list.iterator();
     while(iter.hasNext()){
         int score = iter.next();
         System.out.println(score)
         }

在集合中使用泛型的情况：（以HashMap为例）

public void test(){
     Map<String,Integer> map = new HashMap<String,Integer>();
     map.put("Tom",20);
     map.put("Jerry",18);
     Set<Map.Entry<String,Integer>> entry = map.entrySet();//泛型嵌套
     Iterator<Map.Entry<String,Integer>> iter = entry.iterator();//敲后面，然后alt+enter
     while(iter.hasNext()){
        Map.Entry<String,Integer> e = iter.next();//敲后面，然后alt+enter
        String key = e.getKey();
        Integer value = e.getValue();
        System.out.println(key + "--------" + value);
}

总结：

1. 集合接口或集合类在JDK 5.0时都修改为带泛型的结构
2. 在实例化集合类时，可以指明具体的泛型结构
3. 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（方法、属性、构造器等）使用到类的泛型的位置，都指定为实例化时泛型类型
4. 泛型的类型必须是类，不能是基本数据类型
5. 如果实例化时，没有指明泛型的类型，则默认类型为java.lang.Object类型

二、自定义泛型结构：泛型类、泛型接口、泛型方法

泛型类：

public class Order<T>{
     String orderName;
     int orderID;
     //类的内部结构就可以使用类的泛型
     T orderT;
     public Order();
     public Order(String orderName,int orderID,T orderT){
         this.oederName = ordername;
         this.orderID = orderID;
         this.orderT = orderT;
      }
     public T getOrderT(){
         return orderT;
         }
     public void setOrderT(T orderT){
         this.orderT = orderT;
         }
}

public class GenericTest(){
     public void test1(){
         //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型,以下三行不会报错
         Order order = new Order();
         order.setOrderT(123);
         order.setOrderT("ABC");
         //要求：如果定义了类是带泛型的，建议在实例化时要指明类的泛型
         Order<String> order1 = new Order<String>();
         Order<String> order2 = new Order<String>("orderAA",001,"order:AA");
         order2.setOrderT("AA:hello");
      }
    public void test2(){
         //由于子类在继承带泛型的父类时，指明了泛型类型，则实例化子类对象时，不需要再指明泛型
         SubOrder sub = new SubOrder();
         sub.setOrderT(1234);//Integer类型
      }
    public void test3(){
         SubOrder1<String> sub2 = new SubOrder1<>();//自动类型填充，后一个尖括号内可不填
         sub2.setOrderT(fine);//String类型
     }
}


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


public class SubOrder1<T> extends Order<T>{//SubOrder1仍然是泛型类
    }

注意：

1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内，比如: <E1,.E2,E3>
2. 泛型类的构造器如下：

 public Order(){};
 public Order<E>(){};//错误

3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致
4. 泛型不同的引用之间不能相互赋值
5. 尽管在编译时ArrayList<String> 和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM
6. 泛型如果不指定，将会被擦除，泛型对应的类型均按照Object处理，但不等价与Object(继承方面的区别)
7. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象
8. 泛型的指定中不能使用基本数据类型，可以用包装类替换
9. 异常类不能声明为泛型类
10. 静态方法不能使用类的泛型（与加载时间有关）
11. 父类有泛型，子类可以选择保留泛型，也可以选择指定泛型类型,还可以增加泛型

class Father<T1,T2>{}
//1.子类不保留父类的泛型

//1.1没有类型，擦除
class Son1 extends Father{}//等价于class Son1 extends Father<Object,Object>{}
//1.2具体类型
class Son2 extends Father<Integer,String>{}

//2.子类保留父类的泛型

//2.1全部保留
class Son3 extends Father<T1,T2>{}
//2.2部分保留
class Son4 extends Father<Integer,T2>{}

泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。换句话说，泛型方法所属的类是不是泛型类都没有关系。

public List<E> = copyFromArrayToList(E[] arr){
//这里是想写一个泛型类的数组，但是这样写编译器不会认为E是一个泛型参数，而是认为E就是一种类型，正确写法如下
public <E> List<E> = copyFromArrayToList(E[] arr){
     ArrayList<E> list = new ArrayList<>();
     for(E e : arr){
        list.add(e)
        }
     return list;
}

public void test(){
     //假设上述方法定义在Order类中
     Order<String> order = new Order<>();
     Integer[] arr = new Integer[]{1,2,3,4};
     //泛型方法在调用时，指明泛型参数的类型
     List<Integer> list = oeder.copyFromArrayToList(arr);
     System.out.println(list);
}

三、泛型在继承方面的体现

public void test(){
     //1.0
     Object obj = null;
     String str =null;
     obj = str;//正确
     //2.0
     Object[] arr1 = null;
     String[] arr2 = null;
     arr1 = arr2;//正确
     //3.0
     List<Object> list1 = null;
     List<String> list2 = null;
     list1 = list2;//错误，此时list1与list2不存在子父类关系
}

说明：
虽然类A是类B 的父类，但G<A>和G<B>不具备子父类关系，二者是并列关系。
补充：类A是类B的父类，A<G>是B<G>的父类，比如List<String>与ArrayList<String>

四、通配符的使用

public void test(){
     List<Object> list1 = null;
     List<String> list2 = null;
     List<?> list = null;
     list = list1;//正确
     list = list2;//正确
}

类A是类B 的父类，G<A>和G<B>是没有关系的，二者共同的父类是G<?>
有限制条件的通配符：

? extends Person//?小于等于person
? super Person//?大于等于person