12.泛型

一.泛型的理解

1.泛型的概念

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者某个方法的返回值及参数类型。这个类型参数将在使用时(例如，继承或实现这个接口)，用这个类型声明变量、创建对象时确定(即传入实际的类型参数，也称为类型实参。)

2.泛型的引入背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>,List<E>,ArrayList<E>,这个E就是类型参数，即泛型。

二.泛型在集合中的使用

1.在集合中使用泛型之前的例子

java

@Test
public void test(){
    ArrayList list = new ArrayList();
    list.add(78);
    list.add(98);
    list.add(88);
    // 问题一：类型不安全
    // list.add("Tom");
    for(Object score :list){
        // 问题二：强转时，可能出现ClassCastException
        int stuScore = (Integer) score;

        Syetem.out.println(stuScore)
    }
}

2.在集合中使用泛型例子 1

java

@Test
public void test2(){
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(78);
    list.add(98);
    list.add(88);
    // 编译时，就会进行类型检查，保证数据的安全
    // list.add("Tom");
    // 方式一： 避免强转操作
    for(Object score :list){
        int stuScore = score;
        Syetem.out.println(stuScore)
    }

     // 方式二：
    Iterator<Integer> interator = list.interator();
    while(interator.hasNext()){
        int stuScore = interator.next();
        Syetem.out.println(stuScore)
    }
}

3.在集合中使用泛型例子 2

java

@Test
public void test3(){
    // Map<String,Integer> map = new HashMap<String,Integer>();
    // jdk7新特性：类型推断
    Map<String,Integer> map = new HashMap<>();
    map.put("Tom",78);
    map.put("Jack",98);
    map.put("Jerry",88);

    // 类型的嵌套
    Set<Map.Entry<String,Integer>> entry = map.entrySet();
    Iterator<Map.Entry<String,Integer>> interator = entry.interator();
    while(interator.hasNext()){
        Map.Entry<String,Integer> e = interator.next();
        String key = e.getKey();
        Integer value = e.getValue();
        Syetem.out.println(key + "---" + value);
    }
}

4.集合中使用泛型总结

集合接口或集合类在jdk5.0时都修改为带泛型的结构。
在实例化集合类时，可以指明具体的泛型类型。
指明完以后，在集合类或接口中凡是定义类或接口时，内部结构(比如：方法、构造器、属性等使用到类的泛型的位置)，都指定为实例化的泛型类型)。比如add(E e) => 实例化以后：add(Integer e);
注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
如果实例化时，没指明泛型的类型。默认类型是java.lang.Object类型

三.自定义泛型类、泛型接口、泛型方法

1.举例

【Order.java】

java

public class Order<T>{
    String orderName;
    int orderId;
    // 类的内部结构就可以使用类的泛型

    T orderT;

    public Order(){
        // 编译不通过
        // T[] arr = new T[10];
        // 编译通过
        T[] arr = (T[]) new Object[10];
    }

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

    // 如下的这个方法都不是泛型方法
    public T getOrderT(){
        return orderT;
    }

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

    @Override
    public String toString(){
        return  orderName + orderId + orderT;
    }

    public void show(){

    }
    // 泛型方法：在方法中出现了泛型结构，泛型参数与类的泛型参数没有任何关系。
    // 换句话说：泛型方法所属的类与是不是泛型类都没关系
    // 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
    public static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();

        for(E e : list){
            list.add(e);
        }
        return list;
    }

}

【SubOrder.java】

java

public class SubOrder extends Order<Integer>{//SubOrder:不是泛型类
    public static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();

        for(E e : list){
            list.add(e);
        }
        return list;
    }
}

2.注意点

泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>。
泛型类的构造器如下：public GenericClass(){}。而下面的是错误的：public GenericClass<E>(){}。
实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
泛型不同的引用不能相互赋值。
- 尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。
泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不用。
如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
jdk1.7,泛型的简化操作：ArrayList<String> list = new ArrayList<>();
泛型的指定中不能使用基本数据类型，可以使用包装类替换。
在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
异常类不能是泛型的。
不能使用new E[]。但是可以:E[] elements = (E[] new Object[capacity]);。参考：ArrayList源码中声明：Object[] elementData,而非泛型参数类型数组。
父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
- 子类不保留父类的泛型：按需实现
  - 没有类型擦除
  - 具体类型
- 子类保留父类的泛型：泛型子类
  - 全部保留
  - 部分保留

结论：子类必须是"富二代"，子类除了指定或保留父类的泛型，还可以增加自己的泛型。

3.应用场景举例

【DAO.java】：定义了操作数据库中的表的通用操作。

java

public class DAO<T>{// 表的共性操作DAO
    // 添加一条记录
    public void add(T t){

    }

    // 删除一条记录
    public boolean remove(int index){
        return false;
    }

    // 修改一条记录
    public void update(int index,T t){

    }

    // 查询多条记录
    public List<T> getForList(int index){
        return null;
    }

    // 泛型方法
    // 举例：获取表中一共有多少条记录？获取最大的员工入职时间？
    public <E> E getValue(){
        return null;
    }
}

【CustomerDAO.java】:

java

public class CustomerDAO extends DAO<Customer>{
    //只能操作某一个表的DAO
}

【StudentDAO.java】:

java

public class StudentDAO extends DAO<Student>{
    //只能操作某一个表的DAO
}

四.泛型在继承上的体现

虽然类A是类B的父类，但是G<A>和G<B>二者不具备字父类关系，二者是并列关系。补充：类A是类B的父类，A<G>是B<G>的父类。

java

List<Object> list1 = null;
List<String> list2 = new ArrayList<String>();
// 此时的list1和list2的类型不具备字父类关系
// 编译不通过
// list1 = list2

五.通配符

1.通配符的使用

通配符：?

类A是类B的子类，G<A>和G<B>是没关系的，二者的共同的父类是G<?>

java

@Test
public void test3(){
    List<Object> list1 = null;
    List<String> list2 = null;

    List<?> list = null;
    // 编译通过
    list = list1;
    list = list2;

    List<String> list3 = new ArrayList<>();
    list3.add("AA");
    list3.add("BB");
    list3.add("CC");
    list = list3;
    // 添加(写入：对于List<?>就不能向其内部添加数据)
    // 除了添加null之外。
    // list.add("DD");
    list.add(null);

    // 获取(读取)：允许读取数据，读取的数据类型为Object
    Object o = list.get(0);
    System.out.println(o);
}

2.涉及通配符的集合的数据的写入和读取

见上

3.有限制条件的通配符的使用

? extends A:G<? entends A>可以作为G<A>和G<B>的父类，其中B是A的子类
? super A:G<? super A>可以作为G<A>和G<B>的父类，其中B是A的父类

java

@Test
public void test4(){
    List<? extends Person> list1 = null;
    List<? super Person> list2 = null;

    List<Student> list3 = new ArrayList<>();
    List<Person> list4 = new ArrayList<>();
    List<Object> list5 = new ArrayList<>();

    list1 = list3;
    list1 = list4;
    // list1 = list5;

    // list2 = list3;
    list2 = list4;
    list2 = list5;

    // 读取数据：
    list1 = list3;
    Person p = list1.get(0);
    // 编译不通过
    // Student s = list1.get(0);

    list2 = list4;
    Object obj = list2.get(0);
    // 编译不通过
    // Person obj = list2.get(0);

    // 写入数据：
    // 编译不通过
    list1.add(new Student());

    // 编译通过
    list2.add(new Person());
    list2.add(new Student());

    list2 = list4;
    Object obj = list2.get(0);
    //编译不通过
    // Person obj = list2.get(0);
}

12.泛型 ​

一.泛型的理解 ​

1.泛型的概念 ​

2.泛型的引入背景 ​

二.泛型在集合中的使用 ​

1.在集合中使用泛型之前的例子 ​

2.在集合中使用泛型例子 1 ​

3.在集合中使用泛型例子 2 ​

4.集合中使用泛型总结 ​

三.自定义泛型类、泛型接口、泛型方法 ​

1.举例 ​

2.注意点 ​

3.应用场景举例 ​

四.泛型在继承上的体现 ​

五.通配符 ​

1.通配符的使用 ​

2.涉及通配符的集合的数据的写入和读取 ​

3.有限制条件的通配符的使用 ​

12.泛型

一.泛型的理解

1.泛型的概念

2.泛型的引入背景

二.泛型在集合中的使用

1.在集合中使用泛型之前的例子

2.在集合中使用泛型例子 1

3.在集合中使用泛型例子 2

4.集合中使用泛型总结

三.自定义泛型类、泛型接口、泛型方法

1.举例

2.注意点

3.应用场景举例

四.泛型在继承上的体现

五.通配符

1.通配符的使用

2.涉及通配符的集合的数据的写入和读取

3.有限制条件的通配符的使用