泛型

package hanshi.net;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.util.*;

public class annotation {
	public static void main (String[] args)throws Exception{
		ArrayList<String> al = new ArrayList<String>();
		al.add("add");
		al.add("dfa");
		print(al.get(1));
		//Constructor cs = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
				//第一种不能泛型               第二种可以泛型
		//Constructor<String> cs = String.class.getConstructor(StringBuffer.class);
		//String str = cs.newInstance(new StringBuffer("abc"));
		       //第一种和第二种前后是一样的，只不过是参数问题不同而已
		Constructor<String> cs = String.class.getConstructor(String.class);
		String str = cs.newInstance("abc");
		print(str);
		print(str.charAt(1));
		ArrayList<Integer> ai = new ArrayList<Integer>();
		ai.add(1);
		ai.add(2);
		print(ai.get(1));
		print(al.getClass() == ai.getClass());   //true   所以javac之后就脱去泛型
		ai.getClass().getMethod("add", Object.class).invoke(ai, "asd"); //反射   后去方法进行实例化
		print(ai);    //[1, 2, asd]    没有泛型限制了   在整形后面可以添加字符串类型的数据
		
		
		//ArrayList<Integer> arr[] = new ArrayList<Integet>[10];
		//这种定义方法是绝对错误的，不允许对泛型的集合类型进行数据操作
		
		/*int i1 = add(3,5);
		Number i2 = add(3,3.5);
		 Object i3 = add(3,"abc");*/
		 //如果两个参数的数据定义模板是一样的，而实际上传递进来的参数类型又是不一样的
		 //那么在使用的过程中就是对两个参数取交集
		 
		 
		 //泛型不能用于基本数据类型，第二个的操作是错误的
		 swap(new String[]{"sfa","fdg","geg"},1,2);
		// swap(new int[]{1,2,3,4,5},1,2);
		 //像add的3,5两个参数就不一样，因为没有歧义性，所以就会自动直接进行拆箱和装箱。。。
		 
		 
		 
		 //定义一个自动强制类型转化的方法。。。    注意它的强制类型转换的过程，很奇妙
		 Object obj = "adg";
		 String strr = change(obj);
		 print(strr);
	}
	public static <T> T change(Object obj){
		return (T)obj;  //返回值的泛型类型是由接受的类型所决定的。。。
	}
	public static <T> void  swap(T[] a,int i,int j){
		T t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
	public static <T> T add(T a,T b){
		return null;
	}
	public static void print(Object obj){
		System.out.println(obj);
	}

}

转载于:https://my.oschina.net/u/2356176/blog/423979