黑马程序员-泛型

泛型：安全机制。编译过后会被擦除。

 思考题不会报错。因为参数化类型可以和原始类型是兼容的。
好处：
1，将运行时期出现的ClassCastException，转移到了编译时期。方便与程序员解决问题。
2，避免强制转换。
泛型的使用：
格式：通过<>来定义要操作的引用数据类型。读作typeof
使用java提供的对象时，什么时候使用泛型呢？
通常集合常见，见到<>就需要定义泛型。

泛型类：当类中操作的引用数据类型不确定的时候。早期用Object扩展，现在用泛型。

class Utils<Q>{
     private Q q;
     public  void setObject(Q q){
        this.q=q;
   }
     public Q getObject(){
             return q;
   }
}

泛型方法：泛型类定义泛型，在整个类中有效。如果方法被使用，那么泛型类的对象明确要操作的具体类型后，所有的操作就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。（定义在返回值前）

class Demo{
    public   <T>void  show(T t){
   }
    public   <Q>void   print(Q q){
   }
}

泛型在方法上定义只在方法中有效。不同方法的泛型互不干扰。
泛型类和泛型方法不冲突。

class Demo<T>{
    public   void  show(T t){
   }
    public   <Q>void   print(Q q){
   }
}

静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。

泛型接口：
interface Inter<T>{
    void  show(T t);
}
class InterImpl<T> implements Inter<T>{
      public void show(T t){
       }
}
class InterImpl implements Inter<String>{
      public void show(String t){
       }
}

泛型的限定：
<?>通配符：只能调用对象中与参数化无关的方法。
<? extends E>  接收E和E的子类，上限。
<?  super   E>  接收E和E的父类，下限。

跳过泛型的检查：通过反射。
ArrayList<String>  al = new ArrayList<String>();
al.getClass().getMethod("add",Object.calss).invoke(al,5);
此时可以将5存入集合。

注意：只有引用类型才能作为泛型方法的实际参数，对于add方法，使用基本类型的数据测试文有问题，这是因为自动装箱和拆箱，下面swa(new int[ ]{1,2,3},1,2);会报告编译错误，因为编译器不会把基本数据类型的int自动拆箱和装箱。因为new int[ ]本身就已经是一个对象了。你想要的可能就是int数组呢？

public class Text {

	public static void main(String[] args) {
		int[] arr=new int[]{1,3,4,5};
		int n=5;
		String[] s = new String[]{"haha","hehe","heihei"};
		//交换数组中字符串的位置。
		swap(s,1,2);
		//swap(new int[]{1,2,3},3,5);编译错误
		for(String s1:s){
			System.out.println(s1);
		}
		swa(n);
		
	}
	public static  <T> void swap(T[] a,int i,int j){
		T tmp=a[i];
		a[i]=a[j];
		a[j]=tmp;
		
	}
	public static <T> void swa(T a){
		System.out.println(a);
	}

}

 异常中泛型的应用：

private static <T extends Exception> sayHello() throws T
{
    try{
  }
    catch(T e){
     throw <T>  e
   }
}

通过反射获得参数的实际类型参数：

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.Vector;

public class GenericTest {

	public static void main(String[] args)throws Exception {
		Vector<Date> v1=new Vector<Date>();
		Method applyMethod=GenericTest.class.getMethod("applyVector",Vector.class);
		Type[] types=applyMethod.getGenericParameterTypes();
		ParameterizedType pType=(ParameterizedType)types[0];
		System.out.println(pType.getRawType());//返回声明此类的原始类型的类或接口Vector
		System.out.println(pType.getActualTypeArguments()[0]);//返回此类型实际参数化的类型，可能有多个，比如map集合。Date

	}
	public static void applyVector(Vector<Date> v1){
		
	}
	/*public static void applyVector(Vector<String> v1){
		不是重载，去类型化。
	}
*/
}