Java基础加强总结(3)(泛型)

 

一、泛型用于编译时

package day2;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
public class GenericTest {
	public static void main(String[] args) throws Exception{
		List<Integer> list = new ArrayList<Integer>();
		Method method = List.class.getMethod("add", Object.class);
		method.invoke(list, "111");
		System.out.println(list.get(0));
		
		List<String> list1 = new ArrayList<String>();
		method.invoke(list1, new Integer(111));
		System.out.println(list1.get(0));
	}
}

 泛型的参数化类型没有继承关系

Map<String,Integer> map = new HashMap<String,Integer>();
map.put("zxy", 44);
map.put("fda", 22);
map.put("ojkl", 33);
Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
for(Map.Entry<String,Integer> e : entrySet){
	System.out.println(e.getKey()+"  "+e.getValue());
}

自定义泛型返回值类型是参数类型的交集

可以限定T的上限下限可以继承

package day2;
public class TestDemo {
 public static void main(String[] args){
  int x = add(3,5);
  Number x1 = add(3.5,3);
  Object x2 = add(3,"abc");
 }
 private static <T> T add(T x,T y){
  return null;
 }
}
 

一个方法，自动将Object类型的对象转换成其他类型。

package day2;
public class TestDemo2 {
	public static void main(String[] args){
		String x3 = autoConvert("abc");
	}
	private static <T> T autoConvert(Object obj){
		return (T)obj;
	}
}

一个方法，可以将任意类型的数组中得所有元素填充为相应类型的某个对象。

package day2;
public class TestDemo2 {
	public static void main(String[] args){
		String[] array = new String[10];
		String str = "sff";
		arrayObject(array,str);
	}
	private static <T> void arrayObject(T[] array,T obj){
		for(int i=0;i<array.length;i++){
			array[i] = obj;
		}
	}
}

采用自定义泛型方法的方式打印出任意参数化类型的集合中的所有内容

public static <T> void printCollection(Collection<T> collection){
	for(T obj : collection){
		System.out.println(obj);
	}
} 

二、 定义泛型的类型

如果类的实例对象中得多处都要用到同一个泛型参数，即这些地方引用的泛型类型也要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：

public  class  GenericDao<T>{

    private T field1;

    public void save(T obj){}

    public void getById(int id){}

}

类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：

GenericDao<String> dao = null;

new GenericDao<String>();

需注意：

在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

当一个变量被声明为泛型时，只能被实例变量和方法调用（还有内嵌类型），而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。

如果一个类中多个方法需要使用泛型使用类级别的泛型。

通过方法获取参数的泛型类型

public static void main(String[] args) throws Exception{
	Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);
	Type[] types = applyMethod.getGenericExceptionTypes();
	ParameterizedType pType = (ParameterizedType)types[0];
	System.out.println(pType.getRawType());
}