泛型,即“参数化类型”。就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。
例如:GenericClass<T>{}
一些常用的泛型类型变量:
E:元素(Element),多用于java集合框架
K:关键字(Key)
N:数字(Number)
T:类型(Type)
V:值(Value)
1 泛型类的说明
import java.util.Objects;
/**
* 自定义泛型类
*/
public class Order<T> {
private int orderId;
private String orderName;
private T[] arr;
private T orderT;
public Order(){
// arr = new T[12];//错误的
arr = (T[]) new Object[12];//正确的
}
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public T getOrderT() {
return orderT;
}
public void setOrderT(T orderT) {
this.orderT = orderT;
}
@Override
public String toString() {
return "Order{" +
"orderId=" + orderId +
", orderName='" + orderName + '\'' +
", orderT=" + orderT +
'}';
}
public Order(int orderId,T orderT){
this.orderId = orderId;
this.orderT = orderT;
}
//静态方法中不能使用类的泛型。
// public static void show(){
// System.out.println("orderT : " + orderT);
// }
}
/**
* 如果继承时,没有父类的泛型参数的类型,则默认此类型为Object。
* 此中写法不规范,不建议
*/
public class SubOrder extends Order {
}
/**
* 继承泛型类时,可以指明泛型参数的类型。
*/
public class SubOrder1 extends Order<String> { //SubOrder1:不是一个泛型类!
}
public class SubOrder2<T> extends Order<T> {//SubOrder2:仍然是一个泛型类!
}
public class GenericTest {
/*
1. 创建自定义的泛型类对象时,如果没有使用类的泛型,则默认泛型参数的类型为:Object
2. 泛型参数,只能使用引用类型来充当。不能使用基本数据类型
3. 创建泛型类对象时,一旦指明了泛型参数的类型,则在泛型类中,凡是使用类的泛型的位置,都替换为指定的泛型参数的类型。
4. 指明类的泛型参数的场景:① 创建泛型类的对象时 ② 子类继承泛型类时,可以指明泛型参数的类型。
*/
@Test
public void test1() {
Order o1 = new Order();
Object orderT = o1.getOrderT();
ArrayList list = new ArrayList();
list.add(123);
list.add("ABC");
Order<Integer> order = new Order<>();
Integer orderT1 = order.getOrderT();
Order<String> order1 = new Order<>(12, "AA");
}
@Test
public void test2() {
SubOrder o1 = new SubOrder();
Object orderT = o1.getOrderT();
SubOrder1 o2 = new SubOrder1();
String orderT1 = o2.getOrderT();
SubOrder2<Double> o3 = new SubOrder2<>();
Double orderT2 = o3.getOrderT();
}
@Test
public void test3(){
ArrayList list1 = new ArrayList();
ArrayList list2 = list1;
ArrayList<Integer> list3 = new ArrayList<>();
//泛型不同的引用不能相互赋值。
// ArrayList<String> list4 = list3;
}
}
补充说明:
1.泛型类可能有多个参数,此时应将多个参数一起放在尖括号内。比如:<E1,E2,E3>
2. 泛型类的构造器如下:public GenericClass(){}。
而下面是错误的:public GenericClass<E>(){}
3. 实例化后,操作原来泛型位置的结构必须与指定的泛型类型一致。
4. 泛型不同的引用不能相互赋值。
>尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型,但是,在运行时只有一个ArrayList被加载到JVM中。
5. 泛型如果不指定,将被擦除,泛型对应的类型均按照Object处理,但不等价于Object。经验:泛型要使用一路都用。要不用,一路都不要用。
6. 如果泛型结构是一个接口或抽象类,则不可创建泛型类的对象。
7. jdk1.7,泛型的简化操作:ArrayList<Fruit> flist = new ArrayList<>();
8. 泛型的指定中不能使用基本数据类型,可以使用包装类替换。
9. 在类/接口上声明的泛型,在本类或本接口中即代表某种类型,可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
10. 异常类不能是泛型的
11. 不能使用new E[]。但是可以:E[] elements = (E[])new Object[capacity];
参考:ArrayList源码中声明:Object[] elementData,而非泛型参数类型数组。
12.父类有泛型,子类可以选择保留泛型也可以选择指定泛型类型:
子类不保留父类的泛型:按需实现
没有类型 擦除
具体类型
子类保留父类的泛型:泛型子类
全部保留
部分保留
结论:子类必须是“富二代”,子类除了指定或保留父类的泛型,还可以增加自己的泛型
2 泛型方法的说明
public class SubOrder1 extends Order<String> { //SubOrder1:不是一个泛型类!
public <E> List<E> copyArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
public class Order<T> {
//...
//泛型方法
public <E> List<E> copyArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
//泛型方法的测试
//1. 泛型方法所属的类可以是泛型类,也可以不是泛型类
//2. 当调用泛型方法时,指明泛型方法中的泛型参数的类型
//3. 泛型方法可以声明为静态的
@Test
public void test4(){
Order<String> order = new Order<>();//此时类的泛型是:String
Integer[] arr = new Integer[]{1,2,3};
List<Integer> list = order.copyArrayToList(arr);//泛型方法的参数是:Integer
}
3 应用举例
import java.util.List;
/**
* DAO: data(base) access object
* 封装了对数据库中表的CRUD操作
*/
public class DAO<T> {
//增
public void add(T instance){
}
//删
public void remove(int id){
}
//改
public void update(int id,T newInstance){
}
//查:一条记录
public T getInstance(){
return null;
}
//查:多条记录
public List<T> getForList(String sql){
return null;
}
//泛型方法
// 可能会查询表的条目数;最大的生日;最多的工资数
public <E> E getValue(String sql){
return null;
}
}
import java.sql.Date;
public class Customer {
private int id;
private String name;
private String email;
private Date birth;
//。。。
}
public class CustomerDAO extends DAO<Customer> {
}
public class Student {
}
public class StudentDAO extends DAO<Student> {
}
测试:
public class DAOTest {
public static void main(String[] args) {
CustomerDAO dao = new CustomerDAO();
dao.getForList("select id,name,email,birth from custoemrs where id < 10");
StudentDAO dao1 = new StudentDAO();
Student student = dao1.getInstance();
}
}
四、泛型在继承上的体现
4.1 情况1
/*
1. 类A是类B的父类,但是 G<A> 与 G<B>没有继承关系。
*/
@Test
public void test1() {
Object obj = null;
String str = null;
obj = str;//多态
Object[] arr = null;
String[] arr1 = null;
arr = arr1;//多态
//*************************
ArrayList<Object> list1 = null;
ArrayList<String> list2 = new ArrayList<>();
//编译不通过
// list1 = list2;
/*
反证法:
假设:list1 = list2;
list1.add(123);非法的。
*/
method(list1);
method1(list2);
}
public void method(ArrayList<Object> list) {
}
public void method1(ArrayList<String> list) {
}
4.2 情况2
/*
2. 类A是类B的父类或接口,A<G> 是 B<G>的父类,可以向上转型(多态)
*/
@Test
public void test2() {
List<String> list1 = null;
ArrayList<String> list2 = new ArrayList<>();
list1 = list2;
method2(list2);
}
public void method2(List<String> list){
}