创建泛型注解类
创建泛型注解类，GenericTest.java
改名，右键->Refactor->Rename
没泛型的时候，不管什么类型的对象，都可以存储进同一个集合中。使用泛型后，就可以将集合中的元素限定为一个特定的类型，集合中只能存储同一个类型的对象，这样更为安全；并且从集合中获取对象时，编译器也可以知道这个对象的类型，不需要进行强制类型转换。
在JDK1.5中，可以按原来的方式将各种不同类型数据装到一个集合中，但编译器会报告unchecked警告。这个警告也可以用@SuppressWarnings这个注解，让它不要报告
泛型是提供给javac编译器使用的，可以限定集合中输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。
Constructor<String> constructor1=String.class.getConstructor(StringBuffer.class);
String str2=(String)constructor1.newInstance(new StringBuffer("abc"));
//System.out.println(str2.charAt(2));
ArrayList<Integer> collection3=new ArrayList<Integer>();
System.out.println(collection3.getClass()==collection2.getClass());由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其他类型的数据。例如，用反射得到集合，再调用其add方法即可
ArrayList<Integer> collection3=new ArrayList<Integer>();
System.out.println(collection3.getClass()==collection2.getClass());
//collection3.add("abc");//编译器报错
collection3.getClass().getMethod("add", Object.class).invoke(collection3, "abc");
//getMethod("add", Object.class)方法是add，参数类型是对象，得到这个方法后，invoke相当于
//main的字节码，这对collection3这个对象，调用前面的方法，拿这个对象作用于
System.out.println(collection3.get(0));
整个成为ArrayList<E>泛型类型
ArrayList<E>中的E成为类型变量或类型参数
整个ArrayList<Integer>称为参数化的类型
ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
ArrayList<Integer>中的<>念做typeof
ArrayList称为原始类型
参数化类型与原始类型的兼容性
参数化类型可以引用一个原始类型的对象，编译报告警告
例如：Collection<String> c=new Vector();
原始类型可以引用一个参数化类型的对象，编译器报警告
例如：Collection c=new Vector<String>();
参数化类型不考虑类型的继承关系
Vector<String> v=new Vector<Object>();//错误！//不写<Object>没错，写了就是明知故犯
Vector<Object> v=new Vector<String>();//也错！
在创建数组实例时，数组元素不能使用参数化类型
Vector <Integer> vectorList[]=new Vector<Integer>[10];
Vector v1=new Vector<String>();
Vector<Object> v=v1;//编译器严格按照语法检查的一个工具，不考虑运行时的效果
泛型中的？通配符
public static void printCollection(Collection<?> collection){//(Collection<?> collection)错误
//collection.add(1);//不能调用，因为不知道传进来的是什么类型
System.out.println(collection.size());//size方法与类型无关
for(Object obj :collection){
System.out.println(obj);
} collection.size();
collection=new HashSet<Date>();
}限定上边界：
正确：Vector<? extends Number> x=new Vector<Integer>();
错误：Vector<? extends Number> x=new Vector<String>();
限定下边界：
正确：Vector<? super Integer> x=new Vector<Number>();
错误：Vector<? super Integer> x=new Vector<Byte>();//Integer和Byte同级
定义泛型方法
Java中的泛型类型（或者泛型）类似于c++中的模板。但是这种相似性仅限于表面，Java语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码，这种实现技术称为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型被认为是无法接受的，这回为Java厂商升级器JVM造成难以逾越的障碍。所以，java的泛型采用了完全在编译器中实现的擦除方法。
例子：
1、用java里面来定义一个类是c++模板的方法的泛型 add方法
add(3,5);
Number x1=add(3.5,3);
Object x3=add(3,"adg");private static <T> T add(T x,T y){
return null;
}2、交换数组元素中的两个方法
swap(new String[]{"abc","xyz","itcast"},1,2); private static <T> void swap(T[] a,int i,int j){
T tmp=a[i];
a[i]=a[j];
a[j]=tmp;
}规则
1、泛型的类型只能是对象类型、引用类型，不能是基本类型
2、用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和方法的返回类型之前，也就是金鳞返回值之前。按照惯例类型参数通常用单个大写字母表示
3、除了在应用泛型时可以使用extend限定符，在定义泛型时也可以使用extends限定符，例如Class.getAnnotation()。并且可以使用&来指定多个边界，如<V extends Serializable & cloneable> void method(){}
4、普通方法、构造方法和静态方法中都可以使用泛型。编译器不允许创建类型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型
例如：Vector<Integer> vectorList[]=new Vector<Integer>[10];//语句错误
5、也可以用类型变量表示异常，称为参数化异常，可以用于throws列表中，但是不能用于catch子句中。
6、在泛型中可以同时又多个参数类型参数，在定义他们的尖括号中用逗号分。
例1：将Object类型自动转换成其他类型
Object obj="abv";
String x3=autoConvert(obj); private static <T> T autoConvert(Object obj){
return (T)obj;
}例2：采用自定义泛型方法的方式打印出任意参数化类型的集合中的所有内容。
在这种情况下，通配符方案要比泛型方法更有效，当一个类型变量用来表达两个参数之间或者参数和返回值之间的关系时，即同一个类型变量在方法签名的两处被使用，或者类型变量在方法体代码中也被使用而不是仅在签名的时候使用，才需要使用泛型的方法
//打印任意类型的集合
public static <T> void printCollection2(Collection<T> collection,T obj2){
//collection.add(1);//不能调用，因为不知道传进来的是什么类型
System.out.println(collection.size());//size方法与类型无关
for(Object obj :collection){
System.out.println(obj);
}
collection.size();
collection.add(obj2);
//collection=new HashSet<Date>();
}
例3：集合到集合的拷贝，数组到数组的拷贝
//集合到集合的拷贝,传播去类型
public static <T> void copy1(Collection<T> dest,T[] src){
int i=0;
for(Object obj:src){
dest.add(src[i]);
i++;
}
}
//数组到数组的拷贝，类型是交集
public static <T> void copy2(T[] dest,T[] src){
for(int i=0;i<src.length;i++){
dest[i]=src[i];
}
} copy1(new Vector<String>(),new String[10]);
copy2(new Date[10],new String[10]);
copy1(new Vector<Date>(),new Date[10]);类型参数的类型推断：
根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下
1、当某个类型变量值在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定；即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型
例：
swap(new String[3],3,4)->static <E> void swap(E[] a,int i,int j)
2、当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定
add(3,5)->static <T> T add(T a,T b)
3、当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型
例：
fill(new Integer[3],3.5f)->static <T> void fill(T[] a,T v)
编译时没问题，运行时出问题
4、当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候优先考虑返回值的类型
例如，下面语句实际对应的类型是Integer，编译将报告错误，将变量x的类型改为float，对eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：
例：int x=(3,3.5f)->static <T> add(T a,T b)
5、参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：
copy(new Integer[5],new String[5])->static <T> void copy(T[] a,t[] b);
定义泛型类型
1、如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也是类级别泛型
格式：
import java.util.Set;
//dao的简写:date access object-->crud对数据库的增删改查，用crud简化描述对数据库的操作
//GenericDao类创建的对象用于数据进行访问的
public class GenericDao<E> {//定义到类上，让方法的类型有约束
public void add(E x){
}
public E findById(int id){
return null;
}
public void delete(E obj){
}
public void update(E obj){
}
public E findByUserName(String name){
return null;
}
public Set<E> findByConditions(String where){
return null;
}
}2、类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的。例如：
下面两种方式都可以：
GenericDao<ReflectPoint> dao=new GenericDao<ReflectPoint>();
dao.add(new ReflectPoint(3,3));
//String s=dao.findById(1);//返回的必须是ReflectPoint类型
注意：
a、在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型
b、当一个变量被声明为泛型时，只能被实例变量和方法调用（还有内嵌类型），而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。
可以这样写：
package cn.test.day2;
import java.util.Set;
//dao的简写:date access object-->crud对数据库的增删改查，用crud简化描述对数据库的操作
//GenericDao类创建的对象用于数据进行访问的
public class GenericDao<E> {//定义到类上，让方法的类型有约束
public void add(E x){
}
public E findById(int id){
return null;
}
public void delete(E obj){
}
public void update(E obj){
}
/* public static void update2(E obj){
//静态方法不能用泛型类型的
}*/
public static <E> void update2(E obj){
//静态方法可以这样定义，此处的E跟上边没关系
}
public E findByUserName(String name){
return null;
}
public Set<E> findByConditions(String where){
return null;
}
}
如果类中只有一个方法需要使用泛型，是使用类级别而不是方法级别的
通过反射获得泛型的参数化类型
JDK1.5的一个扩展方法，得到一个参数列表
每个参数不是以class返回，而是以泛型的class返回
package cn.test.day2;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import cn.test.day1.ReflectPoint;
public class GenericTest {
/**
* @param args
*/
public static void main(String[] args) throws Exception{
//通过反射获得泛型的参数化类型
Vector<Date> v1=new Vector<Date>();
//v1.getClass()//编译器编完了class里面去掉类型了
/*通过反射的方式，得到泛型里的数据类型
例如：想得到applyVector方法接受的参数的实际类型:Date*/
//要得到这个方法，先要找到字节码
//Vector.class表示参数类型
//class里没有包括类型参数
//获得参数的泛型类型.getGenericParameterTypes
//Type是Class的父类import java.lang.reflect.Type
//Type下面有各种子类，Class只是其中一个，还有一个参数化的类型ParameterizedType
//得到自己的实际类型的参数getActualTypeArguments，实际化类型参数可能有多个,是一个数组
//得到自己的原始类型getRawType,原始的类型是一个class
Method applyMethod=GenericTest.class.getMethod("applyVector", Vector.class);
Type[] types=applyMethod.getGenericParameterTypes();//可能有多个，所以是一个数组
ParameterizedType pType=(ParameterizedType)types[0];
System.out.println(pType.getRawType());//class java.util.Vector
System.out.println(pType.getActualTypeArguments()[0]);
}
public static void applyVector(Vector<Date> v1){//无法通过v1来知道前边变量的类型，
//但是可以通过方法applyVector的方法，以泛型的形式来知道参数列表的类型
}
}
570
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
