Java学习第十二章——泛型

泛型概述

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

在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。那么为什么要用泛型呢，直接Object不是也可以存储数据吗？

1.解决元素存储的安全性问题
2.解决获取数据元素时，需要类型强制转换的问题

Java泛型可以保证如果程序在编译时没有发出告警，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。 

在集合中使用泛型

 //在集合中使用泛型之前的情况：
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //问题一：类型不安全
        list.add("Tom");

        for(Object score : list){
            //问题二：强转时，可能出现ClassCastException
            int stuScore = (Integer) score;
        }

    //在集合中使用泛型的情况：以ArrayList为例 
       ArrayList<Integer> list =  new ArrayList<Integer>();
        list.add(78);
        list.add(87);
        list.add(99);
        list.add(65);
        //编译时，就会进行类型检查，保证数据的安全，此处提示错误
        list.add("Tom");

        //方式一：
        for(Integer score : list){
          //避免了强转操作
           int stuScore = score;
        }

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

    //在集合中使用泛型的情况：以HashMap为例
        Map<String,Integer> map = new HashMap<String,Integer>();
        //jdk7新特性：类型推断，后面可省
        Map<String,Integer> map = new HashMap<>();
        map.put("Tom",87);
        map.put("Jerry",87);
        map.put("Jack",67);
        //map.put(123,"ABC");
        
        //泛型的嵌套
        //set中放的是Entry类型，Entry中存放的是String和Integer
        Set<Map.Entry<String,Integer>> entry = map.entrySet();//Entry是Map类中定义的接口
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        while(iterator.hasNext()){
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key + "----" + value);
        }
    }

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

练习

//没有指明泛型的写法
 public int compareTo(Object o) {
        if(o instanceof Employee){
            Employee e = (Employee)o;
            return this.name.compareTo(o.name);
        }
    }

//指明泛型的写法
public int compareTo(Employee o) {       
        return this.name.compareTo(o.name);    
    }

自定义泛型结构

泛型类、泛型接口；泛型方法。

泛型的声明：

interface List<T> 和class GenTest<K,V>,其中，T,K,V不代表值，而是表示类型，常用T表示，是type的缩写。T只能是类，不能用基本数据类型填充。

 1. 关于自定义泛型类、泛型接口：

A,B是子类自己的泛型

代码实操：

自定义泛型类Order:

//泛型类
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 "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
    //静态方法中不能使用类的泛型。
    public static void show(T orderT){
        System.out.println(orderT);
    }

    public void show(){
        //编译不通过。不能砸try-catch中使用泛型定义
//        try{
//
//
//        }catch(T t){
//
//        }

    }

}

Order子类SubOrder 

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

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

public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");
        order1.setOrderT("AA:hello");
    }

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

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

    @Test
    public void test3(){
        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        //泛型不同的引用不能相互赋值。
       list1 = list2;

        Person p1 = null;
        Person p2 = null;
        p1 = p2;


    }
}

自定义泛型方法举例

方法也可以被泛型化。不管此时定义在其中的类是不是泛型类，在泛型方法中可以定义泛型参数，此时参数的类型就是传入数据的类型。

泛型方法的格式：

[访问权限]<泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常

泛型方法声明时也可以指定上限

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

    //测试泛型方法
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型。
        List<Integer> list = order.copyFromArrayToList(arr);

        System.out.println(list);
    }

 泛型类和泛型方法的使用情境举例

//DAO:data(base) access object  数据访问对象
//dao中定义通用的操作数据表的操作方法。会操作多张表，<T>表示
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 T getIndex(int index){
        return null;
    }
    //查询多条记录
    public List<T> getForList(int index){
        return null;
    }

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

//具体的dao的子类
//此类对应数据库中的customer表
public class  Customer {
}

//专门操作customer表，
public class CustomerDAO extends Dao<Customer> {//只能操作某个表的DAO
}

public class Daotest {
    public static void main(String[] args) {
        CustomerDAO dao1 = new CustomerDAO();
        dao1.add(new Customer());//只能是对Customer的操作
        List<Customer> forList = dao1.getForList(10);
    }
}

泛型在继承上的体现

类A是类B的父类，G是具有泛型声明的类或接口，G<A>和G<B>不具备子父类关系，二者是并列关系

        Object obj = null;
        String str = null;
        obj = str;//多态的体现

        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;//多态的体现

        List<Object> list1 = null;
        List<String> list2 = null;
        //list1 = list2;//编译不通过。意味此时的list1和list2不具备子父类关系
        //可用反证证明，如果在list1中添加整数不满足list2的添加条件

意味着下述方法的通用性偏差

List<String> list2 = new ArerayList();
show(list2)//没法放list2
public void show(List<Object> list){
    }
需要重新定义方法
public void show(List<String> list){
    }

补充：类A是类B的父类，类A<G>是类B<G>的父类

通配符的使用

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

    List<Object> list1 = null;
    List<String> list2 = null;

    List<?> list = null;
    list = list1;
    list = list2;
    show(list1);
    show(list2);

    public void show(List<?> list){
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
        }
    }

使用通配符后数据的读取和写入要求 

读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，他包含的对象都是Objext.

写入list中的元素时，不行。因为我们不知道c的元素类型，不能向其中添加对象。唯一的例外是null，他说所有类型的成员。

    List<?> list = null;
    List<String> list3 = new ArrayList<>();
    list3.add("AA");
    list3.add("BB");
    list = list3;
    //添加(写入)
    list.add();//对于list<?>就不能向其内部添加数据，除了添加null(空对象)之外
    //获取(读取),允许读取数据，读取的数据类型为Object
    Object o = list.get(0);

注意点：

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

用数学上的集合大小理解更直观
?extends A:通配符指定上限，使用时指定的类型必须是继承某个类，或者实现某个接口                            G<? extends A>可以作为G<A>和G<B>的父类，其实B是A的子类 <=
?super A: 通配符指定下限 ，使用时指定的类型不能小于操作的类                                                                    G<? super A>可以作为G<A>和G<B>的父类，其实B是A的父类 >=

class Person{
}

class Student extends Person{
}

List<? extends Person> list1 = null;
List<? super Person> list2 = null;
List<Student> list3 = null;
List<Person> list4 = null;
List<Object> list5 = null;
list1 = list3;
list1 = list4;
list1 = list5;//编译报错、

list2 = list3;//编译报错
list2= list4;
list2 = list5;

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

list2 = list4;
Object p = list1.get(0);

//写入数据
list1.add(new Student);//编译不过(有可能范围会比student小)
list2.add(new Person());//可行
list2.add(new Student());//可行

实验题：

 

public class Dao<T> {
    private Map<String ,T> map = new HashMap<>();

    public void save(String id,T entity){
        map.put(id,entity);
    }
    public T get(String id){
        return map.get(id);
    }
    public void update(String id,T entity){
        if(map.containsKey(id)){
            map.put(id,entity);
        }

    }
    public List<T> list(){
        ArrayList<T> list  = new ArrayList<>();
        Collection<T> values = map.values();
        for(T t:values){
            list.add(t);
        }
        return list;
    }
    public void delete(String id){
        map.remove(id);
    }
}

​
package atgui.java;

import java.util.Objects;

public class User {
    private int id;
    private int age;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public User() {
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id &&
                age == user.age &&
                Objects.equals(name, user.name);
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, age, name);
    }
}

public class DaoTest {
    public static void main(String[] args) {
        Dao<User> dao = new Dao<>();
        dao.save("1001",new User(1001,23,"zhou"));
        dao.save("1002",new User(1002,23,"zhou"));
        dao.save("1003",new User(1003,23,"zhou"));
        dao.update("1002",new User(1003,20,"fang"));

        List<User> list = dao.list();
        list.forEach(System.out::println);
    }
}