定义泛型类与泛型方法
实例代码如下：
public class Order<T> {
private String orderName;
private int orderId;
private T t;
List<T> list = new ArrayList<T>();
public void add(){
list.add(t);
}
/*下面这个泛型方法表示只能只用实例化泛型类时的类型*/
public T getT(){
return t;
}
public void setT(T t){
this.t = t;
}
//不可以在static方法中使用泛型的声明
// public static void show(){
// System.out.println(t);
// }
public void info(){
//不可以在try-catch中使用类的泛型的声明
// try{
//
// }catch(T e){
//
// }
}
/*如下泛型方法表示类型T可以与类的类型不一致，可以自定义*/
//声明泛型方法
public static <T> T getE(T e){
return e;
}
//声明泛型方法，返回为String类型
public <T> T getE(String j,Double i){
return (T) (i+j);
}
//return i 返回为Double类型;return j 返回Integer类型
public <T> T getE(Integer j,Double i){
return (T) j;
}
//返回为S类型
public <T,S extends T> T getE(T j,S i){
return i;
}
/*如上泛型方法表示类型T可以与类的类型不一致，可以自定义*/
//实现数组到集合的复制
public <E> List<E> fromArrayToList(E[] e,List<E> list){
for(E e1 : e){
list.add(e1);
}
return list;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
@Override
public String toString() {
return "Order [orderName=" + orderName + ", orderId=" + orderId
+ ", t=" + t + "]";
}
//继承泛型类或泛型接口时，可以指明泛型的类型
class SubOrder extends Order<Integer>{
}tips-1：
这里说明一下public static <T> T getE(T e) 与public T getE(T e) 区别。
首先，该类是一个泛型类，若使用第二种形式，表明 T为实例化类时的T，不能添加额外元素属性；
若使用第一种形式(泛型方法)，则表明可以添加与类<T> 不同的属性元素；
//声明泛型方法
public static <T> T getE(T e){
return e;
}测试代码如下：
Order<Boolean> order = new Order<Boolean>();
//实例化order<Boolean>
//当通过对象调泛型方法时，指明泛型方法的类型。
//第二种方法
Boolean i = order.getE(true);
//第一种方法
Integer i = order.getE(123);test for all：
@Test
public void test4(){
//1.当实例化泛型类的对象时，指明泛型的类型。
//指明以后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
//2.如果我们自定义了泛型类，但是在实例化时没有使用，
//那么默认类型是Object类的
Order<Boolean> order = new Order<Boolean>();
// order.getT();
order.setT(true);
System.out.println(order.getT());
//把t添加进list
order.add();
List<Boolean> list = order.list;
System.out.println(list);
//SubOrder extends Order<Integer>
SubOrder o = new SubOrder();
List<Integer> list1 = o.list;
System.out.println(list1);
//当通过对象调泛型方法时，指明泛型方法的类型。
Integer i = order.getE(123);
Object d = order.getE((Object)3,2);
System.out.println(order.getE(1,1.23).getClass());
Object e = order.getE(1,1.23);
System.out.println(i+","+d+"****"+e+"**");
Integer[] in = new Integer[]{1,2,3};
List<Integer> list2 = new ArrayList<Integer>();
List<Integer> list3 = order.fromArrayToList(in, list2);
System.out.println(list3);
}result as follows :
true
[true]
[]
class java.lang.Integer
123,2****1**
[1, 2, 3]
