1.举例:
【Order.java】
public class Order <T>{
private String orderName;
private int orderId;
//类的内部结构就可以使用类的泛型
private T orderT;
public Order(){
//编译不通过
// T[] arr = new T[5];
//编译通过
T[] arr = (T[])new Object[5];
}
public Order(String orderName,int orderId,T orderT){
this.orderId = orderId;
this.orderName = orderName;
this.orderT = orderT;
}
//如下的个方法都不是泛型方法
public void setOrderT(T orderT){
this.orderT = orderT;
}
public T getOrderT(){
return orderT;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + '\'' +
", orderId=" + orderId +
", orderT=" + orderT +
'}';
}
//静态方法中不能使用类的泛型。
// public static void show(T orderT){
// System.out.println(orderT);
// }
//不能在try-catch中使用泛型定义
// public void show(){
// //编译不通过
try{
} catch (T e) {
}
// }
//泛型方法:在方法中出现了泛型的结构,泛型参数与类的泛型参数没任何关系。
//换句话说,泛型方法所属的类是不是泛型类都没关系。
//泛型方法,可以声明为静态的。原因:泛型参数是在调用方法时确定的。并非在实例化类时确定。
public <E> List<E> copyformArrayToList(E[] arr){
// public static <E> List<E> copyformArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
【SubOrder.java】
public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类
public <E> List<E> copyformArrayToList(E[] arr){
// public static <E> List<E> copyformArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
【SubOrder1.java】
public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类
}
【测试】
@Test
public void test1(){
//如果定义了泛型类,实例化没指明类的泛型,则认为此泛型类型为Object类型
//要求:如果大家定义了类是带泛型的,建议在实例化时要指明类的泛型。
// Order order = new Order();
// order.setOrderT("ABC");
// order.setOrderT("123");
//建议:实例化时指明类的泛型
Order<String> order = new Order("PCY",1127,"xixi");
order.setOrderT("PARKCHANYEOL");
//编译不通过
// order.setOrderT(123);
System.out.println(order);//Order{orderName='PCY', orderId=1127, orderT=PARKCHANYEOL}
}
@Test
public void test2(){
SubOrder subOrder = new SubOrder();
//由于子类在继承带泛型的父类时,指明了泛型类型。则实例化子类对象时,不再需要指明泛型。
subOrder.setOrderT(123);
// subOrder.setOrderT("AA");编译不通过
//子类保留父类的泛型
SubOrder1<String> subOrder1 = new SubOrder1<>();
subOrder1.setOrderT("subOrder1...");
// 子类不保留父类的泛型,没类型 擦除
//编译都通过,相当于Object
SubOrder2 subOrder2 = new SubOrder2();
subOrder2.setOrderT("AA");
subOrder2.setOrderT(123);
}
@Test
public void test3(){
//泛型不同的引用不能相互赋值。
//尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型,但是,
// 在运行时只 一个ArrayList被加载到JVM中
ArrayList<String> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
ArrayList<Integer> list3 = new ArrayList<>();
list1 = list2;
// list1 = list3;
}
//测试泛型方法
@Test
public void test4(){
Order<String> order = new Order<>();
Integer[] arr = new Integer[]{1,2,3,4};
//泛型方法在调用时,指明泛型参数的类型。
List<Integer> list = order.copyformArrayToList(arr);
System.out.println(list);
}
2.注意点:
3.应用场景举例:
【DAO.java】:
* DAO:data(base) access object
*/
public class DAO<T> {//表的共性操作的DAO
//添加一条记录
public void add(T t){
}
//删除一条记录
public boolean remove(int index){
return false;
}
//修改一条记录
public void update(int index,T t){
}
//查询一条记录
public T getIndex(int index){
return null;
}
//查询多条记录
public List<T> getForList(int index){
return null;
}
//泛型方法
** 说明:**
* 1public 与 返回值中间<T>非常重要,可以理解为声明此方法为泛型方法。
* 2只声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
* 3<T>表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
* 4与泛型类的定义一样,此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型。
//举例:获取表中一共有多少条记录?获取最大的员工入职时间?
public <E> E getValue(){
return null;
}
}
【CustomerDAO.java】:
public class CustomerDAO extends DAO<Customer>{//只能操作某一个表的DAO
}
【StudentDAO.java】:
public class StudentDAO extends DAO<Student> {//只能操作某一个表的DAO
}