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){}
,修饰符后面没有则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
分别创建以下方法:
- 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 + '\'' +
'}';
}
}