一、自定义泛型类（接口）
@[toc]
ps：泛型类和泛型接口的区别就是类和接口的区别，这里不做阐述
1、基础知识
- 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>
- 泛型类的构造器如下：public GenericClass(){}。 而下面是错误的：public GenericClass(){}
- 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致
- 泛型不同的引用不能相互赋值。(见下面代码举例部分的第四点测试类的)
- 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价 于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
- 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
- jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
- 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
- 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。（看下面代码举例第一点自定义泛型类Order注释部分）(原因：泛型在创建对象的时候才指定，但是静态方法要早于创建对象，所以静态方法中不能使用类的泛型)
异常类不能是泛型的
public class Test11<T> extends Exception{}//错误的不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];
参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
举例：
T[] t = new T[];//错误的 T[] t = (T[]) new Object[10];//而且后续用的时候赋值的时候new的只能是T或者T的子类的对象，不然会报错.父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
子类不保留父类的泛型：按需实现
- 没有类型 擦除
- 具体类型
子类保留父类的泛型：泛型子类
- 全部保留
- 部分保留
代码举例：
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}2、代码举例
自定义泛型类Order
package com.jsm.java1; //自定义泛型类 public class Order<T> { String orderName; int orderId; //类的内部结构就可以使用类的泛型 T orderT; public Order(){ } public Order(String orderName, int orderId, T orderT) { this.orderName = orderName; this.orderId = orderId; this.orderT = orderT; } public T getOrderT() { return orderT; } public void setOrderT(T orderT) { this.orderT = orderT; } @Override public String toString() { return "Order{" + "orderName='" + orderName + '\'' + ", orderId=" + orderId + ", orderT=" + orderT + '}'; } //静态方法中不能使用类的泛型。 /* public static void show(T orderT){ System.out.println(T orderT); } */ }继承泛型类Order并且指明了泛型为Integer（SubOrder不再是泛型类）
public class SubOrder extends Order<Integer> { }继承泛型类Order但是仍然保留了”T”（SubOrder1仍然是泛型类）
public class SubOrder1<T> extends Order<T> { }测试：OrderTest
package com.jsm.java1; import org.junit.Test; public class OrderTest { @Test public void test1(){ //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object //要求：如果定义了类是带泛型的，建议在实例化时候要指明类的泛型 Order<Object> order = new Order<>(); order.setOrderT(123); order.setOrderT("ABC"); //建议：实例化时候指明类的泛型 Order<String> order1 = new Order<String>("orderAA",1001,"F"); order1.setOrderT("AA:hello"); SubOrder sub1 = new SubOrder(); //由于子类在继承带父类的泛型时，指明了泛型类型，则实例化子类对象时，不再需要指明泛型 sub1.setOrderT(1234); SubOrder1<Integer> sb1 = new SubOrder1<Integer>(); sb1.setOrderT(1234); @Test public void test2(){ //泛型不同的引用不能相互赋值 ArrayList<String> list1= new ArrayList<String>(); ArrayList<Integer> list2= new ArrayList<Integer>(); //list1=list2; //尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有 //一个ArrayList被加载到JVM中。 } } }
二、自定义泛型方法
1、基础知识
- 在方法中出现了泛型结构、泛型参数与类的泛型参数没有任何关系，换句话说，是不是泛型方法，和泛型方法所属的类是不是泛型类没有任何关系
- 举例代码中方法这里的E是调用方法的时候确定的，并非实例化类的时候确定，所以和类的泛型没关系，所以泛型方法可以是静态的
- 泛型方法的格式：
[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
2、代码举例
//学习内容：
//开发时间:10月16日 0:13
package com.jsm.java2;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
public class MethodTest {
//测试泛型方法
@Test
public void test11(){
Integer[] arr=new Integer[]{1,2,3,4};
//泛型方法在调用时，指明泛型参数的类型，这个类型和类的泛型没有任何关系
List<Integer> list = copyFromArrayToList(arr);
System.out.println(list);//[1, 2, 3, 4]
}
//泛型方法
public <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list=new ArrayList<>();
for (E e:arr){
list.add(e);
}
return list;
}
//说明：这个方法这里的E是调用方法的时候确定的，并非实例化类的时候确定，所以和类的泛型没关系，所以泛型方法可以是静态的
}