Java-Day-21（ 泛型 + JUnit ）
Java-Day-21
泛型
( generic )
理解和好处
-
传统方法：
ArrayList arrayList = new ArrayList(); arrayList.add(new Person(1001, "AA")); // 若是误入一个 new Animal(.....) // get获取输出的时候是用Person类的， // 所以会报类型转换依次错误，而且错误不一定好发现 for (Object o : arrayList) { // 语法不支持直接把Object换成Person Person per = (Person) o; System.out.println(per.getName() + "-" + per.getAge()); }- 不能对加入到集合 ArrayList 中的数据类型进行约束(不安全)
- 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响
-
所以引出泛型
ArrayList<Person> arrayList = new ArrayList<Person>(); ..... for (Person person : arrayList) { // 这样就不需要再取出时转型了 // .... }- 这样若是无意添加了其他类型的对象就会检测出来报错 ( 做了限制 )
-
好处：
- 编译时，检查添加元素的类型，提高了安全性
- 减少了类型转换的次数，提高效率
介绍
-
< E > 表示某一种数据类型，具体是自行指定的，一种数据类型的 ( 可变 ) 类型
- 设置前广泛，指定后约束 ( 有的用 < T > )
-
泛型又称参数化类型，是 JDK5.0 出现的新特性，解决数据类型的安全性问题
-
在类声明或实例化时只要指定好需要的具体类型即可
- 但不能是基本数据类型，但可以用其包装类
-
Java 泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生 ClassCastException 类型转换异常，使代码更简洁、健壮
-
泛型的作用是：可以在类声明时通过一个标识表示类中的某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型
public class test1 {
public static void main(String[] args) {
Person<String> person = new Person<String>("zyz");
Person<Integer> person2 = new Person<Integer>(12315);
// t方法显示已创对象的运行类型
person.t(); // class java.lang.String
person2.t(); // class java.lang.Integer
}
}
class Person<E> {
// String crud; // 但有的时候想用其Integer类型
E crud; // E表示s的数据类型，该数据类型在定义Person对象时指定，即在编译期间(定义的时候)就确定了E的类型
public Person(E crud) { // E也可以是参数类型
this.crud = crud;
}
public E f() { // 也可以是返回类型用E
return crud;
}
public void t() {
System.out.println(crud.getClass());
}
}
使用
-
泛型声明
- interface 接口 < T > {}
- class 类 <K, V ...> {} —— 需要多个泛型时
- 其中 T、K、V 不代表值，而是表示类型
- 任意字母都可以，常用 T ( Type )
-
泛型的实例化
-
要在类名后面指定类型参数的值 ( 类型 )
List<String> strList = new ArrayList<String>(); Iterator<Customer> iterator = customers.iterator();
-
-
练习：创建三个学生对象
放 HashSet 中学生对象
放 HashMap 中，要求 Key 是 String name，Value 是学生对象
public class test1 { public static void main(String[] args) { HashSet<Student> set = new HashSet<Student>(); // 指定了为Student set.add(new Student("zyz", 22)); set.add(new Student("java", 80)); set.add(new Student("duang", 54)); for (Student student : set) { System.out.println(student); } // 严格规范了put存入的类型模式 HashMap<String, Student> hashmap = new HashMap<String, Student>(); // 已经把HashMap里所有的K和V都做了指定 hashmap.put("zyz", new Student("zyz", 22)); hashmap.put("java", new Student("java", 80)); hashmap.put("duang", new Student("duang", 54)); // 迭代器 EntrySet 取出的类型确定 /* public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es; return (es = entrySet) == null ? (entrySet = new EntrySet()) : es; } 确定类型是Map.Entry<K,V>，而前面定义时已经把 K,V 都做了指定 */ Set<Map.Entry<String, Student>> entries = hashmap.entrySet(); // .var直接填充，因为Map.Entry里K和V已经指定了 Iterator<Map.Entry<String, Student>> iterator = entries.iterator(); // .var直接填充 } } class Student<E> { public String name; public int age; public Student(String name, int age) { super(); this.name = name; this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
注意事项和细节
-
泛型指向数据类型 T、E 只能是引用类型
- 即不能是基本数据类型
-
在给泛型指定具体类型后，可以传入该类型或者其子类类型
public class test1 { public static void main(String[] args) { Pig<Everything> pig = new Pig<Everything>(new Everything()); Pig<Everything> pig1 = new Pig<Everything>(new Animal()); } } class Everything {} class Animal extends Everything{} -
泛型使用形式
-
规范型：
ArrayList<Integer> list1 = new ArrayList<Integer>();List<Integer> list2 = new ArrayList<Integer>(); -
推荐、开发时常用简写：
ArrayList<Integer> list3 = new ArrayList<>();后面的<>内编译器会进行类型判断
-
常见默认 ( 应有却没写就是 Object )
ArrayList list4 = new ArrayList();-
实际就等价于：
ArrayList<Object> list4 = new ArrayList<>();
-
-
-
Required type 所需该放的类型
-
Provided 自己放进的类型
练习
- 定义 Employee 类
- 该类包含：private 成员变量 name，sal，birthday，其中 birthday 为 MyDate 类的对象
- 为每一个属性定义 getter， setter 方法
- 重写 toString 方法输出name，sal，birthday
- MyDate 类包含：private 成员变量month，day，year；并为每一个属性定义 getter，setter方法
- 创建该类的 3 个对象，并把这些对象放入 ArrayList 集合中 ( ArrayList 需使用泛型来定义 )，对集合中的元素进行排序，并遍历输出：
- 排序方式：调用 ArrayList 的 sort 方法，传入 Comparator 对象 [ 使用泛型 ]，先按照 name 排序，如果 name 相同，则按生日日期的先后排序，即：定制排序
- 由于代码太长，没有用到的set方法就没在此展示
// test.java
public class test {
public static void main(String[] args) {
ArrayList<Employee> employees = new ArrayList<>();
employees.add(new Employee("zyz", 100, new MyDate(2000,1,1)));
employees.add(new Employee("java", 2200, new MyDate(1000,1,1)));
employees.add(new Employee("duang", 33300, new MyDate(1999,1,1)));
employees.add(new Employee("duang", 33300, new MyDate(1999,2,1)));
System.out.println(employees);
System.out.println("sort方法：重写Comparator内的compare方法:");
employees.sort(new Comparator<Employee>() {
@Override
// 要求:先按照 name 排序,如果name相同,就按照生日的先后顺序
public int compare(Employee o1, Employee o2) {
// 先对传入的参数进行验证
if (!(o1 instanceof Employee && o2 instanceof Employee)) {
System.out.println("类型不匹配，返回不加以比较");
return 0;
}
// 先比较名字
int i = o1.getName().compareTo(o2.getName()); // 名字是String,自带比较方法
// o1:java o2:zyz (旧值)
if (i != 0) {
// 名字不相同
return i;
}
// 把年月日的比较都放进来显得麻烦不规范
//// 名字相同就比较birthday - year
// int yearMinus = o1.getBirhday().getYear() - o2.getBirhday().getYear(); // int直接用减法即可
// if (yearMinus != 0) {
// return yearMinus;
// }
//// 如果year相同,就比较 month
// int monthMinus = o1.getBirhday().getMonth() - o2.getBirhday().getMonth();
// ......
// return o1.getBirhday().getDay() - o2.getBirhday().getDay();
return o1.getBirhday().compareTo(o2.getBirhday());
}
});
System.out.println(employees);
}
}
class Employee {
private String name;
private double sal;
private MyDate birhday;
public Employee(String name, double sal, MyDate birhday) {
this.name = name;
this.sal = sal;
this.birhday = birhday;
}
public String getName() {
return name;
}
public double getSal() {
return sal;
}
public MyDate getBirhday() {
return birhday;
}
@Override
public String toString() {
return "\nEmployee{" +
"name='" + name + '\'' +
", sal=" + sal +
", birhday=" + birhday +
'}';
}
}
// MyDate.java
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 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) {
// 名字相同就比较birthday - year
int yearMinus = year - o.getYear(); // 本类的(想比较的) - 传进来的(被比较的)
if (yearMinus != 0) {
return yearMinus;
}
// 如果year相同,就比较 month
int monthMinus = month - o.getMonth();
if (monthMinus != 0) {
return monthMinus;
}
// month 也相同
return day - o.getDay();
}
}
-
把年月日比较方法放进 MyDate.java 里，这样封装后，将来可维护性和复用性就大大增加，所需便调用 ( OOP )
-
接口 Comparator< T > 里面的 compare(T o1, T o2) 是传入两个对象
-
接口 Comparable< T > 里面的 compareTo(T o) 是传入的一个对象
-
自定义泛型
自定义泛型类
-
基本语法
- class 类名<T, R ...>
-
注意细节
-
普通成员可以使用泛型 ( 属性、方法 )
class Animal <T, R, M> { String name; T tou; R rbody; M mleg; public Animal(String name, T tou, R rbody, M mleg) { this.name = name; this.tou = tou; this.rbody = rbody; this.mleg = mleg; } } -
使用泛型的数组，不能初始化
// 用泛型的话,数组new初始化时不能确定类型,就无法开辟空间,就会报错 // T[] ts = new T[8]; // 泛型数组不能实例化,但是可以单纯定义 T[] ts; // 可以 -
静态方法中不能使用类的泛型 ( 但并非静态不能使用，细见泛型的继承部分 )
// 静态static和类的泛型不共存 public static void m1(M m) { // 因为静态是类加载(对象还未创建)就触发了,仍没法确定类型,JVM就不能初始化 // 泛型具体是在定义时确定的 } -
泛型类的类型，是在创建对象时确定的 ( 因为创建对象时，需要指定确定类型 )
-
如果在创建对象时，没有指定类型，就默认 Object
-
-
练习
public class test1 { public static void main(String[] args) { Animal<Double, String, Integer> a = new Animal<>("zyz"); // 则已经定下 T是Double,R是String,M是Integer a.setTdou(9.99); // a.setTdou("duang"); // 报错 System.out.println(a); Animal a2 = new Animal("java~duang"); // 默认的话 T,R,M 都是 Object 类,都可以接收 a2.setTdou("zyz"); a2.setTdou(1010); // 都正确,此处替换了 zyz System.out.println(a2); } } // 自定义泛型类: Animal class Animal <T, R, M> { String name; T tdou; R rstr; M mint; public Animal(String name) { this.name = name; } public Animal(T tdou, R rstr, M mint) { this.tdou = tdou; this.rstr = rstr; this.mint = mint; } public T getTdou() { return tdou; } public void setTdou(T tdou) { this.tdou = tdou; } @Override public String toString() { return "Animal{" + "name='" + name + '\'' + ", tdou=" + tdou + ", rstr=" + rstr + ", mint=" + mint + '}'; } }
自定义泛型接口
-
基本语法
- interface 接口名<T, R ...>
-
注意细节
- 接口中，静态成员也不能使用泛型
- 泛型接口的类型，在继承接口或者实现接口时确定
- 没有指定类型，就默认 Object
-
练习
- 已知泛型接口
// 自定义泛型接口: IUsb interface IUsb<U, R> { int n = 10; // 接口中成员都是默认静态性质的: public static final // U name = "zyz"; // 普通方法中,可以使用接口泛型 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; } }- 类直接实现接口
// 类实现泛型接口 // U指定了Integer,R指定了Float class BBB 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) { } }- 类间接实现指定过了的接口
// 在继承接口时指定泛型接口的类型 interface IA extends IUsb<String, Double> { // 但凡是使用了IA接口的,都在实现IUsb方法的时候: U即String R即Double } // 类实现指定了泛型接口的接口(继承) class AAA implements IA { // ctrl + I 快捷出要指定的方法 // 方法在填入时就自动指定了先前泛型所指定类型 @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) { } }- 默认指定
// 类默认指定泛型就是 Object,最好是默认的话也写上 //class CCC implements IUsb<Object, Object> {}
自定义泛型方法
-
基本语法
- 修饰符 < T, R ... > 返回类型 方法名 ( 参数列表 )
-
注意细节
- 泛型方法，可以定义在普通类中，也可以定义在泛型类中
- 当泛型方法被调用时，类型会确定
- public void eat ( E e ) {}，修饰符后没有 < T, R ... > eat 方法不是泛型方法，而是使用了泛型
-
练习
- 普通类里
class Car { // 普通类 public void run() { // 普通方法 } public <T, R> void fly(T t, R r) { // <T, R> 泛型方法 System.out.println(t.getClass()); System.out.println(r.getClass()); } }- 泛型类里
class Ship<T,R> { // 泛型类 public void swim(T t) { // 注: 普通方法可以使用类声明的泛型,但并不代表是泛型方法 } // 泛型方法 != 方法使用泛型 public <U, M> void eat(U u, M m) { // 泛型方法,为区分最好取和类不同的表示,如: U, M } // 方法使用泛型还是看具体情况 public <K> void dalal(R r, K k) { // 但是泛型方法里还是既可以使用类声明的泛型,也可以自行声明使用 System.out.println(r.getClass()); System.out.println(k.getClass()); } } // 泛型方法里的参数要不就是类的泛型，要不就是泛型方法自带，不能凭空出现- main 方法里
public class test { public static void main(String[] args) { Car car = new Car(); // 调用方法时传入参数,编译器会自行确定类型如何 car.fly("霸天虎", 101); // 确定了类型,控制台输出: String, Integer (会自动装箱的) Ship<String, ArrayList> ship = new Ship<>(); ship.dalal(new ArrayList<>(), 0.5f); // 控制台输出:ArrayList, Float } }
泛型的继承和通配符
-
泛型不具备继承性
Object o = new String("zyz"); // 不会报错 List<Object> list = new ArrayList<String>(); // 语句报错 // 泛型里的 Object 和 String 就无继承关系 -
< ? > ：支持任意泛型类型
// 已知: class Son extends Father{} class Father extends Grandpa{} class Grandpa {} // public class test 内 // 任意泛型类型都可接收 public static void printCollection1(List<?> c) { for (Object object : c) { System.out.println(object); } } -
< ? extends A >：支持 A 类以及 A 类的子类，规定了泛型的上限
// 定上限, 可接收 Son, Father, Grandpa public static void printCollection2(List<? extends Grandpa> g) { } -
< ? super A >：支持 A 类以及 A 类的父类，不限于直接父类，规定了泛型的下限
// 定下限, 支持 Son, Father, Grandpa public static void printCollection3(List<? super Father> s) { } -
main 部分
// public class test 内 public static void main(String[] args) { List<Object> list_Object = new ArrayList<>(); List<String> list_String = new ArrayList<>(); List<Grandpa> list_Grandpa = new ArrayList<>(); List<Father> list_Father = new ArrayList<>(); List<Son> list_Son = new ArrayList<>(); // 上述List都确定了泛型的类型,即可验证方法可接收的泛型类型 printCollection1(list_Object); printCollection1(list_String); printCollection1(list_Grandpa); printCollection1(list_Father); printCollection1(list_Son); // 都可以接收 // List<? extends Grandpa> g 已知 // printCollection2(list_Object); // 最顶层,报错 // printCollection2(list_String); // 与Grandpa无关,则报错 printCollection2(list_Grandpa); printCollection2(list_Father); printCollection2(list_Son); // List<? super Father> s 已知 printCollection3(list_Object); // printCollection3(list_String); // 报错 printCollection3(list_Grandpa); printCollection3(list_Father); // printCollection3(list_Son); // 最低 Father }
练习
- 定义个泛型类 DAO< T >，在其中定义一个 Map 成员变量，Map 的键为 String 类型，值为 T 类型。分别创建以下方法:
- public void save(String number,T entity)：保存 T 类型的对象到 Map 成员变量中
- public T get(String number)：从 map 中获取 number对应的对象
- public void update(String number, T entity)：替换 map 中 key 为 number的内容，改为 entity 对象
- public List< T > list()：返回 map 中存放的所有 T 对象
- public void delete(String number)：删除指定 number 对象
- 定义一个 User 类：该类包含: private 成员变量 ( int 类型 ) id，age；( String 类型 ) name。
- 创建 DAO 类的对象，分别调用其 save、get、update、list、delete 方法来操作 User 对象，使用 Junit 单元测试类进行测试。
// User.java
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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", age=" + age +
", 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;
}
}
// DAO.java
public class DAO<T> {
// String 键; T 值
private Map<String, T> map = new HashMap<>();
public void save(String number, T entity) {
map.put(number, entity);
}
// get()根据id获取值
public T get(String number) {
return map.get(number);
}
public void update(String number, T entity) {
map.put(number, entity);
}
// 返回map中存放的所有T对象
// 遍历map[k-v],将所有的value(T entity),封装到ArrayList返回
public List<T> list() {
List<T> list = new ArrayList<>();
Set<String> keySet = map.keySet();
for (String key : keySet) {
// list.add(map.get(key));
list.add(get(key)); // 本类定义了
}
return list;
}
public void delete(String number) {
map.remove(number);
}
}
// main 所在test1.java(但没用main)
public class test1 {
public static void main(String[] args) { }
@Test
public void testList() {
DAO<User> dao = new DAO<>();
// 指定了T为User
// 都存进了DAO里的map中
dao.save("001", new User(1, 10, "zyz"));
dao.save("002", new User(2, 20, "java"));
dao.save("003", new User(3, 30, "duang"));
List<User> list = dao.list(); // 泛型DAO里定义: ArrayList
// map存, ArrayList调用，
// 感觉就好似先前跟踪源码，add增加 —— 实际是调用了map的put方法
System.out.println("list = " + list);
dao.delete("001");
dao.update("002", new User(2, 999, "godman"));
list = dao.list();
System.out.println("修改后 list = " + list);
User user = dao.get("002");
System.out.println("单独取出002 number的数据信息 = " + user);
}
}
- 使用 Junit 单元测试类进行测试。
JUnit
引出
- 一个类有很多功能代码需要测试，为了测试，就需要写入到 main 方法中
- 如果有多个功能代码测试，就需要来回注销，切换麻烦
- 如果可以直接运行一个方法，就方便很多，并且可以给出相关信息就好
基本介绍
- JUnit 是一个 Java 语言的单元测试框架
- 多数 Java 的开发环境都已经集成了 JUnit 作为单元测试的工具
