Java泛型02

5.自定义泛型

5.1自定义泛型类

基本语法：

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

注意细节：

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

例子：

// Tiger后面有泛型，所以我们把 Tiger称为自定义泛型类 class Tiger<T,R,M>{// 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; } //因为静态是和类相关的，在来加载的时候，对象还没有创建 //所以如果静态方法和静态属性使用到泛型，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) + }; } }

练习：说明自定义泛型代码是否正确，并说明原因

package li.generic.customgeneric; import java.util.Arrays; public class CustomGeneric_ { public static void main(String[] args) { //T=Double , R=String , M=Integer Tiger<Double,String ,Integer> g = new Tiger<>("john");//ok g.setT(10.9);//ok // g.setT("yy");//错误，类型不对 System.out.println(g); //这里没有指定泛型类型，全部默认为Object类型 //T=Object , R=Object , M=Object Tiger g2 = new Tiger("join~~"); g2.setT("yy");//ok,因为T为Object类型，“yy”为String类型，是Object的子类 System.out.println("g2="+g2); } }

5.2自定义泛型接口

基本语法：

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

注意细节：

接口中，静态成员不能使用泛型（这个和泛型类的规定一样） 泛型接口的类型，在继承接口或者实现接口时确定 没有指定类型，就默认为Object类

例子：

package li.generic.customgeneric; public class CustomInterfaceGeneric { public static void main(String[] args) { } } interface IUsb<U,R>{ //U name; //这里的接口属性默认前面加上了static final，接口中，静态成员不能使用泛型 //普通方法中，可以使用接口泛型 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; } } // 在继承接口时，指定泛型接口的类型 interface IA extends IUsb<String,Double>{ } //当我们去实现IA接口时，因为IA在继承IUsb接口时，指定了U为String类型，R为 Double类型 //因此，在实现IUsb方法的时候，使用String替换U，使用Double替换R class 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替换R class 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 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) { } }

5.3自定义泛型方法

基本语法：

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

注意细节：

泛型方法，可以定义在普通类中，也可以定义在泛型类中 当泛型方法被调用时，类型会确定 public void eat(E e){},修饰符后面没有<T,R...> 则eat方法不是泛型方法，只是使用了泛型

例子：

package li.generic.customgeneric; import java.util.ArrayList; public class CustomMethodGeneric { public static void main(String[] args) { Car car = new Car(); car.fly("宝马", 100);//当调用方法时，传入参数，编译器就会确定类型 // class java.lang.String //class java.lang.Integer System.out.println("=========="); car.fly(300, 100.7);//当调用方法时，传入参数，编译器就会确定类型 //class java.lang.Integer //class java.lang.Double System.out.println("=========="); //fish的T=String，R=ArrayList Fish<String, ArrayList> fish = new Fish<>(); fish.hello(new ArrayList(),11.3f); //class java.util.ArrayList //class java.lang.Float } } //泛型方法，可以定义在普通的类中，也可以定义在泛型类中 class Car {//普通类 public void run() {//普通方法 } //<T,R>就是泛型，是提供给fly方法使用的 public <T, R> void fly(T t, R r) {//泛型方法 System.out.println(t.getClass()); System.out.println(r.getClass()); } } class Fish<T, R> {//泛型类 public void run() {//普通方法 } public <U, M> void eat(U u, M m) {//泛型方法 } //说明：下面的hi方法不是泛型方法，因为修饰符后面没有表示符<T,R...> //是hi方法使用了类声明的泛型 public void hi(T t) { } //泛型方法可以使用类声明的泛型，也可以使用自己声明的泛型 public <K> void hello(R r,K k){//R是类声明的标识符，K则是方法自己声明的标识符 System.out.println(r.getClass()); System.out.println(k.getClass()); } }

5.4泛型方法练习

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

package li.generic.customgeneric; public class CustomMethodGenericExercise { public static void main(String[] args) { Apple<String, Integer, Double> apple = new Apple<>();//ok apple.fly(10);//ok 10会被自动装箱，输出Integer apple.fly(new Dog());//ok 输出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) { } } class Dog { }

6.泛型继承和通配

泛型的继承和通配符说明：

泛型不具备继承性

List

<?> ：支持任意泛型类型

<? extends A>：支持A类以及A类的子类，规定了泛型的上限

<? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

例子：

package li.generic; 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 可以接受任意的泛型类型 printCollection1(list1); printCollection1(list2); printCollection1(list3); printCollection1(list4); printCollection1(list5); // ? extends AA 表示上限，可以接受AA或者AA的子类，不限于直接子类 // printCollection2(list1);//错误，list1是Object类型 // printCollection2(list2);//错误，list2是String类型 printCollection2(list3);//正确，AA printCollection2(list4);//正确，BB继承了AA类 printCollection2(list5);//正确，CC继承了BB类 //? super AA:表示可以接受AA类以及AA的父类，不限于直接父类 printCollection3(list1);//正确，Object类是所有类的父类 // printCollection3(list2);//错误，String类非AA类的父类 printCollection3(list3);//正确，AA //printCollection3(list4);//错误，BB类非AA的父类 //printCollection3(list5);//错误，CC类非AA类的父类 } //编写几个方法 //List<?> 表示任意的泛型类型都可以接收 public static void printCollection1(List<?> c) { for (Object object : c) {//通配符，取出时就是Object System.out.println(object); } } //? extends AA ：表示上限，可以接受AA或者AA的子类，不限于直接子类 public static void printCollection2(List<? extends AA> c) { for (Object object : c) { System.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 { }

7.泛型练习

7.1编程题 HomeWork01

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

分别创建以下方法：

public void save（String id，T entity）：保存T类型的对象到Map成员变量中 public T get（String id）：从map中 获取id对应的对象 public void update（String id，T entity）：替换map中key为id的内容，改为entity对象 public List list（）：返回map中存放的所有T对象 public void delete（String id）：删除指定id对象

定义一个User类：该类包含：private成员变量（int类型）id，age；（String类型）name

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

为什么需要JUnit：

一个类很多功能代码需要测试，为了测试就需要将测试代码写到main方法中

如果有多个功能代码测试，就需要来回注释，切换很麻烦

如果可以直接运行一个方法，就方便许多，并且可以给出相关信息

JUnit是一个Java语言的单元测试框架

多数 Java的开发环境都已经集成了JUnit作为单元测试的工具

在测试方法前面加上@Test ，按Alt+Enter，弹出提示框，选择Add JUnit5.4 to classpath

练习：

package li.generic.junit; import java.util.*; public class JUnit_ { public static void main(String[] args) { //这里给T指定的类型是User DAO<User> userDAO = new DAO<>(); userDAO.save("001", new User(1, 23, "Jack")); userDAO.save("002", new User(2, 32, "John")); userDAO.save("003", new User(3, 19, "King")); userDAO.save("004", new User(4, 55, "Poly")); System.out.println("====调用get方法===="); System.out.println(userDAO.get("004")); System.out.println(userDAO.get("002")); System.out.println("====调用update方法===="); User user = new User(2, 999, "孙悟空"); userDAO.update("002", user); System.out.println(userDAO.get("002")); System.out.println("====调用list方法===="); for (User user1:userDAO.list()) { System.out.println(user1); } System.out.println("====调用delete方法===="); userDAO.delete("001"); for (User user1:userDAO.list()) { System.out.println(user1); } } } class DAO<T> { private Map<String, T> map = new HashMap<>(); public void save(String id, T entity) {//保存T类型的对象到Map成员变量中 map.put(id, entity); } public T get(String id) {//从map中 获取id对应的对象 return map.get(id); } public void update(String id, T entity) {//替换map中key为id的内容，改为entity对象 map.put(id, entity); } //遍历map[K-V],将map的所有的values(即entity)封装到一个ArrayList中，再返回即可 public List<T> list() {//返回map中存放的所有T对象 List<T> list = new ArrayList<>(); Set<String> set = map.keySet(); for (Object key: set) { list.add(map.get(key));//也可以使用本类的get(String id)方法 } return list; } public void delete(String id) {//删除指定id对象 map.remove(id); } } 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 + \ + }; } }