2、泛型的使用
2.1、什么是泛型
什么是泛型?泛型按照字面意思来理解 就是 广泛的数据类型 ....所谓的泛型 其实就是一种数据类型 这个数据类型究竟是什么？不确定 这个数据类型的确定是在程序的运行过程中简单的说 就是这个数据类型的确定的时机不一致我们以前学习的数据类型都是在编写代码的时候 直接申明的 int float ... double....现在这个数据类型是在程序运行时候 动态的确定的...
2.2、泛型的在方法中的使用
重点：方法中的泛型 是在调用这个方法的时候 去确定的这个数据类型
public class Test001 {
public static void main(String[] args) {Object[] objects = test006(String.class);objects[0]=123;System.out.println("数组的长度是:"+objects.length);}
/*** @param t* @param <T> ：定义了一个数据类型 这个数据类型是什么并不确定* 注意事项：这个泛型的定义不一定用T 来定义 可以使用任何的名字来进行定义* 一般泛型的定义使用* T ：type类型* E：Element节点* K,V :键值对* @return*/public static <T> T test001(T t) {System.out.println("T:" + t);return t;}
public static <T, B> T test002(T t, B b) {System.out.println("T:" + t + "---B:" + b);return t;}
public static <T> T[][] test003(T[]... t) {return t;}
public static <T> T test004(String str) {System.out.println("str:"+str);return (T) str;}
public static <T> T test005(String str) {//能不能在这里确定这个数据类型是啥呢?T t= (T) "中国好";return t;}
public static <T> T[] test006(Class<String> clazz) {//能不能使用这个T 创建一个泛型的数组呢?//给人一种感觉 就是只要知道这个数据类型就可以创建数组?T[] tArray = (T[]) Array.newInstance(clazz, 10);return tArray;}
}
2.3、泛型在类中的使用
类中泛型是在 new这个类的对象的时候 确定这个数据类型是啥
2.3.1、编写R类
// @description: 这个类是我们的结果集的统一返回类@Data //只要getter和setter方法
public class R<T> {private Integer code; //状态码 0：成功 非0：失败private String message; //请求失败之后的提示信息private T t;
}
2.3.2、编写枚举类
public enum ResponseCode {SUCCESS(0, "请求成功"),FAIL(-1, "请求失败");
private Integer code;private String message;
ResponseCode(Integer code, String message) {this.code = code;this.message = message;}
public Integer getCode() {return code;}
public void setCode(Integer code) {this.code = code;}
public String getMessage() {return message;}
public void setMessage(String message) {this.message = message;}
}
2.3.3、编写测试类
public class TestTypeType {
public static void main(String[] args){//类中的泛型是在这个类 初始化的时候 去确定数据类型 简单的说 就是new的时候//注意事项：就是泛型只能使用包装类型
R<String> r = new R<>();r.setCode(ResponseCode.SUCCESS.getCode());r.setMessage(ResponseCode.SUCCESS.getMessage());r.setMessage("中国人民万岁...");//这个R对象于是就设置成功了...
System.out.println("R:"+r);
}
}
2.4、泛型在接口中的使用
2.4.1、泛型在接口中的使用1
2.4.1.1、编写接口
public interface UserDAO<T> {/*** 打印的这个方法* @param t*/T print(T t);
}
2.4.1.2、编写接口的实现类
public class UserDAOImpl implements UserDAO<User>{@Overridepublic User print(User user) {System.out.println("user:"+user);return user;}
}
2.4.1.3、编写测试类
public class TestInterfaceType {public static void main(String[] args) {//多态UserDAO userDAO = new UserDAOImpl();Object result = userDAO.print(new User(1, "小波波", "123"));System.out.println("返回的数据是:" + result);}
}
2.4.2、数据类型前移的问题
2.4.2.1、编写接口
public interface UserDAO<T> {/*** 打印的这个方法* @param t*/T print(T t);
}
2.4.2.2、编写接口的实现类
public class UserDAOImpl<T> implements UserDAO<T> {
@Overridepublic T print(T t) {System.out.println("传递过来的T的值是:"+t);return t;}
}
2.4.2.3、编写测试类
public static void main(String[] args) {/*** 判断一个程序的好坏 有如下原则* 开里依 单迪离* 开：开闭原则** 里：里氏替换原则*** 依：依赖倒置* 单：单一职责* 迪：迪米特法则* 离：接口隔离*/UserDAO userDAO=new UserDAOImpl<User>();Object print = userDAO.print(new User(2, "中国好", "哈哈哈"));System.out.println("结果是:"+print);}
2.5、泛型的向上和向下转型的问题(泛型的不确定性的问题)
2.5.1、向下转型的问题
public class TestConvert1 {
public static void main(String[] args) {UserService userService = new UserService<>();print2(userService);}
/*** 向上和向下转型实际上是为了限制这个输入参数的问题* 保证这个输入参数在某一个范围内?*/
/*** 下面这个表示的是传递的是List的孩子* @param userService*/public static void print(UserService<? extends Number> userService){
}
/*** 这里就表示的是传递的参数 必须是 List或者 List的爹* @param userService*/public static void print1(UserService<? super Number> userService){
}
/*** 下面的? 就表示的是传递啥子都可以* @param userService*/public static void print2(UserService<?> userService){
}
}
