Java高级语法（五）：泛型

1.为什么要有泛型

2.泛型的使用

        1.jdk 5.0新增的特性

        2.在集合中使用泛型：(jdk7新特性：类型推断，即泛型只需要在变量名之前声明一次)

                1.集合接口或集合类在jdk5.0时都修改为带泛型的结构。

                2.在实例化集合类时，可以指明具体的泛型类型

                3.指明完以后，在集合类或接口中凡是定义类或接口时，内部结构(比如：方法、构造器、属性等)使用到类的泛型的位置，都指定为实例化的泛型类型，比如：add(E e) → 实例化以后：add(Integer e)

                4.注意点:：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换

                5.如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型
        3.对比集合在使用泛型前后的情况：

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

                        1.问题一：类型不安全、

                         2.问题二：强转时，可能出现类型转换异常(ClassCastException) 

                2.在集合中使用泛型的情况：

                        1.泛型在使用是不能是基本数据类型，可以是基本数据类型的包装类

                        2.编译时，就会进行类型检查，保证数据的安全

                        3.避免了强转操作

3.如何自定义泛型结构：泛型类、泛型接口、泛型方法

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

                1.如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型，要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。

                2.由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型

                3.子类可以保留父类的泛型不做设置，在需要的时候再设置

                4.泛型不同的引用不能相互赋值。

                5.静态方法中不能使用类的泛型

                6.异常类不能声明为泛型类

 

 

        2.泛型方法：

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

                2.可以声明为静态的。原因:泛型参数是在调用方法时确定的。并非在实例化类时确定。

4.泛型在继承方面的体现

        1.类A是类B的父类，G<A>和G<B>二者不具备子父类关系，二者是并列关系。 → 反证法：
假设list<Object> = list2<String>；list1.add (123)；导致混入非String的数据。出错。

        2.补充：如果类A是类B的父类，那么A<G>是B<G>的父类

5.通配符的使用

        1.通配符：?(英文格式下的)

        2.类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>

        3.添加(写入)：对于List<?>就不能向其内部添加数据，除了添加null之外

        4.获取(读取)：允许读取数据，读取的数据类型为Object

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

                1.? extends A(<=)：

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

                        2.不可以添加数据

                2.? super A(>=)：

                        1.G<? super A>可以作为G<A>和G<B>的父类，其中B是A的父类

                        2.可以添加A及A的子类

练习1(自定义泛型类)

     1.DAO类

package com.wy.exer1;

import java.util.*;

/**
 * 定义个泛型类DAO<T>，在其中定义一个Wap成员变量，Map 的键为String类型，值为T类型。
 * 分别创建以下方法:
 * public void save(String id,T entity):保存T类型的对象到Map成员变量中
 * public T get(String id): 从 map中获取id 对应的对象
 * public void update(String id,T entity ):替换 map中key为id的内容,改为entity对象
 * public List<T> list():返回map 中存放的所有T对象
 * public void delete(String id):删除指定 id 对象
 *
 * @author wy
 * @date 2021/12/6 - 22:41
 */
public class DAO<T> {
    private Map<String, T> map = new HashMap<>();

    //保存T类型的对象到Map成员变量中
    public void save(String id, T entity) {
        map.put(id, entity);
    }

    //从 map中获取id 对应的对象
    public T get(String id) {
        return map.get(id);
    }

    //替换 map中key为id的内容,改为entity对象
    public void update(String id, T entity) {
        if (map.containsKey(id)){
            map.put(id,entity);
        }
    }

    //返回map 中存放的所有T对象
    public List<T> list() {
        List<T> list = new ArrayList<>();
        Collection<T> values = map.values();

        for (T t :values) {
            list.add(t);
        }
        return list;
    }

    //删除指定 id 对象
    public void delete(String id) {
        map.remove(id);
    }

}

     2.User类

package com.wy.exer1;

/**
 * 定义一个User类:
 * 该类包含: private成员变量(int类型）id，age;(String类型)name。
 * @author wy
 * @date 2021/12/6 - 22:56
 */
public class User {
    private int id;
    private int age;
    private String name;

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

    public User() {
    }

    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;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (id != user.id) return false;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + age;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

     3.DAOTest类(测试类)

package com.wy.exer1;

import java.util.List;

/**
 * 创建DAO 类的对象，分别调用其 save、get、update、list、delete方法来操作 User对象，
 * 使用Junit单元测试类进行测试。
 * @author wy
 * @date 2021/12/6 - 22:59
 */
public class DAOTest {
    public static void main(String[] args) {
        DAO<User> dao = new DAO<>();

        dao.save("1001",new User(1001,34,"张三"));
        dao.save("1002",new User(1002,20,"李四"));
        dao.save("1003",new User(1003,25,"王五"));

        dao.update("1003",new User(1003,30,"赵六"));

        dao.delete("1002");

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