Java泛型详解

请在ArrayList中编写程序 中间添加3个Dog对象

Dog对象含有name 和 age, 并输出name 和 age (要求使用getxxx()

package com.hspedu.generic;import java.util.ArrayList;@SuppressWarnings({"all"})public class Generic01 {    public static void main(String[] args) {        ////用传统的方法解决问题        ArrayList arrayList = new ArrayList();        arrayList.add(new Dog(“旺财”， 10));        arrayList.add(new Dog(“发财”， 1));        arrayList.add(new Dog(“小黄”， 5));        //如果程序员不小心添加了一只猫        arrayList.add(new Cat(“招财猫”， 8)); // 会报告类型转换的错误        //遍历        for (Object o : arrayList) {            ///向下转型Objectct ->Dog            Dog dog = (Dog) o;            System.out.println(dog.getName() + "-" + dog.getAge());        }    }}/*请编写程序，ArrayListtt在Aray 添加3个Dog对象的Dog对象包含name 和 age, 并输出name 和 age (要求使用getxxx() */class Dog {    private String name;    private int age;    public Dog(String name, int age) {        this.name = name;        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}class Cat { ///Cat类    private String name;    private int age;    public Cat(String name, int age) {        this.name = name;        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

1)不能限制添加到集合ArayList中的数据类型(不安全)

2)遍历时，需要转换类型。如果集合中的数据量大，会影响效率。

public class Generic02 {    public static void main(String[] args) {        // 用传统的方法来解决问题===> 使用泛型        // 1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合元素是Dog类型        // 2. 如果编译器发现添加的类型，如果你不符合要求，你会报错        // 3. 在遍历中，可以直接取出 Dog 类型而不是 Object        // 4. public class ArrayList<E> {} 称为泛型，称为泛型，那么 Dog->E        ArrayList<Dog> arrayList = new ArrayList<Dog>();        arrayList.add(new Dog(“旺财”， 10));        arrayList.add(new Dog(“发财”， 1));        arrayList.add(new Dog(“小黄”， 5));        // 假如我们的程序员，不小心，加了一只猫        // arrayList.add(new Cat(“招财猫”， 8));        System.out.println("==== 使用泛型 ====");        for (Dog dog : arrayList) {            System.out.println(dog.getName() + "-" + dog.getAge());        }    }}

1)在编译过程中，检查添加元素的类型，提高安全性

2)减少类型转换次数，提高效率。

不使用泛型

• Dog -加入-> Object -取出-> Dog ///放入ArrayList Object将首先转换为Object，取出时需要转换

使用泛型

• Dog -> Dog -> Dog // 放入和取出时，无需转换类型以提高效率

3)不再提示编译警告

(广泛)型(类型)=> Integer,String,Dog

1. 泛型，又称参数类型，是JDK5.0的一个新特征，解决了数据类型的安全问题
2. 在类别声明或实例化中，只需指定所需的特定类型。
3. Java泛型可以保证，如果程序在编译过程中没有发出警告，则在运行过程中不会出现Clascastexception异常。同时，代码更简洁、更强大。
4. 泛型的功能是：在类声明中，可以通过一个标志来表示类中某一属性的类型，或法的返回值的类型，或参数类型。

package com.hspedu.generic;import java.util.List;public class Generic03 {    public static void main(String[] args) {        //注意，特别强调： 在定义Person对象时指定E的具体数据类型，即在编译过程中，确定E的类型        Person<String> person = new Person<String>("timerring");        person.show(); //String        /*            你可以这样理解，上面的Person类            class Person {                String s ;//E表示 s的数据类型， 在定义Person对象时指定数据类型，即在编译过程中，确定E的类型                public Person(String s) {//E也可以是参数类型                    this.s = s;                }                public String f() E{///回归类型使用E回归类型                    return s;                }            }         */        Person<Integer> person2 = new Person<Integer>(100);        person2.show();//Integer        /*            class Person {                Integer s ;//E表示 s的数据类型， 在定义Person对象时指定数据类型，即在编译过程中，确定E的类型                public Person(Integer s) {//E也可以是参数类型                    this.s = s;                }                public Integer f() E{///回归类型使用E回归类型                    return s;                }            }         */    }}//泛型的作用是：在类声明中，可以通过一个标志来表示类中某一属性的类型，// 或某种方法的返回值类型，或参数类型classs Person<E> {    E s ;//E表示 s的数据类型， 在定义Person对象时指定数据类型，即在编译过程中，确定E的类型    public Person(E s) {//E也可以是参数类型        this.s = s;    }    public E f() E{///回归类型使用E回归类型        return s;    }    public void show() {        System.out.println(s.getClass());////显示s的操作类型    }}

interface 接口<T>{} 和 class 类 <K,V>{}/比如：List , ArrayList

说明:

1. 其中，T,K,V不代表值，而是表示类型。
2. 任何字母都可以。常用的T表示是Type的缩写

类型参数的值(类型)应在类名后面指定。

List<String> strList = new ArrayList<String>();Iterator<Customer> iterator = customers.iterator();

例如，在Hashset和Hashmap中使用泛型

练习:

1. 创建三个学生对象
2. 在Hashset中学生对象中使用.
3. 在Hashmap中，要求Key是String name, Value是学生的对象
4. 用两种方式遍历

package com.hspedu.generic;import java.util.*;@SuppressWarnings({"all"})public class GenericExercise {    public static void main(String[] args) {        // Hashsetet采用泛型法 放三个学生对象        HashSet<Student> students = new HashSet<Student>();        students.add(new Student("jack", 18));        students.add(new Student("tom", 28));        students.add(new Student("mary", 19));        // 遍历        for (Student student : students) {            System.out.println(student);        }        // HashMapp采用泛型法 放三个学生对象        // K -> String V->Student        HashMap<String, Student> hm = new HashMap<String, Student>();        /*            public class HashMap<K,V>  {}         */        hm.put("milan", new Student("milan", 38));        hm.put("smith", new Student("smith", 48));        hm.put("hsp", new Student("hsp", 28));        //迭代器 EntrySet        /*        public Set<Map.Entry<K,V>> entrySet() {            Set<Map.Entry<K,V>> es;            return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;        }         */        Set<Map.Entry<String, Student>> entries = hm.entrySet();        /*            public final Iterator<Map.Entry<K,V>> iterator() {                return new EntryIterator();            }         */        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();        System.out.println================================;        while (iterator.hasNext()) {            Map.Entry<String, Student> next =  iterator.next();            System.out.println(next.getKey() + "-" + next.getValue());        }    }}/** * 创建 3 个学生对象 * 放入到 HashSet 中学生对象， 使用. * 放入到  Hashmap要求Hashmap Key 是 String name, Value 就是 学生对象 * 用两种方式遍历 */class Student {    private String name;    private int age;    public Student(String name, int age) {        this.name = name;        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    @Override    public String toString() {        return "Student{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }}

interface List{} , public class HashSet{}..等等

说明:T,E只能是参考类型，看看下面的句子是否正确。

List<lnteger> list = new ArrayList<lnteger>()://OKList<int> list2 = new ArrayList<int>();//错误

给泛型指定具体类型后，可以引入该类型或其子类型

泛型使用形式

List<lnteger> list1 =new ArrayList<lnteger>();List<lnteger> list2 = new ArrayList<>(); // 建议省略写作方法

如果我们这样写Listtt，如果我们这样写Listttt list3 = new ArrayList();默认给它的泛型是\ E是Object。如果是这样写的话 泛型默认是 Object

package com.hspedu.generic;import java.util.ArrayList;import java.util.List;@SuppressWarnings({"all"})public class GenericDetail {    public static void main(String[] args) {        //1.指向泛型的数据类型是，要求是引用类型，不能是基本数据类型        List<Integer> list = new ArrayList<Integer>(); //OK        //List<int> list2 = new ArrayList<int>();//错误        //2. 说明        //因为 E 指定了 A 类型, 引入了结构器 new A()        给泛型指定具体类型后，//可以传入该类型或其子类型        Pig<A> aPig = new Pig<A>(new A());        aPig.f();        Pig<A> aPig2 = new Pig<A>(new B());        aPig2.f();        //3. 泛型的使用形式        ArrayList<Integer> list1 = new ArrayList<Integer>();        List<Integer> list2 = new ArrayList<Integer>();        //在实际开发中，我们经常简写        //编译器将推断类型， 老师建议使用以下写作方法        ArrayList<Integer> list3 = new ArrayList<>();        List<Integer> list4 = new ArrayList<>();        ArrayList<Pig> pigs = new ArrayList<>();        //4. 假如是这样写的 泛型默认是 Object        ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();        /*            public boolean add(Object e) {                ensureCapacityInternal(size + 1);  // Increments modCount!!                elementData[size++] = e;                return true;            }         */        Tiger tiger = new Tiger();        /*            class Tiger {//类                Object e;                public Tiger() {}                public Tiger(Object e) {                    this.e = e;                }            }         */    }}class Tiger<E> {//类    E e;    public Tiger() {}    public Tiger(E e) {        this.e = e;    }}class A {}class B extends A {}class Pig<E> {//    E e;    public Pig(E e) {        this.e = e;    }    public void f() {        System.out.println(e.getClass()); //操作类型    }}

Employee类定义

1. 该类包含: private成员变量name， sal, birthday，其中 birthday 为 MyDate 类的对象;
2. 为每个属性定义getter， setter方法；
3. 重写tostring方法输出name， sal, birthday
4. MyDate类包括：private成员变量month， day, year; 并定义每个属性 getter,setter方法；
5. 创建这三个对象，并将这些对象放入ArrayList集合中(ArrayList需要用泛型来定义)，对集合中的元素进行排序，并将其放入ArrayList集合中:
6. 排序方法：调用ArrayList的sort方法，传入 comparator对象[使用泛型]，先按name排序，如果name相同，则按生日日期顺序排序。[即：定制排序]

package com.hspedu.generic;public 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 void setYear(int year) {        this.year = year;    }    public int getMonth() {        return month;    }    public void setMonth(int month) {        this.month = month;    }    public int getDay() {        return day;    }    public void setDay(int day) {        this.day = day;    }    @Override    public String toString() {        return "MyDate{" +                "year=" + year +                ", month=" + month +                ", day=" + day +                '}';    }    @Override    public int compareTo(MyDate o) { ///对year-month-day比较放在这里        int yearMinus = year - o.getYear();        if(yearMinus != 0) {            return  yearMinus;        }        ///如果year相同，则比较month        int monthMinus = month - o.getMonth();        if(monthMinus != 0) {            return monthMinus;        }        //如果是year 和 month        return day - o.getDay();    }}

package com.hspedu.generic;public class Employee {    private String name;    private double sal;    private MyDate birthday;    public Employee(String name, double sal, MyDate birthday) {        this.name = name;        this.sal = sal;        this.birthday = birthday;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public double getSal() {        return sal;    }    public void setSal(double sal) {        this.sal = sal;    }    public MyDate getBirthday() {        return birthday;    }    public void setBirthday(MyDate birthday) {        this.birthday = birthday;    }    @Override    public String toString() {        return "\nEmployee{" +                "name='" + name + '\'' +                ", sal=" + sal +                ", birthday=" + birthday +                '}';    }}

package com.hspedu.generic;import java.util.ArrayList;import java.util.Comparator;@SuppressWarnings({"all"})public class Genericercise {    public static void main(String[] args) {        ArrayList<Employee> employees = new ArrayList<>();        employees.add(new Employee("tom", 20000, new MyDate(1980，12，11);        employees.add(new Employee("jack", 12000, new MyDate(2001，12，12);        employees.add(new Employee("tom", 50000, new MyDate(1980,12,10)));        System.out.println("employees=" + employees);        employees.sort(new Comparator<Employee>() {            @Override            public int compare(Employee emp1, Employee emp2) {                //先按name排序，如果name相同，则按生日日期顺序排序。[即：定制排序]                ///首先验证输入参数                if(!(emp1 instanceof  Employee && emp2 instanceof Employee)) {                    System.out.println(”类型不正确..");                    return 0;                }                //比较name                int i = emp1.getName().compareTo(emp2.getName());                if(i != 0) {                    return i;                }                //以下是birthday的比较，所以我们最好把这个比较放在mydate类别中                ///包装后，将来可以维护和重用，就大大增强.                return emp1.getBirthday().compareTo(emp2.getBirthday());            }        });        System.out.println(==对员工进行排序==);        System.out.println(employees);    }}/** * Employee类定义 * 1) 这类包括：private成员变量name，sal,birthday，其中 birthday 为 MyDate 类的对象； * 2) 定义每个属性 getter, setter 方法； * 3) 重写 toString 方法输出 name, sal, birthday * 4) MyDate类包括： private成员变量month，day,year；并定义每个属性 getter, setter 方法； * 5) 创建该类的 3 将这些对象放入对象中 ArrayList 集合中（ArrayList 需要用泛型来定义)，对集中元素进行排序，并通过输出进行遍历: * * 排序方式： 调用ArrayListt 的 sort 方法 , * 传入 comparator对象[使用泛型]，先按name排序，如果name相同，则按生日日期顺序排序。[即：定制排序] */

class 类名 <T,R..> {//..表示可以有多个泛型成员}

注意细节

1. 普通成员可以使用泛型(属性、方法)
2. 使用泛型数组不能初始化：因为如果不确定类型，就不知道要开多少空间。
3. 类型的泛型不能用于静态方法，因为静态与类相关，所以在加载过程中没有创建对象，所以不能指定静态方法/变量的类型。如果泛型用于静态方法和静态属性，JVM将无法初始化。
4. 在创建对象时确定泛型类型(因为在创建对象时需要指定确定的类型)
5. 如果在创建对象时没有指定类型，则默认为Objectt

class Tiger<T, R, M>{   String name;   R r;   M m;   T t;}

package com.hspedu.customgeneric;import java.util.Arrays;@SuppressWarnings({"all"})public class CustomGeneric_ {    public static void main(String[] args) {        //T=Double, R=String, M=Integer        Tiger<Double,String,Integer> g = new Tiger<>("john");        g.setT(10.9); //OK        //g.setT("yy"); //错误，类型不对        System.out.println(g);        Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object        g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类        System.out.println("g2=" + g2);    }}//1. Tiger 后面的泛型，所以我们把它放在后面 Tiger 称为自定义泛类//2， T, R, M 泛型标识符， 一般来说，单个大写字母///3. 泛型标志符可以有多个.//4. 普通成员可以使用泛型 (属性、方法)/5. 使用泛型数组不能初始化//6. 泛型classs不能用于静态方法 Tiger<T, R, M> {    String name;    R r; ///属性用于泛型    M m;    T t;    ///因为数组在new T的类型无法确定，在内存中无法打开空间    T[] ts;    public Tiger(String name) {        this.name = name;    }    public Tiger(R r, M m, T t) {///构造器使用泛型        this.r = r;        this.m = m;        this.t = t;    }    public Tiger(String name, R r, M m, T t) {///构造器使用泛型        this.name = name;        this.r = r;        this.m = m;        this.t = t;    }    //因为静态与类有关，当类加载时，对象尚未创建    //所以，若采用泛型的静态方法和静态属性，JVM无法初始化////    static R r2;//    public static void m1(M m) {////    }    //使用泛型的方法    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public R getR() {        return r;    }    public void setR(R r) {///方法用于泛型        this.r = r;    }    public M getM() {//返回类型可以使用泛型.        return m;    }    public void setM(M m) {        this.m = m;    }    public T getT() {        return t;    }    public void setT(T t) {        this.t = t;    }    @Override    public String toString() {        return "Tiger{" +                "name='" + name + '\'' +                ", r=" + r +                ", m=" + m +                ", t=" + t +                ", ts=" + Arrays.toString(ts) +                '}';    }}

interface 接口名 <T,R...> {}

注意细节

1. 在接口中，静态成员不能使用泛型(这与泛型规定相同)
2. 在继承接口或实现接口时确定泛型接口的类型
3. Objectttect没有指定类型

package com.hspedu.customgeneric;public class CustomInterfaceGeneric {    public static void main(String[] args) {    }}/** *  使用泛型接口的说明 *  1. 接口中，静态成员也不能使用泛型 *  2. 泛型接口的类型， 在确定继承接口或实现接口时确定 *  3. Objectttect没有指定类型 *////继承接口 interface指定泛型接口的类型 IA extends IUsb<String, Double> {}//当我们去实现IA接口时，IA继承IUSb 界面时，指定U String R为Double使用String替换U，实现IUSB接口的方法， Double取代Rclass AA implements IA {    @Override    public Double get(String s) {        return null;    }    @Override    public void hi(Double aDouble) {    }    @Override    public void run(Double r1, Double r2, String u1, String u2) {    }}///实现接口时，直接指定泛接口的类型//给U 指定Integer 给 R 指定了 Float//因此，当我们实现IUSB方法时，Integer将被用来替换U， 用Float代替Rclass BB implements IUsb<Integer, Float> {    @Override    public Float get(Integer integer) {        return null;    }    @Override    public void hi(Float aFloat) {    }    @Override    public void run(Float r1, Float r2, Integer u1, Integer u2) {    }}///未指定类型，默认为Object//建议直接写成 IUsb<Object,Object>class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {    @Override    public Object get(Object o) {        return null;    }    @Override    public void hi(Object o) {    }    @Override    public void run(Object r1, Object r2, Object u1, Object u2) {    }}interface IUsb<U, R> {    int n = 10;    //U name; 不能这样使用    //在普通方法中，界面泛型可用于接口泛型    R get(U u);    void hi(R r);    void run(R r1, R r2, U u1, U u2);    //在jdk8 默认方法可用于界面， 泛型也可以使用    default R method(U u) {        return null;    }}

修饰符 <T,R..> 返回类型 方法名 (参数列表){}

注意细节

1. 泛型方法可以在普通类或泛型类中定义
2. 当调用泛型方法时，将确定类型
3. public void eat(E e) {}.修 饰符后没有 <T,R..>eat方法不是泛型方法，而是泛型方法。泛型方法可以使用类声明的泛型，也可以使用自己的泛型。

package com.hspedu.customgeneric;import java.util.ArrayList;@SuppressWarnings({"all"})public class CustomMethodGeneric {    public static void main(String[] args) {        Car car = new Car();        car.fly(“宝马”， 100);//当调用方法时，传输参数和编译器将确定类型        System.out.println(========);        car.fly(300, 100.1);//当调用方法时，传入参数，编译器，将确定类型        //测试        //T->String, R-> ArrayList        Fish<String, ArrayList> fish = new Fish<>();        fish.hello(new ArrayList(), 11.3f);    }}在普通类中可以定义//泛型方法， classs也可以定义为泛类 Car {///普通类    public void run() {//普通方法    }    //说明 泛型方法    //1. <T,R> 就是泛型    //2. 是提供给 使用fly    public <T, R> void fly(T t, R r) {///泛型方法        System.out.println(t.getClass());//String        System.out.println(r.getClass());//Integer    }}class Fish<T, R> {///泛型类    public void run() {//普通方法    }    public<U,M> void eat(U u, M m) {///泛型方法    }    //说明    //1. 下面的hi方法不是泛型方法    //2. hi方法使用类声明 泛型    public void hi(T t) {    }    // 泛型方法，可采用类声明的泛型，也可以用自己声明泛型    public<K> void hello(R r, K k) {        System.out.println(r.getClass());//ArrayList        System.out.println(k.getClass());//Float    }}

下面的代码是否正确，如果有错误，修改正确，并说明输出是什么？

package com.hspedu.customgeneric;public class CustomMethodGenericExercise {    public static void main(String[] args) {        //T->String, R->Integer, M->Double        Apple<String, Integer, Double> apple = new Apple<>();        apple.fly(10);//10 自动装箱 Integer10， 输出Integer        apple.fly(new Dog());//Dog    }}class Apple<T, R, M> {//自定义泛型类    public <E> void fly(E e) {  ///泛型方法        System.out.println(e.getClass().getSimpleName());    }    //public void eat(U u) {}//错误，因为U没有声明    public void run(M m) {    } //ok}class Dog {}

1. 泛型不具有继承性

List <Object> list = new ArrayList<String>(); //错误

2. <?>:支持任何泛型类型
3. <? extends A>:支持a类和a类子类，规定了一般类型的上限
4. <? super A>:支持A类和A类的父类，不限于直接父类，规定了一般类型的下限

package com.hspedu;import java.util.ArrayList;import java.util.List;public class GenericExtends {    public static void main(String[] args) {        Object o = new String("xx");        ///泛型没有继承性        //List<Object> list = new ArrayList<String>();        ///举例说明以下三种方法的使用        List<Object> list1 = new ArrayList<>();        List<String> list2 = new ArrayList<>();        List<AA> list3 = new ArrayList<>();        List<BB> list4 = new ArrayList<>();        List<CC> list5 = new ArrayList<>();        //如果是 List<?> c ，任何泛型类型都可以接受        collection1(list1);        collection1(list2);        collection1(list3);        collection1(list4);        collection1(list5);        //List<? extends AA> c： 表示 上限，可以接受 AA或AA子类////        collection2(list1);//×//        collection2(list2);//×        collection2(list3);//√        collection2(list4);//√        collection2(list5);//√        //List<? super AA> c: 支持AA类和AA类的父类，不限于直接父类        collection3(list1);//√        ////printcolection3(list2);//×        collection3(list3);//√        ////printcolection3(list4);//×        ////printcolection3(list5);//×    }    // ? extends AA 表示 上限，可以接受 AA或AA子类    public static void coletionprint(List<? extends AA> c) {        for (Object object : c) {            System.out.println(object);        }    }    //说明: List<?> 表示 任何泛型类型都可以接受    public static void coletionprint(List<?> c) {        for (Object object : c) { // 取出通配符时，是Object            System.out.println(object);        }    }    // ? super AA的子类名:支持AA类和AA类的父类，不限于直接父类，    ///规定泛型的下限    public static void colectionprint(List<? super AA> c) {        for (Object object : c) {            System.out.println(object);        }    }}class AA {}class BB extends AA {}class CC extends BB {}

1. 一个类有许多功能代码需要测试。为了测试，需要将其写入main方法
2. 若有多个功能代码测试，则需要来回取消，切换非常麻烦
3. 如果能直接操作一种方法，方便多了，可以给出相关信息，可以使用 JUnit 测试框架

Junit是Java语言的单元测试框架

Java的大部分开发环境都集成了Junit作为单元测试的工具，可以直接单独执行，而无需直接在main中调用实例对象。

使用方法：先写 @Test ，然后 Alt + Enter 从Maven 添加 Junit 即可。

package com.hspedu.junit_;import org.junit.jupiter.api.Test;public class JUnit_ {    public static void main(String[] args) {        //传统方式        //new JUnit_().m1();        //new JUnit_().m2();    }    @Test    public void m1() {        System.out.println(调用m1方法);    }    @Test    public void m2() {        System.out.println(调用m2方法);    }    @Test    public void m3() {        System.out.println(调用m3方法);    }}

1.编程题

定义一个泛型DAO，定义一个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 list):所有存储在返回map中的T对象

(5) public void delete(String id):删除指定的ID对象

定义一个 User类:

这类包括private成员变量(int类型) id,age; (String类型)name。

创建 DAO 类别对象分别调用其save、get、update、list、delete方法用于操作User对象 Junit 测试单元测试类。

package com.hspedu.homework;/** * 这类包括private成员变量(int类型) id，age；（String 类型）name */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 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 + '\'' +                '}';    }}

package com.hspedu.homework;import java.util.*;/** * 定义一个泛类 DAO<T>，定义一个Mapp 成员变量，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)：删除指定 id 对象 */public class DAO<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 所有存放在中间的东西 T 对象    ///遍历map [k-v],将map的 所有value(T entity),封装到ArrayList返回    public List<T> list() {        //创建 Arraylist        List<T> list = new ArrayList<>();        ///遍历map        Set<String> keySet = map.keySet();        for (String key : keySet) {            //map.get(key) 返回就是 User对象->ArrayList            list.add(map.get(key)); ///也可以直接使用这种类型 get(String id)        }        return list;    }    public void delete(String id) {        map.remove(id);    }    public void save(String id,T entity) {///将entity保存到mapp中        map.put(id, entity);    }}