一、内省--了解JavaBean（java.beans ）
概述：
1、IntroSpector：即内省，是对内部进行检查，了解更多的底层细节。
2、内省的作用：主要针对JavaBean进行操作。
JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。
如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问，大家觉得这些方法的名称叫什么好呢？JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。如果方法名为setId，中文意思即为设置id，至于你把它存到哪个变量上，用管吗？如果方法名为getId，中文意思即为获取id，至于你从哪个变量上取，用管吗？去掉set前缀，剩余部分就是属性名，如果剩余部分的第二个字母是小写的，则把剩余部分的首字母改成小的。
setId()的属性名 id
isLast()的属性名 last
setCPU的属性名是什么? CPU
getUPS的属性名是什么？ UPS
总之，一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量。
一个符合JavaBean特点的类可以当作普通类一样进行使用，但把它当JavaBean用肯定需要带来一些额外的好处，我们才会去了解和应用JavaBean！
好处如下：
1、在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作，别人都这么用和要求这么做，那你就没什么挑选的余地！
2、JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。
开场：内省对应的英文单词为IntroSpector，它主要用于对JavaBean进行操作，JavaBean是一种特殊的Java类，其中的某些方法符合某种命名规则，如果一个Java类中的一些方法符合某种命名规则，则可以把它当作JavaBean来使用。请问：一个JavaBean可以当做普通Java类来使用吗？一个普通Java类可以当做JavaBean来使用吗？
java.beans BeanDescriptor
java.beans.Introspector
java.beans BeanInfo
java.beans.PropertyDescriptor
- package javaBean.cn.itcast;
- import java.beans.BeanInfo;
- import java.beans.IntrospectionException;
- import java.beans.Introspector;
- import java.beans.PropertyDescriptor;
- import java.lang.reflect.InvocationTargetException;
- import java.lang.reflect.Method;
- import org.apache.commons.beanutils.BeanUtils;
- public class BeansTest {
- /**
- * @param args
- * @throws Exception
- */
- public static void main(String[] args) throws Exception {
- // TODO Auto-generated method stub
- Person p = new Person();
- p.setName("董方宇");
- String propertiesName = "name";
- String name = extracted(p, propertiesName);//演示了用eclipse抽取方法
- System.out.println(name);
- String propertiesAge = "age";
- int age = 23;
- SetAge(p, propertiesAge, age);
- String name1 = BeanUtils.getProperty(p, "name");//使用beanUtils工具包进行获取和设置属性（尽管这些属性是私有的，可是有方法啊，是不是很方便）
- System.out.println(BeanUtils.getProperty(p, "name").getClass().getName());
- System.out.println(name1);
- BeanUtils.setProperty(p, "age", 19);
- System.out.println(p.getAge());
- /*打印结果
- * 董方宇
- 23
- java.lang.String
- 董方宇
- 19*/
- }
- private static void SetAge(Person p, String propertiesAge, int age)
- throws IntrospectionException, IllegalAccessException,
- InvocationTargetException {
- PropertyDescriptor bp1 = new PropertyDescriptor(propertiesAge, p.getClass());
- Method methodSetAge = bp1.getWriteMethod();
- methodSetAge.invoke(p,age);
- System.out.println(p.getAge());
- }
- private static String extracted(Object p, String propertiesName)
- throws IntrospectionException, IllegalAccessException,
- InvocationTargetException {
- /*PropertyDescriptor bp = new PropertyDescriptor(propertiesName, p.getClass());
- Method methodGetName = bp.getReadMethod();
- Object readVal = methodGetName.invoke(p);
- System.out.println(readVal);*/
- BeanInfo beanInfo = Introspector.getBeanInfo(p.getClass());
- PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
- Object retVal = null;
- for(PropertyDescriptor pd : pds){
- if(pd.getName().equals(propertiesName))
- {
- Method methodGetX = pd.getReadMethod();
- retVal = (String)methodGetX.invoke(p);
- break;
- }
- }
- return (String) retVal;
- }
- }
Beanutils工具包
演示用eclipse如何加入jar包，先只是引入beanutils包，等程序运行出错后再引入logging包。
在前面内省例子的基础上，用BeanUtils类先get原来设置好的属性，再将其set为一个新值。
get属性时返回的结果为字符串，set属性时可以接受任意类型的对象，通常使用字符串。
用PropertyUtils类先get原来设置好的属性，再将其set为一个新值。
get属性时返回的结果为该属性本来的类型，set属性时只接受该属性本来的类型。
演示去掉JavaBean（ReflectPoint）的public修饰符时，BeanUtils工具包访问javabean属性时出现的问题。
用struts的迭代标签不能迭代出枚举元素的属性，而用jstl的迭代标签则可以。采用BeanUtils去获取带有抽象方法的枚举类的成员对象的属性时，会出现错误，要自己用内省加暴力反射方式才可以获取。主要原因是枚举类的抽象子类不是public类型的。
- 部分代码：
- String name1 = BeanUtils.getProperty(p, "name");
- System.out.println(BeanUtils.getProperty(p, "name").getClass().getName());
- System.out.println(name1);
- BeanUtils.setProperty(p, "age", 19);
- System.out.println(p.getAge());
- /*打印结果
- * 董方宇
- 23
- java.lang.String
- 董方宇
- 19*/
二、注解（Annotation）
1、注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记。
以后，javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。
2、标记可以加在包，类，字段，方法，方法的参数以及局部变量上。
3、一个注解相当于一个类。
看java.lang包，可看到JDK中提供的最基本的annotation。
1)、@SuppressWarning(”deprecation”)--->压制警告
SupressWarning是告知编译器或开发工具等提示指定的编译器警告；
”deprecation”是告知具体的信息即方法已过时。
2)、@Deprecated（过时的方法，对于不再使用的方法，可能别人或别的地方有调用这个方法，不能删除完事）
直接在刚才的类中增加一个方法，并加上@Deprecated标注，在另外一个类中调用这个方法。测试一下。
@SuppressWarnings("deprecation") （用这个可以告诉 程序说，我知道调用的方法过时了）
3)、@Override--->提示覆盖（父类方法）
public boolean equals(Reflect other)方法与HashSet结合讲解
像person类，覆盖父类的equals 和hashCode方法，人家接收的参数是Object，人们习惯总是传入自己的对象，造成覆盖失败，变成重载！
注解的应用结构图
演示和讲解@Target元注解
Target（告诉编译器，自定义的注解类可以用在方法还是类....），设置Target等于ElementType.METHOD，原来加在类上的注解就报错了，改为用数组方式设置{ElementType.METHOD,ElementType.TYPE}就可以了。
元注解以及其枚举属性值不用记，只要会看jdk提供那几个基本注解的API帮助文档的定义或其源代码，按图索骥即可查到，或者直接看java.lang.annotation包下面的类。
- （自定义注解）示例代码：
- @Retention(RetentionPolicy.RUNTIME)//告诉程序说，这个注解要保存到运行时期
- @Target({ElementType.METHOD,ElementType.TYPE})//告诉编译器，这个注解可以用在方法上，也可以用在类上
- public @interface MyAnnotation {
- String color() default "yellow";//默认缺省值为yellow
- String value() ;//不指定
- int [] arrayAttr() default {1,2};//默认为{1,2}
- EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;//枚举类
- MetaAnnotation annotationAttr() default @MetaAnnotation("xxx");//属性中加注解，用@。可以在对别的类加注解时，改变值
- }
为注解增加基本属性
（可以是八种基本数据类型，String ，数组，枚举，注解，Class）
什么是注解的属性?
一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是传智播客的学生，否则，就不是。如果还想区分出是传智播客哪个班的学生，这时候可以为胸牌在增加一个属性来进行区分。加了属性的标记效果为：@MyAnnotation(color="red")
定义基本类型的属性和应用属性：
在注解类中增加String color();
@MyAnnotation(color="red")
用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法
MyAnnotation a = (MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);
System.out.println(a.color());
可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象
如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("lhm")。
枚举和注解都是特殊的类，不能用new 创建它们的实例对象，创建枚举的实例对象就是在其中增加元素。
在程序中如何创建出一个注解的实例对象啊？直接用@放上一个标记即可
- import java.lang.reflect.Method;
- import javax.jws.soap.InitParam;
- @ItcastAnnotation(annotationAttr=@MetaAnnotation("flx"),color="red",value="abc",arrayAttr=1)
- public class AnnotationTest {
- /**
- * @param args
- */
- @SuppressWarnings("deprecation")
- @ItcastAnnotation("xyz")
- public static void main(String[] args) throws Exception{
- // TODO Auto-generated method stub
- System.runFinalizersOnExit(true);
- if(AnnotationTest.class.isAnnotationPresent(ItcastAnnotation.class)){
- ItcastAnnotation annotation = (ItcastAnnotation)AnnotationTest.class.getAnnotation(ItcastAnnotation.class);
- System.out.println(annotation.color());
- System.out.println(annotation.value());
- System.out.println(annotation.arrayAttr().length);
- System.out.println(annotation.lamp().nextLamp().name());
- System.out.println(annotation.annotationAttr().value());
- }
- Method mainMethod = AnnotationTest.class.getMethod("main", String[].class); ItcastAnnotation annotation2 =
- (ItcastAnnotation)mainMethod.getAnnotation(ItcastAnnotation.class);
- //获取String类上main函数上的注解
- System.out.println(annotation2.value());
- }
- @Deprecated//告诉调用者，这个方法过期了。
- public static void sayHello()
- {
- System.out.println("hello,传智播客");
- }
- }
- -----------------------------------------------------
- MetaAnnotation注解的定义：
- public @interface MetaAnnotation {
- String value();
- }
看java语言规范：
打开j3toc.html页面后，搜索annotation，进入9.6节，在其中的第5个Discussion部分就有属性类型的讲解说明，可以知道枚举的属性类型包括：基本数据类型，String，Class，枚举，其他注解，以及这些类型的数组。
三、泛型
Jdk 1.5以前的集合类中存在什么问题
ArrayList collection = new ArrayList();
collection.add(1);
collection.add(1L);
collection.add("abc");
int i = (Integer) collection.get(1);//编译要强制类型转换且运行时出错！
Jdk 1.5的集合类希望你在定义集合时，明确表示你要向集合中装哪种类型的数据，无法加入指定类型以外的数据
ArrayList<Integer> collection2 = new ArrayList<Integer>();
collection2.add(1);
/*collection2.add(1L);
collection2.add(“abc”);*///这两行代码编译时就报告了语法错误
int i2 = collection2.get(0);//不需要再进行类型转换
泛型是提供给javac编译器使用的，
利用反射穿透泛型限制 （暴力反射）
泛型能绝对保证集合中存入数据都是它限定的类型吗？先看下边的代码
- ArrayList<Integer> collection2 = new ArrayList<Integer>();
- System.out.println(collection1.getClass()==collection2.getClass());
- collection2.add（“真暴力”）；//这句会报错
- collection2.getClass().getMethod("add", Object.class).invoke(collection2, "真暴力");
- System.out.println(collection2.get(0)); //结果却为真暴力
- 已经限制集合中元素的类型为Integer，可用反射却能将String存入，为什么？ 这是因为泛型是给编译器用的，运行时就没有这些泛型信息了，这叫做“去泛型化”，所以可以通过反射，获取集合字节码加入非指定的类型。
了解泛型（genericity）
ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：
整个称为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>(); //也错误!
泛型中的类型参数严格说明集合中装载的数据类型是什么和可以加入什么类型的数据，记住:Collection<String>和Collection<Object>是两个没有转换关系的参数化的类型。
假设Vector<String> v = new Vector<Object>();可以的话，那么以后从v中取出的对象当作String用，而v实际指向的对象中可以加入任意的类型对象；假设Vector<Object> v = new Vector<String>();可以的话，那么以后可以向v中加入任意的类型对象，而v实际指向的集合中只能装String类型的对象。
编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：
Vector<Integer> vectorList[] = new Vector<Integer>[10];
思考题：下面的代码会报错误吗？
Vector v1 = new Vector<String>();
Vector<Object> v = v1;
不会报错，因为编译器只按照语法进行检查，不能按运行时的道理去编译嘛
泛型中的？通配符
- 问题：
- 定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义呢？
- 错误方式：
- public static void printCollection(Collection<Object> cols) {
- for(Object obj:cols) {
- System.out.println(obj);
- }
- /* cols.add("string");//没错
- cols = new HashSet<Date>();//会报告错误！（泛型不存在继承）*/
- }
- 正确方式：
- public static void printCollection(Collection<?> cols) {
- for(Object obj:cols) {
- System.out.println(obj);
- }
- //cols.add("string");//错误，因为它不知自己未来匹配就一定是String
- cols.size();//没错，此方法与类型参数没有关系
- cols = new HashSet<Date>();//没错
- a.add(“abc”)都不行，
- /*Cols<Object> 中的Object只是说明Cols<Object> 实例对象中的方法接受的参数是Object
- Cols<Object> 是一种具体类型，new HashSet<Date>也是一种具体类型，两者没有兼容性问题。
- */
- Collection<?> a可以与任意参数化的类型匹配，但到底匹配的是什么类型，只有以后才知道，所以，
- a=new ArrayList<Integer>和a=new ArrayList<String>都可以， 但a.add(new 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>();
提示：
限定通配符总是包括自己。
?只能用作引用，不能用它去给其他变量赋值
Vector<? extends Number> y = new Vector<Integer>();
Vector<Number> x = y;
上面的代码错误，原理与Vector<Object > x11 = new Vector<String>();相似，
只能通过强制类型转换方式来赋值。
- 泛型集合类的综合案例
- 能写出下面的代码即代表掌握了Java的泛型集合类：
- HashMap<String,Integer> hm = new HashMap<String,Integer>();
- hm.put("zxx",19);
- hm.put("lis",18);
- Set<Map.Entry<String,Integer>> mes= hm.entrySet();
- for(Map.Entry<String,Integer> me : mes) {
- System.out.println(me.getKey() + ":" + me.getValue());
- }
- 由C++的模板函数引入自定义泛型
- 如下函数的结构很相似，仅类型不同：
- int add(int x,int y) {
- return x+y;
- }
- float add(float x,float y) {
- return x+y;
- }
- double add(double x,double y) {
- return x+y;
- }
- C++用模板函数解决，只写一个通用的方法，它可以适应各种类型，示意代码如下：
- template<class T>
- T add(T x,T y) {
- return (T) (x+y);
- }
- 定义泛型方法
- Java的泛型方法没有C++模板函数功能强大，java中的如下代码无法通过编译：
- <T> T add(T x,T y) {
- return (T) (x+y);
- //return null;
- }
- Java中的泛型类型（或者泛型）类似于 C++ 中的模板。但是这种相似性仅限于表面，Java 语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码，这种实现技术称为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型被认为是无法接受的，这会为 Java 厂商升级其 JVM 造成难以逾越的障碍。所以，java的泛型采用了可以完全在编译器中实现的擦除方法。
- 用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示。
- 交换数组中的两个元素的位置的泛型方法语法定义如下：
- static <E> void swap(E[] a, int i, int j) {/
- /比如int[] 已经就是对象，不会在转为Integer对象。
- E t = a[i];
- a[i] = a[j];
- a[j] = t;
- }//或用一个面试题讲：把一个数组中的元素的顺序颠倒一下
- 只有引用类型才能作为泛型方法的实际参数，swap(new int[3],3,5);语句会报告编译错误
- <T>中的T不能被int（基本类型）替换，int[]本来就是数组类型（对象），不会自动装箱了。
- 除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如，Class.getAnnotation()方法的定义。并且可以用&来指定多个边界（两个接口的实现类），如<V extends Serializable & cloneable> void method(){}
- 普通方法、构造方法和静态方法中都可以使用泛型。
- 也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。
- 在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分，例如：
- public static <K,V> V getValue(K key) { return map.get(key);}
- 例如，下面这两个方法，编译器会报告错误，它不认为是两个不同的参数类型，而认为是同一种参数类型。
- private static void applyGeneric(Vector<String> v){
- }
- private static void applyGeneric(Vector<Date> v){
- }
- 测试代码：
- String[] strs = new String[]{"a","b","c"};
- swap(strs,1,2);
- System.out.println(Arrays.asList(strs));
- 只有引用类型才能作为泛型方法的实际参数，对于add方法，使用基本类型的数据进行测试没有问题，这是因为自动装箱和拆箱了。 swap(new int[3],3.5);语句会报告编译错误，这是因为编译器不会对new int[3]中的int自动拆箱和装箱了，因为new int[3]本身已经是对象了，你想要的有可能就是int数组呢？它装箱岂不弄巧成拙了。
- 用下面的代码说明对异常如何采用泛型：
- private static <T extends Exception> sayHello() throws T
- {
- try{
- }catch(Exception e){
- throw (T)e;
- }
- }
- 演示两个泛型参数的例子没有什么实际意义，以后有机会的话，应该换成一个有实际意义的例子。
泛型方法的练习题
- 编写一个泛型方法，自动将Object类型的对象转换成其他类型。
- private static <T> T autoConvert(Object obj){
- return (T)obj;
- 定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象。
- private static <T> void fillArray(T[] a,T obj){
- for(int i=0;i<a.length;i++){
- a[i] = obj;
- }
- 采用自定泛型方法的方式打印出任意参数化类型的集合中的所有内容。
- public static void printCollection(Collection<?> collection){
- //collection.add(1);
- System.out.println(collection.size());
- for(Object obj : collection){
- System.out.println(obj);
- }
- 定义一个方法，把任意参数类型的集合中的数据安全地复制到相应类型的数组中。
- public static <T> void copy2(Collection<T> dest,T[] src){
- Iterator<T> it = dest.iterator();
- int x =0;
- while(it.hasNext()){
- src[x] = it.next();
- x++;
- }
- }
- 定义一个方法，把任意参数类型的一个数组中的数据安全地复制到相应类型的另一个数组中。
- public static <T> void copy2(T[] dest,T[] src){
类型参数的类型推断（花了张老师两天的时间总结）
l 编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。
l 根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：
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．当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：
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> 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);
copy(new Vector<String>(), new Integer[5]) à static <T> void copy(Collection<T> a , T[] b);
定义泛型类型
l 如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：
public class GenericDao<T> {
private T field1;
public void save(T obj){}
public T getById(int id){}
}
l 类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：
GenericDao<String> dao = null;
new genericDao<String>();
l 注意：
在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。
当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。
l 问题：类中只有一个方法需要使用泛型，是使用类级别的泛型，还是使用方法级别的泛型？
- (Create)、查询(Retrieve)（重新得到数据）、更新(Update)和删除(Delete)几个单词的首字母简写
- import java.util.Set;
- //dao data access object（数据访问对象）--->crud
- public class GenericDao<E> {
- public void add(E x){
- }
- public E findById(int id){
- return null;
- }
- public void delete(E obj){
- }
- public void delete(int id){
- }
- public void update(E obj){
- }
- public static <E> void update2(E obj){
- }
- public E findByUserName(String name){
- return null;
- }
- public Set<E> findByConditions(String where){
- return null;
- }
- }
通过反射获得泛型的参数化类型
/*本想通过Class字节码获取方法的泛型，但是泛型是给编译器看的，所以字节码中不包含泛型信息，这时想到可以通过java.lang.Reflect.Method中的新方法，可以返回参数列表的泛型，问题解决了！*/
- public class GenericTest {
- public static void main(String[] args) throws Exception {Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);
- Type[] types = applyMethod.getGenericParameterTypes();
- ParameterizedType pType = (ParameterizedType)types[0];
- //参数化类型ParameterizedType
- System.out.println(pType.getRawType());
- //原始类型，Class java.util.vector
- System.out.println(pType.getActualTypeArguments()[0]);
- //实际参数化类型的数组，打印结果Class java.util.Data
- }
- public static void applyVector(Vector<Date> v1){
- }
- }
- 我的疑问，ParameterizedType 是Type接口的子类接口，其中有三个方法，上述代码中调用了 pType.getRawType()和pType.getActualTypeArguments()[0]这两个，接口中的方法都是抽象的，没有方法体，怎么能调用，并能返回值？ParameterizedType pType = (ParameterizedType)types[0];//这一句很奇葩啊，算不算面向接口编程？接口类型变量能调用其抽象方法？
359
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
