什么是泛型

什么是泛型为什么要使用泛型

泛型就是参数化类型

泛型的作用

减少重复代码

像dao接口中存在样式雷同的代码：
EmpDao：
package com.aaa.gen.dao;
import com.aaa.gen.entity.Emp;
import java.util.List;
/**
* 员工管理dao接口
DetpDao：
*/
public interface EmpDao {
/**
* 查询所有的员工信息
* @return
*/
public List listAll();
/**
* 保存员工信息
* @param emp
* @return
*/
public int save(Emp emp);
/**
* 删除员工信息
* @param emp
* @return
*/
public int delete(Emp emp);
/**
* 修改员工信息
* @param emp
* @return
*/
public int update(Emp emp);
/**
* 根据主键查询 员工的信息
* @param id
* @return
*/
public Emp find(Long id);
}
package com.aaa.gen.dao;
import com.aaa.gen.entity.Dept;
import java.util.List;
/**
* 部门管理dao接口
*/
public interface DeptDao {
/**
有这么 多重复代码，肯定是不好的，我们应该使用一种范式提取出来。我们可以定义一个公共的BaseDao接口来
解决这种问题:
* 查询所有的部门信息
* @return
*/
public List listAll();
/**
* 保存部门信息
* @param dept
* @return
*/
public int save(Dept dept);
/**
* 删除部门信息
* @param dept
* @return
*/
public int delete(Dept dept);
/**
* 修改部门信息
* @param dept
* @return
*/
public int update(Dept dept);
/**
* 根据主键查询 部门的信息
* @param id
* @return
*/
public Dept find(Long id);
}
package com.aaa.gen.common;
import com.aaa.gen.entity.Dept;
import java.util.List;
public interface BaseDao {
/**
* 查询所有的实体信息
* @return
*/
public List listAll();
然后针对某个特定多的接口比如EmpDao，我们可以让EmpDao继承BaseDao接口，同时指定泛型的类型:
帮助我们提前发现一些程序的错误
/**
* 保存实体信息
* @param t
* @return
*/
public int save(T t);
/**
* 删除实体信息
* @param t
* @return
*/
public int delete(T t);
/**
* 修改实体信息
* @param t
* @return
*/
public int update(T t);
/**
* 根据主键查询 实体的信息
* @param id
* @return
*/
public T find(Long id);
}
package com.aaa.gen.dao;
import com.aaa.gen.common.BaseDao;
import com.aaa.gen.entity.Emp;
import java.util.List;
/**
* 员工管理dao接口
*/
public interface EmpDao extends BaseDao {
}

帮助我们提前发现一些程序的错误
package com.aaa.gen.test;
import java.util.ArrayList;
import java.util.List;定义泛型接口或者类
定义泛型接口
泛型接口在被实现的时候，如果实现类不再需要泛型，则需要指定泛型的具体类型：
/**
* 测试泛型
*/
public class Test01 {
/**
* 打印list中所有的内容
*/
public static void printList(List list){
for(int i=0;i){
String str = list.get(i);
System.out.println(str);
}
}
public static void main(String[] args) {
List list = new ArrayList();
list.add("Java");
list.add("C#");
list.add("python");
list.add(123);
Test01.printList(list);
}
}
package com.aaa.gen;
/**
* 定义泛型接口list
* 在接口后面使用<>表示，在<>可以定义泛型的形参，一般形参都使用单独的一个大写字母来表示
* 多个发型的形参用逗号进行间隔 经常用的泛型的标识有T E
*
*/
public interface List {
/**
* 迭代元素
* @param t
*/
public void iterator(T t);
}如果实现类继续使用泛型，则可以不指定泛型的具体类型：
定义泛型类
package com.aaa.gen;
/**
* 如果实现类中不再使用泛型，则需要指定泛型的具体类型
*/
public class ArrayList implements List {
@Override
public void iterator(String s) {
}
}
package com.aaa.gen;
/**
* 实现类中如果继续使用泛型 ，则不必指定泛型的具体类型
* @param 
*/
public class LinkedList implements List{
@Override
public void iterator(T t) {
}
}
package com.aaa.gen;
/**
* 泛型类
*/
public class Apple {
//声明泛型变量info
private T info;
public T getInfo() {
return info;
}
public void setInfo(T info) {
this.info = info;
}
}在使用的时候：
泛型通配符
需求：定义一个类，类中需要有打印一个字符串集合中的所有元素的方法，还需要有打印一个整数集合中的所有元
素的方法
package com.aaa.gen.test;
import com.aaa.gen.Apple;
/**
* 测试泛型类
*/
public class Test02 {
public static void main(String[] args) {
Apple apple= new Apple()apple.setInfo("红色");
System.out.println(apple.getInfo());
Apple apple2= new Apple();
apple2.setInfo(10);
System.out.println(apple2.getInfo());
}
}
package com.aaa.gen.test;
import java.util.List;
public class Test03 {
/**
* 打印字符串集合中的所有的元素
* @param list
*/
public void printStr(List list){
for(String str : list){
System.out.println(str);
}
}
/**
* 打印整数集合中的所有的元素
* @param list
*/
public void printInt(List list){
for(Integer num :list){
System.out.println(num);
}
}我们发现所有打印的方法的代码结构上都是类似的，打印每种类型的变量的集合都需要再定义一个方法，这样做非
常麻烦，有没有一个通用的方法可以解决这个问题？
我们通过泛型通配符来解决这个问题，java提供一个方案，List 不是所有List<其他类型>的父类，但是List<?>可以
理解为所有List<其他类型>的父类：
/**
* 打印小数集合中的所有的元素
* @param list
*/
public void printDouble(List list){
for(Double num :list){
System.out.println(num);
}
}
}
package com.aaa.gen.test;
import java.util.ArrayList;
import java.util.List;
/**
* 使用List