泛型你真的了解吗
你需要掌握的：
- 基本用法
- 泛型擦除
- 泛型类/泛型方法/泛型接口
- 泛型关键字
- 反射泛型
和泛型的初次见面
泛型是JDK1.5以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化。很明显，使用Java泛型，我们可以省掉强制类型转换。编译器会保留参数的类型信息，执行类型检查，执行类型转换操作。因此开发人员不需要自己确保类型转换的安全性，而把这个交给编译器去做。
基本使用
public void testGeneric() throws Exception {
// 声明泛型集合的时候指定元素的类型
List<String> list = new ArrayList<String>();
list.add("China");
//list.add(1);// 编译时期报错
String str = list.get(1);
}
泛型擦除
泛型只在编译时期有效，编译后的字节码文件中无效，怎么理解呢，看demo:
//泛型擦除实例
public void save(List p){
}
public void save(List d){
// 报错： 与上面方法编译后一样
}
这并不是方法的重载，这直接会编译时报错。
泛型的几种写法
// 泛型写法
@Test
public void testGeneric2() throws Exception {
// 声明泛型集合，集合两端类型必须一致
List<Object> list = new ArrayList<Object>();
List<String> list1 = new ArrayList<String>();
List list2 = new ArrayList<String>();
List<Integer> list3 = new ArrayList();
// 错误
//List
// 错误： 泛型类型必须是引用类型,不能为基本类型
List<int> list5 = new ArrayList<int>();
}
泛型方法/泛型类/泛型接口
作用：设计公用的类、方法，对公用的业务实现进行抽取， 使程序更灵活。
- 泛型方法
public class GenericDemo {
// 定义泛型方法
public T save(T t,K k) {
return null;
}
// 测试方法
@Test
public void testMethod() throws Exception {
// 使用泛型方法: 在使用泛型方法的时候，确定泛型类型
save(1.0f, 1);
}
}
- 泛型类
public class GenericDemo {
// 定义泛型方法
public T save(T t,K k) {
return null;
}
public void update(T t) {
}
// 测试方法
@Test
public void testMethod() throws Exception {
// 泛型类： 在创建爱泛型类对象的时候，确定类型
GenericDemo demo = new GenericDemo();
demo.save("test", 1);
}
}
- 泛型接口
public interface IBaseDao<T> {
void save(T t );
void update(T t );
}
//泛型接口类型确定： 实现泛型接口的类也是抽象，那么类型在具体的实现中确定或创建泛型类的时候确定
public class BaseDao<T> implements IBaseDao<T>{
}
//泛型接口类型确定： 在业务实现类中直接确定接口的类型
public class StudentDao implements IBaseDao<Student>{
}
泛型关键字
泛型中：
? 指定只是接收值
extends 元素的类型必须继承自指定的类
super 元素的类型必须是指定的类的父类
- 关键字： ？
/** * 泛型, 涉及到一些关键字 * * Ctrl + shift + R 查看当前项目中类 * Ctrl + shift + T 查看源码jar包中的类 * */
public void save(List list){
// 只能获取、迭代list; 不能编辑list
}
@Test
public void testGeneric() throws Exception {
// ? 可以接收任何泛型集合， 但是不能编辑集合值； 所以一般在方法参数中用
List list = new ArrayList();
//list.add(""); //报错
} - 关键字：extends 【上限】
public void save(List extends Number> list) {
}
@Test
public void testGeneric() throws Exception {
List<Double> list1 = new ArrayList<Double>();
List<Float> list2 = new ArrayList<Float>();
List<Integer> list3 = new ArrayList<Integer>();
List<String> list4 = new ArrayList<String>();
//调用
save(list1);
save(list2);
save(list3);
//save(list4);
}- 关键字：super 【下限】
/** * super限定元素范围：必须是String父类 【下限】 * @param list */
public void save(Listsuper String> list) {
}
@Test
public void testGeneric() throws Exception {
// 调用上面方法，必须传入String的父类
List泛型的反射
案例，设置通用方法，会用到反射泛型。
步骤：
1. 案例分析 / 实现
2. 涉及知识点(jdk api)
3. 优化 / 反射泛型
案例：
demo数据库中有两张表：student,admin；
对应写两个实体类Student、Admin :
//Student实体类
public class Student {
private int sid;
private String name;
private String gender;
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
//Admin实体类
public class Admin {
private int id;
private String userName;
private String pwd;
@Override
public String toString() {
return "Admin{" +
"id=" + id +
", userName='" + userName + '\'' +
", pwd='" + pwd + '\'' +
'}';
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
//AdminDao.java
public class AdminDao extends BaseDao {
}
//StudentDao.java
public class StudentDaoextends BaseDao {
} 然后两个dao,都有一个findById(int id),与getAll（）方法，仅仅是对应的表名和返回值不同，于是抽象出一个公有的BaseDao。
//两个dao抽象出来的公有dao
public class BaseDao<T> {
//保存当前运行类的参数化类型中的实际类型
private Class clazz;
//表名
private String tableName;
//通过构造函数 1.获取当前类的参数化类型 2.获取参数化类型中实际类型的定义
public BaseDao(){
//获取当前运行类的父类，即Base]
ParameterizedType pt = (ParameterizedType) type;
//获取参数化类型中，实际类型的定义
Type types[] = pt.getActualTypeArguments();
//获取数据的第一个元素
clazz = (Class) types[0];
tableName = clazz.getSimpleName();
System.out.println("-------" + tableName);
}
/** * 主键查询 * @param id * @return */
public T findById(int id){
/** * 1.知道封装的对象的类型 * 2.所有的表名【与对象名称一样，且主键都为id】 */
String sql = "select * from " + tableName + " where id = ?";
try {
return JdbcUtils.getQueryRunner().query(sql, new BeanHandler(clazz), id);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
public List getAll( ){
/** * 1.知道封装的对象的类型 * 2.所有的表名【与对象名称一样，且主键都为id】 */
String sql = "select * from " + tableName;
try {
return JdbcUtils.getQueryRunner().query(sql, new BeanListHandler(clazz));
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
StudentDao、与AdminDao都继承自BaseDao，然后通过一个测试方法拿到数据库中的表。
@Test
public void test(){
AdminDao adminDao = new AdminDao();
Admin admin = adminDao.findById(2);
System.out.println(admin);
System.out.println("-->" + adminDao.getAll());
}
补充：
反射泛型涉及API：
ParameterizedType 参数化类型的表示
Type 接口，任何类型默认的接口！包括： 引用类型、原始类型、参数化类型
上面代码中用到的JdbcUtils是我封装的一个数据库操作类
public class JdbcUtils {
private static DataSource dataSource;
static {
dataSource = new ComboPooledDataSource();
}
public static DataSource getDataSource(){
return dataSource;
}
public static QueryRunner getQueryRunner(){
return new QueryRunner(dataSource);
}
}详细的可以看看我的上一篇文章。