第15章 泛型

泛型的好处

（1）编译时，检查添加元素的类型，提高了安全性

（2）减少了类型转换的次数，提高效率

• 不使用泛型时：本类-->Object-->本类//需要类型转换

• 使用泛型时：本类-->本类-->本类//不需要类型转换，提高效率

• 泛型小练习

  对ArrayList中的元素进行排序，先判断名字，在名字相同的情况下再判断出生日期

public class B {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        ArrayList<Employee> employee = new ArrayList<>();
        employee.add(new Employee("jack",10000,new MyDate(2001,12,11)));
        employee.add(new Employee("rose",10000,new MyDate(2001,12,11)));
        employee.add(new Employee("jack",10000,new MyDate(2000,12,10)));
        employee.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee emp1, Employee emp2) {
                int i = emp1.getName().compareTo(emp2.getName());
                if (i != 0){
                    return i;
                }
               return emp1.getBirthday().compareTo(emp2.getBirthday());
            }
        });
        System.out.println(employee);
    }
}
class Employee{
    private String name;
    private int age;
    private MyDate birthday;

    public Employee(String name, int age, MyDate birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    @Override
    public String toString() {
        return "\nEmployee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }
}
class MyDate implements Comparable<MyDate>{
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    @Override
    public int compareTo(MyDate o) {
        int i = this.year - o.getYear();
        if (i != 0){
            return i;
        }
        int i2 = this.month-o.getMonth();
        if (i2 != 0){
            return i2;
        }
        return this.day - o.getDay();
    }
}

 自定义泛型

• 注意细节

（1）普通成员可以使用泛型

（2）使用泛型的数组不能进行初始化

（3）静态方法中不能使用类的泛型

（4）泛型类的类型，是在创建对象时确定的

（5）如果在创建对象时，没有指定类型，默认为Object

自定义泛型接口

• 细节

（1）接口中，静态成员也不能使用泛型

（2）泛型接口的类型，在继承或者实现接口时确定

（3）没有指定类型，默认为Object

自定义泛型方法

• 细节

（1）泛型方法，可以定义在普通类中，也可以定义在泛型类中

（2）当泛型方法被调用时，类型会确定

（3）泛型方法可以使用类声明的泛型也可以使用自己的泛型

（4）泛型方法和方法使用泛型不同：

public<E> void eat<E e>{}
//方法使用泛型：
public void eat<E>{}

本章作业

 

① 定义泛型类DAO<T>，在其中定义一个Map成员变量，Map的键为String类型，值为T类型

分别创建以下方法：

（1）public void save（String id，T entity）：保存T类型的对象到Map成员变量中

（2）public T get（String id）：从map中获取id对应的对象

（3）public void update（String id，T entity）：替换map中key为id的内容，改为entity对象

（4）public List<T>list（）：返回map中存放的所有T对象

（5）public void delete（String Id）：删除指定对象

②定义一个user类：

该类包含：private成员变量（int类型）id，age，（String类型）name

③创建DAO类的对象，分别调用其save、get、update、list、delete方法来操作User对象

public class B {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Dog<User> userDog = new Dog<>();
        userDog.save("001",new User(1,18,"jack"));
        userDog.save("002",new User(2,19,"rose"));
        userDog.save("003",new User(3,20,"karry"));
        List<User> list = userDog.list();
        list.remove(1);
        System.out.println(list);
        userDog.update("004",new User(1,21,"ROY"));
        List<User> list1 = userDog.list();
        System.out.println(list1);
    }
}
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 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 "\nUser{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
class Dog<T>{
    private Map<String, T> map = new HashMap<>();
    public T get(String id){
        return map.get(id);
    }
    public void update(String id,T entity){
        map.put(id,entity);
    }
    //遍历map，将所有的value封装到arraylist
    public List<T> list(){
        List<T> list = new ArrayList<>();
        Set<String> keySet = map.keySet();
        for(String key : keySet){
            list.add(get(key));
        }
        return list;
    }
    public void delete(String Id){
        map.remove(Id);
    }
    public void save(String id,T entity){
        map.put(id, entity);
    }
}