1. 泛型的理解和好处

看一个需求

  1. 请编写程序,在 ArrayList 中,添加3个 Dog 对象
  2. Dog对象含有 name 和 age ,并输出 name 和 age (要求使用 getXxx())
  1. public class Generic01 {
  2.     public static void main(String[] args) {
  4.         //使用传统的方法来解决
  5.         ArrayList arrayList = new ArrayList();
  6.         arrayList.add(new Dog("旺财", 10));
  7.         arrayList.add(new Dog("发财", 1));
  8.         arrayList.add(new Dog("小黄", 5));
  10.         //假如我们的程序员，不小心，添加了一只猫
  11.         arrayList.add(new Cat("招财猫", 8));
  13.         //遍历
  14.         for (Object o : arrayList) {
  15.             //向下转型Object ->Dog
  16.             Dog dog = (Dog) o;
  17.             System.out.println(dog.getName() + "-" + dog.getAge());
  18.         }
  20.     }
  21. }
  22. /*
  23. 请编写程序，在ArrayList 中，添加3个Dog对象
  24. Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
  25.  */
  26. class Dog {
  27.     private String name;
  28.     private int age;
  29.     public Dog(String name, int age) {
  30.         this.name = name;
  31.         this.age = age;
  32.     }
  34.     public String getName() {
  35.         return name;
  36.     }
  38.     public void setName(String name) {
  39.         this.name = name;
  40.     }
  42.     public int getAge() {
  43.         return age;
  44.     }
  46.     public void setAge(int age) {
  47.         this.age = age;
  48.     }
  49. }
  51. class Cat { //Cat类
  52.     private String name;
  53.     private int age;
  54.     public Cat(String name, int age) {
  55.         this.name = name;
  56.         this.age = age;
  57.     }
  59.     public String getName() {
  60.         return name;
  61.     }
  63.     public void setName(String name) {
  64.         this.name = name;
  65.     }
  67.     public int getAge() {
  68.         return age;
  69.     }
  71.     public void setAge(int age) {
  72.         this.age = age;
  73.     }
  74. }

使用传统方法的问题分析

  1. 不能对加入到集合 ArrayList 中的数据类型进行约束(不安全)
  2. 遍历的时候,需要进行类型转换如果集合中的数据量较大,对效率有影响

泛型快速体验-用泛型来解决前面的问题

  1. public class Generic02 {
  2.     public static void main(String[] args) {
  4.         //使用传统的方法来解决===> 使用泛型
  5.         //老韩解读
  6.         //1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是Dog类型 (细节后面说...)
  7.         //2. 如果编译器发现添加的类型，不满足要求，就会报错
  8.         //3. 在遍历的时候，可以直接取出 Dog 类型而不是 Object
  9.         //4. public class ArrayList<E> {} E称为泛型,那么 Dog->E
  10.         ArrayList<Dog> arrayList = new ArrayList<Dog>();
  11.         arrayList.add(new Dog("旺财", 10));
  12.         arrayList.add(new Dog("发财", 1));
  13.         arrayList.add(new Dog("小黄", 5));
  14.         //假如我们的程序员，不小心，添加了一只猫
  15.         //arrayList.add(new Cat("招财猫", 8));
  16.         System.out.println("===使用泛型====");
  17.         for (Dog dog : arrayList) {
  18.             System.out.println(dog.getName() + "-" + dog.getAge());
  19.         }
  22.     }
  23. }
  25. /*
  26. 1.请编写程序，在ArrayList 中，添加3个Dog对象
  27. 2.Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
  28. 3.老师使用泛型来完成代码
  29.  */
  30. class Dog {
  31.     private String name;
  32.     private int age;
  33.     public Dog(String name, int age) {
  34.         this.name = name;
  35.         this.age = age;
  36.     }
  38.     public String getName() {
  39.         return name;
  40.     }
  42.     public void setName(String name) {
  43.         this.name = name;
  44.     }
  46.     public int getAge() {
  47.         return age;
  48.     }
  50.     public void setAge(int age) {
  51.         this.age = age;
  52.     }
  53. }
  55. class Cat { //Cat类
  56.     private String name;
  57.     private int age;
  58.     public Cat(String name, int age) {
  59.         this.name = name;
  60.         this.age = age;
  61.     }
  63.     public String getName() {
  64.         return name;
  65.     }
  67.     public void setName(String name) {
  68.         this.name = name;
  69.     }
  71.     public int getAge() {
  72.         return age;
  73.     }
  75.     public void setAge(int age) {
  76.         this.age = age;
  77.     }
  78. }

2. 泛型的好处

泛型的好处

  1. 编译时,检查添加元素的类型,提高了安全性
  2. 减少了类型转换的次数提高效率[说明
    √ 不使用泛型
    Dog -加入→ Object -取出→ Dog // 放入到 ArrayList 会先转成 Object,在取出时,还需要转换成Dog
    √ 使用泛型
    Dog → Dog → Dog // 放入时,和取出时,不需要类型转换,提高效率
  3. 不再提示编译警告

泛型介绍

int a= 10
老韩理解 : 泛(广泛)型(类型) => Integer, String, Dog

  1. 泛型又称参数化类型,是Jdk5.0出现的新特性解决数据类型的安全性问题
  2. 在类声明或实例化时只要指定好需要的具体的类型即可。
  3. Java泛型可以保证如果程序在编译时没有发出警告,运行时就不会产生ClassCastException异常。同时,代码更加简洁、健壮
  4. 泛型的作用是 : 可以在类声明时通过一个标识表示类中某个属性的类型,或者是某个方法的返回值的类型,或者是参数类型.
  1. public class Generic03 {
  2.     public static void main(String[] args) {
  4.         //注意，特别强调： E具体的数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
  5.         Person<String> person = new Person<String>("韩顺平教育");
  6.         person.show(); //String
  8.         /*
  9.             你可以这样理解，上面的Person类
  10.             class Person {
  11.                 String s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
  13.                 public Person(String s) {//E也可以是参数类型
  14.                     this.s = s;
  15.                 }
  17.                 public String f() {//返回类型使用E
  18.                     return s;
  19.                 }
  20.             }
  21.          */
  23.         Person<Integer> person2 = new Person<Integer>(100);
  24.         person2.show();//Integer
  26.         /*
  27.             class Person {
  28.                 Integer s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
  30.                 public Person(Integer s) {//E也可以是参数类型
  31.                     this.s = s;
  32.                 }
  34.                 public Integer f() {//返回类型使用E
  35.                     return s;
  36.                 }
  37.             }
  38.          */
  39.     }
  40. }
  42. //泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
  43. // 或者是某个方法的返回值的类型，或者是参数类型
  45. class Person<E> {
  46.     E s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
  48.     public Person(E s) {//E也可以是参数类型
  49.         this.s = s;
  50.     }
  52.     public E f() {//返回类型使用E
  53.         return s;
  54.     }
  56.     public void show() {
  57.         System.out.println(s.getClass());//显示s的运行类型
  58.     }
  59. }

3. 泛型的语法

泛型的声明

  1. interface 接口<T>{}

和

  1. class 类<K,V>{}//比如:List, Array List

说明:

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

泛型的实例化

要在类名后面指定类型参数的值(类型)。如:

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

泛型使用举例

  1. public class GenericExercise {
  2.     public static void main(String[] args) {
  3.         //使用泛型方式给HashSet 放入3个学生对象
  4.         HashSet<Student> students = new HashSet<Student>();
  5.         students.add(new Student("jack", 18));
  6.         students.add(new Student("tom", 28));
  7.         students.add(new Student("mary", 19));
  9.         //遍历
  10.         for (Student student : students) {
  11.             System.out.println(student);
  12.         }
  14.         //使用泛型方式给HashMap 放入3个学生对象
  15.         //K -> String V->Student
  16.         HashMap<String, Student> hm = new HashMap<String, Student>();
  17.         /*
  18.             public class HashMap<K,V>  {}
  19.          */
  20.         hm.put("milan", new Student("milan", 38));
  21.         hm.put("smith", new Student("smith", 48));
  22.         hm.put("hsp", new Student("hsp", 28));
  24.         //迭代器 EntrySet
  25.         /*
  26.         public Set<Map.Entry<K,V>> entrySet() {
  27.             Set<Map.Entry<K,V>> es;
  28.             return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
  29.         }
  30.          */
  31.         Set<Map.Entry<String, Student>> entries = hm.entrySet();
  32.         /*
  33.             public final Iterator<Map.Entry<K,V>> iterator() {
  34.                 return new EntryIterator();
  35.             }
  36.          */
  37.         Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
  38.         System.out.println("==============================");
  39.         while (iterator.hasNext()) {
  40.             Map.Entry<String, Student> next =  iterator.next();
  41.             System.out.println(next.getKey() + "-" + next.getValue());
  43.         }
  45.     }
  46. }
  47. /**
  48.  * 创建  3个学生对象
  49.  * 放入到HashSet中学生对象, 使用.
  50.  * 放入到  HashMap中，要求 Key 是 String name, Value 就是 学生对象
  51.  * 使用两种方式遍历
  52.  */
  53. class Student {
  54.     private String name;
  55.     private int age;
  57.     public Student(String name, int age) {
  58.         this.name = name;
  59.         this.age = age;
  60.     }
  62.     public String getName() {
  63.         return name;
  64.     }
  66.     public void setName(String name) {
  67.         this.name = name;
  68.     }
  70.     public int getAge() {
  71.         return age;
  72.     }
  74.     public void setAge(int age) {
  75.         this.age = age;
  76.     }
  78.     @Override
  79.     public String toString() {
  80.         return "Student{" +
  81.                 "name='" + name + '\'' +
  82.                 ", age=" + age +
  83.                 '}';
  84.     }
  85. }

泛型使用的注意事项和细节

    1. interface List<T>{} , public class HashSet<E>{}….等


说明:T , E只能是引用类型
看看下面语句是否正确?:

  1. List<Integer> list = new ArrayList<Integer>(); //OK
  2. List<int> list2 = new ArrayList<int> (): //错误  只能是引用数据类型 不能使用基本数据类型
  1. 在给泛型指定具体类型后,可以传入该类型或者其子类类型
    1. Pig<A> aPig = new Pig<A>(new A());
    2. aPig.f();
    3. Pig<A> aPig2 = new Pig<A>(new B());
    4. aPig2.f();
  1. 泛型使用形式
    1. ArrayList<Integer> list1 = new ArrayList<Integer>();
    2. List<Integer> list2 = new ArrayList<Integer>();
  1. 在实际开发中，我们往往简写
  2. 编译器会进行类型推断, 老师推荐使用下面写法
  1. ArrayList<Integer> list3 = new ArrayList<>();
  2. List<Integer> list4 = new ArrayList<>();
  3. ArrayList<Pig> pigs = new ArrayList<>();
  1. 如果我们这样写 List list3 = new ArrayList();默认绐它的泛型是[ E就是 Object]
  1. //4. 如果是这样写 泛型默认是 Object
  2.         ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
  4.         /*
  5.             public boolean add(Object e) {
  6.                 ensureCapacityInternal(size + 1);  // Increments modCount!!
  7.                 elementData[size++] = e;
  8.                 return true;
  9.             }
  10.          */
  11.         Tiger tiger = new Tiger();
  12.         /*
  14.             class Tiger {//类
  15.                 Object e;
  17.                 public Tiger() {}
  19.                 public Tiger(Object e) {
  20.                     this.e = e;
  21.                 }
  22.             }
  24.          */
  26.     }
  27. }
  1. class Tiger<E> {//类
  2.     E e;
  4.     public Tiger() {}
  6.     public Tiger(E e) {
  7.         this.e = e;
  8.     }
  9. }
  11. class A {}
  12. class B extends A {}
  14. class Pig<E> {//
  15.     E e;
  17.     public Pig(E e) {
  18.         this.e = e;
  19.     }
  21.     public void f() {
  22.         System.out.println(e.getClass()); //运行类型
  23.     }
  24. }

4. 自定义泛型

自定义泛型类

基本语法

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

注意细节

  1. 普通成员可以使用泛型(属性、方法)
  2. 使用泛型的数组,不能初始化
  3. 静态方法中不能使用类的泛型
  4. 泛型类的类型,是在创建对象时确定的(因为创建对象时,需要指定确定类型)
  5. 如果在创建对象时,没有指定类型,默认为 Object

应用案例

  1. public class CustomGeneric_ {
  2.     public static void main(String[] args) {
  4.         //T=Double, R=String, M=Integer
  5.         Tiger<Double,String,Integer> g = new Tiger<>("john");
  6.         g.setT(10.9); //OK
  7.         //g.setT("yy"); //错误，类型不对
  8.         System.out.println(g);
  9.         Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
  10.         g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
  11.         System.out.println("g2=" + g2);
  13.     }
  14. }
  16. //老韩解读
  17. //1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
  18. //2, T, R, M 泛型的标识符, 一般是单个大写字母
  19. //3. 泛型标识符可以有多个.
  20. //4. 普通成员可以使用泛型 (属性、方法)
  21. //5. 使用泛型的数组，不能初始化
  22. //6. 静态方法中不能使用类的泛型
  23. class Tiger<T, R, M> {
  24.     String name;
  25.     R r; //属性使用到泛型
  26.     M m;
  27.     T t;
  28.     //因为数组在new 不能确定T的类型，就无法在内存开空间
  29.     T[] ts;
  31.     public Tiger(String name) {
  32.         this.name = name;
  33.     }
  35.     public Tiger(R r, M m, T t) {//构造器使用泛型
  37.         this.r = r;
  38.         this.m = m;
  39.         this.t = t;
  40.     }
  42.     public Tiger(String name, R r, M m, T t) {//构造器使用泛型
  43.         this.name = name;
  44.         this.r = r;
  45.         this.m = m;
  46.         this.t = t;
  47.     }
  49.     //因为静态是和类相关的，在类加载时，对象还没有创建
  50.     //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
  51. //    static R r2;
  52. //    public static void m1(M m) {
  53. //
  54. //    }
  56.     //方法使用泛型
  58.     public String getName() {
  59.         return name;
  60.     }
  62.     public void setName(String name) {
  63.         this.name = name;
  64.     }
  66.     public R getR() {
  67.         return r;
  68.     }
  70.     public void setR(R r) {//方法使用到泛型
  71.         this.r = r;
  72.     }
  74.     public M getM() {//返回类型可以使用泛型.
  75.         return m;
  76.     }
  78.     public void setM(M m) {
  79.         this.m = m;
  80.     }
  82.     public T getT() {
  83.         return t;
  84.     }
  86.     public void setT(T t) {
  87.         this.t = t;
  88.     }
  90.     @Override
  91.     public String toString() {
  92.         return "Tiger{" +
  93.                 "name='" + name + '\'' +
  94.                 ", r=" + r +
  95.                 ", m=" + m +
  96.                 ", t=" + t +
  97.                 ", ts=" + Arrays.toString(ts) +
  98.                 '}';
  99.     }
  100. }
  1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
  2. T, R, M 泛型的标识符, 一般是单个大写字母
  3. 泛型标识符可以有多个.
  4. 普通成员可以使用泛型 (属性、方法)
  5. 使用泛型的数组，不能初始化
  6. 静态方法中不能使用类的泛型

5. 自定义泛型接口

基本语法

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

注意细节

  1. 接口中,静态成员也不能使用泛型(这个和泛型类规定一样)
  2. 泛型接口的类型,在继承接口或者实现接口时确定
  3. 没有指定类型,默认为 Object
  1. //在继承接口 指定泛型接口的类型
  2. interface IA extends IUsb<String, Double> {
  4. }
  5. //当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
  6. //，在实现IUsu接口的方法时，使用String替换U, 是Double替换R
  7. class AA implements IA {
  9.     @Override
  10.     public Double get(String s) {
  11.         return null;
  12.     }
  13.     @Override
  14.     public void hi(Double aDouble) {
  16.     }
  17.     @Override
  18.     public void run(Double r1, Double r2, String u1, String u2) {
  20.     }
  21. }
  23. //实现接口时，直接指定泛型接口的类型
  24. //给U 指定Integer 给 R 指定了 Float
  25. //所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
  26. class BB implements IUsb<Integer, Float> {
  28.     @Override
  29.     public Float get(Integer integer) {
  30.         return null;
  31.     }
  33.     @Override
  34.     public void hi(Float aFloat) {
  36.     }
  38.     @Override
  39.     public void run(Float r1, Float r2, Integer u1, Integer u2) {
  41.     }
  42. }
  43. //没有指定类型，默认为Object
  44. //建议直接写成 IUsb<Object,Object>
  45. class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {
  46.     @Override
  47.     public Object get(Object o) {
  48.         return null;
  49.     }
  50.     @Override
  51.     public void hi(Object o) {
  52.     }
  53.     @Override
  54.     public void run(Object r1, Object r2, Object u1, Object u2) {
  56.     }
  58. }
  60. interface IUsb<U, R> {
  62.     int n = 10;
  63.     //U name; 不能这样使用
  65.     //普通方法中，可以使用接口泛型
  66.     R get(U u);
  68.     void hi(R r);
  70.     void run(R r1, R r2, U u1, U u2);
  72.     //在jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
  73.     default R method(U u) {
  74.         return null;
  75.     }
  76. }

6. 自定义泛型方法

基本语法

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

注意细节

  1. 泛型方法,可以定义在普通类中也可以定义在泛型类中

  2. 当泛型方法被调用时,类型会确定

  3. public void eat(E e){},修饰符后没有<T,R..> eat方法不是泛型方法,而是使用了泛型

  4. 泛型可以理解为 : 可以接受数据类型的数据类型

  1. public class CustomMethodGeneric {
  2.     public static void main(String[] args) {
  3.         Car car = new Car();
  4.         car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
  5.         System.out.println("=======");
  6.         car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型
  8.         //测试
  9.         //T->String, R-> ArrayList
  10.         Fish<String, ArrayList> fish = new Fish<>();
  11.         fish.hello(new ArrayList(), 11.3f);
  12.     }
  13. }
  15. //泛型方法，可以定义在普通类中, 也可以定义在泛型类中
  16. class Car {//普通类
  18.     public void run() {//普通方法
  19.     }
  20.     //说明 泛型方法
  21.     //1. <T,R> 就是泛型
  22.     //2. 是提供给 fly使用的
  23.     public <T, R> void fly(T t, R r) {//泛型方法
  24.         System.out.println(t.getClass());//String
  25.         System.out.println(r.getClass());//Integer
  26.     }
  27. }
  29. class Fish<T, R> {//泛型类
  30.     public void run() {//普通方法
  31.     }
  32.     public<U,M> void eat(U u, M m) {//泛型方法
  34.     }
  35.     //说明
  36.     //1. 下面hi方法不是泛型方法
  37.     //2. 是hi方法使用了类声明的 泛型
  38.     public void hi(T t) {
  39.     }
  40.     //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
  41.     public<K> void hello(R r, K k) {
  42.         System.out.println(r.getClass());//ArrayList
  43.         System.out.println(k.getClass());//Float
  44.     }
  46. }

7. 自定义泛型练习

  1. public class CustomMethodGenericExercise {
  2.     public static void main(String[] args) {
  3.         //T->String, R->Integer, M->Double
  4.         Apple<String, Integer, Double> apple = new Apple<>();
  5.         apple.fly(10);//10 会被自动装箱 Integer10, 输出Integer
  6.         apple.fly(new Dog());//Dog
  8.     }
  9. }
  11. class Apple<T, R, M> {//自定义泛型类
  13.     public <E> void fly(E e) {  //泛型方法
  14.         System.out.println(e.getClass().getSimpleName());  //会输出运行类型的包名
  15.     }
  17.     //public void eat(U u) {}//错误，因为U没有声明
  18.     public void run(M m) {
  19.     } //ok
  20. }
  22. class Dog {
  23. }

e.getClass() : 显示包名和类名

e.getClass().getSimpleName() : 只显示类名

8. 泛型的继承和通配符

泛型的继承和通配符说明

  1. 泛型不具备继承性
    1. List<Object> list = new ArrayList<String>();//不对

  1. <?> : 支持任意泛型类型

  2. <? extends A> : 支持A类以及A类的子类,规定了泛型的上限

  3. <? super A> : 支持A类以及A类的父类,不限于直接父类,规定了泛型的下限

  1. public class GenericExtends {
  2.     public static void main(String[] args) {
  4.         Object o = new String("xx");
  6.         //泛型没有继承性
  7.         //List<Object> list = new ArrayList<String>();
  9.         //举例说明下面三个方法的使用
  10.         List<Object> list1 = new ArrayList<>();
  11.         List<String> list2 = new ArrayList<>();
  12.         List<AA> list3 = new ArrayList<>();
  13.         List<BB> list4 = new ArrayList<>();
  14.         List<CC> list5 = new ArrayList<>();
  16.         //如果是 List<?> c ，可以接受任意的泛型类型
  17.         printCollection1(list1);
  18.         printCollection1(list2);
  19.         printCollection1(list3);
  20.         printCollection1(list4);
  21.         printCollection1(list5);
  23.         //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
  24. //        printCollection2(list1);//×
  25. //        printCollection2(list2);//×
  26.         printCollection2(list3);//√
  27.         printCollection2(list4);//√
  28.         printCollection2(list5);//√
  30.         //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
  31.         printCollection3(list1);//√
  32.         //printCollection3(list2);//×
  33.         printCollection3(list3);//√
  34.         //printCollection3(list4);//×
  35.         //printCollection3(list5);//×
  38.         //冒泡排序
  40.         //插入排序
  42.         //....
  45.     }
  46.     // ? extends AA 表示 上限，可以接受 AA或者AA子类
  47.     public static void printCollection2(List<? extends AA> c) {
  48.         for (Object object : c) {
  49.             System.out.println(object);
  50.         }
  51.     }
  53.     //说明: List<?> 表示 任意的泛型类型都可以接受
  54.     public static void printCollection1(List<?> c) {
  55.         for (Object object : c) { // 通配符，取出时，就是Object
  56.             System.out.println(object);
  57.         }
  58.     }
  62.     // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，
  63.     //规定了泛型的下限
  64.     public static void printCollection3(List<? super AA> c) {
  65.         for (Object object : c) {
  66.             System.out.println(object);
  67.         }
  68.     }
  70. }
  72. class AA {
  73. }
  75. class BB extends AA {
  76. }
  78. class CC extends BB {
  79. }

9. JUnit 单元测试类

为什么需要JUnit

  1. 一个类有很多功能代码需要测试,为了测试,就需要写入到main方法中

  2. 如果有多个功能代码测试,就需要来回注销,切换很麻烦

  3. 如果可以直接运行一个方法,就方便很多,并且可以给出相关信息,就好了-> JUnit

基本介绍

  1. JUnit是一个Java语言的单元测试框架
  2. 多数Java的开发环境都已经集成了 JUnit 作为单元测试的工具
  1. public class JUnit_ {
  2.     public static void main(String[] args) {
  3.         //传统方式
  4.         //new JUnit_().m1();
  5.         //new JUnit_().m2();
  7.     }
  8.     @Test
  9.     public void m1() {
  10.         System.out.println("m1方法被调用");
  11.     }
  13.     @Test
  14.     public void m2() {
  15.         System.out.println("m2方法被调用");
  16.     }
  18.     @Test
  19.     public void m3() {
  20.         System.out.println("m3方法被调用");
  21.     }
  22. }

@Test

Alt + Enter

10. 练习

Dao

  1. /**
  2.  * 定义个泛型类 DAO<T>，在其中定义一个Map 成员变量，Map 的键为 String 类型，值为 T 类型。
  3.  *  *
  4.  *  * 分别创建以下方法：
  5.  *  * (1) public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中
  6.  *  * (2) public T get(String id)：从 map 中获取 id 对应的对象
  7.  *  * (3) public void update(String id,T entity)：替换 map 中key为id的内容,改为 entity 对象
  8.  *  * (4) public List<T> list()：返回 map 中存放的所有 T 对象
  9.  *  * (5) public void delete(String id)：删除指定 id 对象
  10.  */
  11. public class DAO<T> {//泛型类
  12.     private Map<String, T> map = new HashMap<>();
  14.     public T get(String id) {
  15.         return map.get(id);
  16.     }
  17.     public void update(String id,T entity) {
  18.         map.put(id, entity);
  19.     }
  20.     //返回 map 中存放的所有 T 对象
  21.     //遍历map [k-v],将map的 所有value(T entity),封装到ArrayList返回即可
  22.     public List<T> list() {
  23.         //创建 Arraylist
  24.         List<T> list = new ArrayList<>();
  26.         //遍历map
  27.         Set<String> keySet = map.keySet();
  28.         for (String key : keySet) {
  29.             //map.get(key) 返回就是 User对象->ArrayList
  30.             list.add(map.get(key));//也可以直接使用本类的 get(String id)
  31.         }
  33.         return list;
  34.     }
  35.     public void delete(String id) {
  36.         map.remove(id);
  37.     }
  38.     public void save(String id,T entity) {//把entity保存到map
  39.         map.put(id, entity);
  41.     }
  43. }

Test

  1. public class Homework01 {
  2.     public static void main(String[] args) {
  4.     }
  6.     @Test
  7.     public void testList() {
  8.         //说明
  9.         //这里我们给T 指定类型是User
  10.         DAO<User> dao = new DAO<>();
  11.         dao.save("001", new User(1,10,"jack"));
  12.         dao.save("002", new User(2,18,"king"));
  13.         dao.save("003", new User(3,38,"smith"));
  15.         List<User> list = dao.list();
  17.         System.out.println("list=" + list);
  19.         dao.update("003", new User(3, 58, "milan"));
  20.         dao.delete("001");//删除
  21.         System.out.println("===修改后====");
  22.         list = dao.list();
  23.         System.out.println("list=" + list);
  25.         System.out.println("id=003 " + dao.get("003"));//milan
  27.     }
  28. }

User

  1. public class User {
  2.     private int id;
  3.     private int age;
  4.     private String name;
  6.     public User(int id, int age, String name) {
  7.         this.id = id;
  8.         this.age = age;
  9.         this.name = name;
  10.     }
  12.     public int getId() {
  13.         return id;
  14.     }
  16.     public void setId(int id) {
  17.         this.id = id;
  18.     }
  20.     public int getAge() {
  21.         return age;
  22.     }
  24.     public void setAge(int age) {
  25.         this.age = age;
  26.     }
  28.     public String getName() {
  29.         return name;
  30.     }
  32.     public void setName(String name) {
  33.         this.name = name;
  34.     }
  36.     @Override
  37.     public String toString() {
  38.         return "User{" +
  39.                 "id=" + id +
  40.                 ", age=" + age +
  41.                 ", name='" + name + '\'' +
  42.                 '}';
  43.     }
  44. }