Java基础 9.26
1.自定义泛型接口
基本语法
interface 接口名<T, R...>{}
注意细节
- 接口中，静态成员也不能使用泛型(这个和泛型类规定一样)
- 泛型接口的类型，在继承接口或者实现接口时确定
- 没有指定类型，默认为Object
/*** @author logic* @version 1.0*/
public class CustomInterfaceGeneric {public static void main(String[] args) {}
}/*** 泛型接口使用的说明* 1. 接口中，静态成员也不能使用泛型* 2. 泛型接口的类型, 在继承接口或者实现接口时确定* 3. 没有指定类型，默认为Object*///在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {}
//当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
//，在实现IUsu接口的方法时，使用String替换U, 是Double替换R
class AA implements IA {@Overridepublic Double get(String s) {return null;}@Overridepublic void hi(Double aDouble) {}@Overridepublic void run(Double r1, Double r2, String u1, String u2) {}
}//实现接口时，直接指定泛型接口的类型
//给U 指定Integer 给 R 指定了 Float
//所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
class BB implements IUsb<Integer, Float> {@Overridepublic Float get(Integer integer) {return null;}@Overridepublic void hi(Float aFloat) {}@Overridepublic void run(Float r1, Float r2, Integer u1, Integer u2) {}
}
//没有指定类型，默认为Object
//建议直接写成 IUsb<Object,Object>
class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {@Overridepublic Object get(Object o) {return null;}@Overridepublic void hi(Object o) {}@Overridepublic 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;}
}2.自定义泛型方法
基本语法
修饰符 <T, R...> 返回类型 方法名(参数列表) {}
注意细节
- 泛型方法，可以定义在普通类中，也可以定义在泛型类中
- 当泛型方法被调用时，类型会确定
- public void eat(E e)(}，修饰符后没有<T,R .. > eat方法不是泛型方法，而是使用了泛型
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-> ArrayListFish<String, ArrayList> fish = new Fish<>();fish.hello(new ArrayList(), 11.3f);}
}//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类public void run() {//普通方法}//说明 泛型方法//1. <T,R> 就是泛型//2. 是提供给 fly使用的public <T, R> void fly(T t, R r) {//泛型方法System.out.println(t.getClass());//StringSystem.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());//ArrayListSystem.out.println(k.getClass());//Float}}
3.泛型的继承和通配符
- 泛型不具备继承性
- <?>：支持任意泛型类型
- <? extends A>：支持A类以及A类的子类，规定了泛型的上限
- <? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限
package com.logic.generic;import java.util.ArrayList;
import java.util.List;/*** @author logic* @version 1.0* 泛型的继承和通配符*/
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 ，可以接受任意的泛型类型printCollection1(list1);printCollection1(list2);printCollection1(list3);printCollection1(list4);printCollection1(list5);//List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
// printCollection2(list1);//×
// printCollection2(list2);//×printCollection2(list3);//√printCollection2(list4);//√printCollection2(list5);//√//List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类printCollection3(list1);//√//printCollection3(list2);//×printCollection3(list3);//√//printCollection3(list4);//×//printCollection3(list5);//×//冒泡排序//插入排序//....}// ? extends AA 表示 上限，可以接受 AA或者AA子类public static void printCollection2(List<? extends AA> c) {for (Object object : c) {System.out.println(object);}}//说明: List<?> 表示 任意的泛型类型都可以接受public static void printCollection1(List<?> c) {for (Object object : c) { // 通配符，取出时，就是ObjectSystem.out.println(object);}}// ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，//规定了泛型的下限public static void printCollection3(List<? super AA> c) {for (Object object : c) {System.out.println(object);}}}class AA {
}class BB extends AA {
}class CC extends BB {
}4.介绍JUnit
为什么需要JUnit
- 一个类有很多功能代码需要测试，为了测试，就需要写入到main方法中
- 如果有多个功能代码测试，就需要来回注销，切换很麻烦
- 如果可以直接运行一个方法，就方便很多，并且可以给出相关信息，就好了->JUnit
基本介绍
- JUnit是一个Java语言的单元测试框架
- 多数Java的开发环境都已经集成了JUnit作为单元测试工具
5.泛型练习
import org.junit.jupiter.api.Test;import java.util.List;public class Homework01 {public static void main(String[] args) {}@Testpublic void testList() {//说明//这里我们给T 指定类型是UserDAO<User> dao = new DAO<>();dao.save("001", new User(1,10,"jack"));dao.save("002", new User(2,18,"king"));dao.save("003", new User(3,38,"smith"));List<User> list = dao.list();System.out.println("list=" + list);dao.update("003", new User(3, 58, "milan"));dao.delete("001");//删除System.out.println("===修改后====");list = dao.list();System.out.println("list=" + list);System.out.println("id=003 " + dao.get("003"));//milan}
}
/*** 定义个泛型类 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)：删除指定 id 对象** 定义一个 User 类：* 该类包含：private成员变量（int类型） id，age；（String 类型）name。** 创建 DAO 类的对象， 分别调用其 save、get、update、list、delete 方法来操作 User 对象，* 使用 Junit 单元测试类进行测试。** 思路分析* 1. 定义User类* 2. 定义Dao<T>泛型类*/
import java.util.*;* 定义个泛型类 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)：删除指定 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() {//创建 ArraylistList<T> list = new ArrayList<>();//遍历mapSet<String> keySet = map.keySet();for (String key : keySet) {//map.get(key) 返回就是 User对象->ArrayListlist.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保存到mapmap.put(id, entity);}}
/*** 该类包含：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;}@Overridepublic String toString() {return "User{" +"id=" + id +", age=" + age +", name='" + name + '\'' +'}';}
}