高薪技术知识(2)
来源：互联网 发布：北京装修公司 知乎 编辑：程序博客网 时间：2024/05/16 04:42
反射的基石-Class类
Class：类的名字，叫Class，代表一类事物，是什么样的事物呢？
描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例来决定，不同的实例对象有不同的属性值，JAVA程序中的各个Java类，这个类的名字就是Class，要注意与小写的class的区别哦。
*众多的人用一个什么类表示？众多的Java类用一个什么类表示
Person-->
Class-->代表一类什么样的事物？
Person p1 = new Person();
Person p2 = new Person();
Date类
Math类
以上三种类有三份字节码，每一份字节码就是一个对象：Class
class cls1 = 字节码1;class cls2 = 字节码2;
Class类里有很多方法，当不能new对象。不提供new对象的方法。
*如何得到各个字节码对象的实例对象（Class类型）
（1）、类名.class。例如System.class
（2）、对象.getClass()。例如new Data().getClass();
（3）、Class.forName("类名")，例如Class.forName("lang.util.Date");
cls1 = Date.class//字节码（得到字节码的方式1）p1.getClass();//得到字节码的方式2Class.forName("java.lang.String");//得到这个类的字节码3
有九个预定义的字节码，就是八个基本数据对象和void的字节码Class cls1 = void.class;
*参看Class.isPrimitive方法的帮助public class ReflectTest{ public static void main(String[]args)throws Exception { String str1 = "abc"; Class cls1 = str1.getClass(); Class cls2 = String.class(); Class cls3 = Class.forName("java.lang.String"); System.out.println(cls1 == cls2);//true System.out.println(cls2 == cls3);//true System.out.println(cls1.isPrimitive());//flase System.out.println(int.class.isPrimitive());//true System.out.println(int.class == Integer.class);//false System.out.println(int.class.Integer.TYPE);//true,TYPE：。。。的基本类型 System.out.println(int[].class.isPrimitive());//false System.out.println(int[].class.isArray());//true }}
*int.class == Integer.TYPE
*数组类型的Class实例对象：Class.isArray()
总之，只要是在源程序中出现的类型都有各自的Class实例对象，例如int[]，void....
1.8理解反射的概念
反射
反射就是把Java类中的各种成分映射成相应的java类。例如，一个java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类，表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
学生总结：反射就是把Java类中的各个成分映射成相应的java类。System.exit()-->methodObj1System.getProperties()-->methodObj2Method-->methodObj1 methodObj2
一个类中的每一个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。
1.9构造方法的反射应用
Constructor类
Constructor类代表某个类中的一个构造方法
*得到某个类所有的构造方法：
例子:
*得到某一个构造方法：Constructor [] constructors = Class.forName("java.lang.String").getConstructors();
例子：
获得方法时要用到类型Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class));
*创建实例对象
通常方式：String str = new String(new StringBuffer("abc"));
反射方式：String str = (String)constructor.newInstance(new StringBuffer("abc"));
//调用获得的方法时要用到上面相同类型的实例对象。
*Class.newInstance()方法
class-->constructor-->new object(以下例子是直接从class环节跳到new object环节)
例子：
String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。
package itheima;import java.lang.reflect.Constructor;public class ReflectTest {public static void main(String[] args)throws Exception{//String str = new String ("abc");//想用反射的机制实现同样的效果
//用反射的原理实现以上代码Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);//表示选择哪个构造方法
String str =(String) constructor.newInstance(new StringBuffer("abc"));//用这个构造方法还要传一个构造方法进去
System.out.println(str.charAt(2));//c，使用反射实现功能成功
}}
2.0成员变量的反射
Field类
*Field类代表某个类中的一个成员变量
*演示用eclipse自动生成Java类的构造方法
*问题：
得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？
类只有一个，而该类的实例对象有多个，即与对象关联。
如果是与对象关联，那关联的是哪个对象呢？
所以字段fieldX代表的是x的定义，而不是具体的x变量。
import java.lang.reflect.Constructor;import java.lang.reflect.*;public class ReflectTest {public static void main(String[] args)throws Exception{//String str = new String ("abc");//用反射的原理实现以上代码Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);String str =(String) constructor.newInstance(new StringBuffer("abc"));System.out.println(str.charAt(2));//cReflectPoint pt1 = new ReflectPoint(3,3);Field fieldY = pt1.getClass().getField("y");System.out.println(fieldY.get(pt1));//3Field fieldX = pt1.getClass().getDeclaredField("x");//暴力反射fieldX.setAccessible(true);System.out.println(fieldX.get(pt1));//3}}class ReflectPoint {private int x ;public int y ;ReflectPoint(int x, int y){super();this.x = x ;this.y = y;}}
2.1成员变量反射的综合案例
作业：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。
package itheima;import java.lang.reflect.Constructor;import java.lang.reflect.*;public class ReflectTest{ public static void main(String[]args)throws Exception{ ReflectPoint pt1 = new ReflectPoint(3,5); changeStringValue(pt1); System.out.println(pt1);//aall:aasketaall:itcast } private static void changeStringValue(Object obj)throws Exception{ Field[] fields = obj.getClass().getFields(); for(Field field : fields){ //if(field.getType().equals(String.class)) if(field.getType() == String.class){ String strValue = (String)field.get(obj); String newValue = strValue.replace('b','a'); field.set(obj,newValue); } } }}class ReflectPoint {private int x ; public int y; public String str1 = "ball"; public String str2 = "basketball"; public String str3 = "itcast"; public ReflectPoint(int x ,int y){ super(); this.x = x; this.y = y; } @Override public String toString(){ return str1 + ":" + str2 + ":" +str3; }
}
2.2成员方法的反射
Method类
*Method类代表某个类中的一个成员方法
*得到类中的某一个方法：
例子：
Method charAt = Class.forName("java.lang.String").getMethod("charAt",int.class);
*调用方法：
通常方式：System.out.println(str.charAt(1));
反射方式：System.out.println(charAt.invoke(str,1));
*如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法。
*jdk1.4和jdk1.5的invoke方法的区别：
jdk1.5：public Object invoke(Object obj, Object ...args)
jdk1.4：public Object invoke (Object obj,Object[]args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每一个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用jdk1.4改写为charAt.invoke("str",new Object[]{1})形式
package itheima;import java.lang.reflect.Constructor;import java.lang.reflect.*;public class ReflectTest{ public static void main(String[]args)throws Exception{ Constructor constructor1 = String.class.getConstructor(StringBuffer.class);//表示选择哪个构造方法 String str1 = (String)constructor1.newInstance(new StringBuffer("abc"));//用这个构造方法还要传一个构造方法进去 System.out.println(str1.charAt(2));//c，使用反射实现功能成功 //str1.charAt(1)； Method methodCharAt = String.class.getMethod("charAt",int.class); System.out.println(methodCharAt.invoke(str1,1));//b System.out.println(methodCharAt.invoke(str1,new Object[]{2}));//c }}2.3、对接收数组参数的成员方法进行反射
*目标：
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调用完后，大家明白为什么要用反射方式去调用？
*问题
启动java程序的main方法的参数是一个字符串数组，即public static void main(String [] args)，通过反射方式来调用这个main方法，如何为invoke方法传递参数呢？按jdk1.5语法，整个数组是一个参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{"xxx"}),java只把它当做jdk1.4的语法进行理解，而不把它当做jdk1.5的语法解释，因此会出现参数类型不对的问题。
*解决方法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"});，编译器会作特殊处理，编译时不把参数当做数组看待，也就不会数组打散成若干个参数了。
package itheima;import java.lang.reflect.Constructor;import java.lang.reflect.*;public class ReflectTest{//现在有两个主类，由于我们是要用反射的机制去调用另外的主函数，所以要eclipse里的Run对话框里的Arguments里把要调用的主函数的类名复制进去 public static void main(String[]args)throws Exception{ //TestArguments.main(new String[]{"111","222","333"});//打印 String startingClassName = args[0]; Method mainMethod = Class.forName(startingClassName).getMethod("main",String[].class); //mainMethod.invoke(null,new Object[]{new String[]{"111","333","222"}});//方法1 mainMethod.invoke(null,(Object)new String[]{"111","222","333"});//方法2 }}public class TestArguments {public static void main(String[] args) {for(String arg:args){ System.out.println(arg); }}}输出结果：
111
222
333
2.4、数组与Object的关系及其反射类型
*具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
*代表数组的Class实例对象的getSuperClass()方法返回的父亲为Object类对应的Class。
*基本类型的一维数据可以被当做Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
*Arrays.asList()方法处理int[]和String[]时的差异。
*Array工具类用于完成对数组的反射操作。
*思考题：怎么得到数组中的元素类型？
package itheima;import java.lang.reflect.*;import java.util.Arrays;public class ReflectTest{ public static void main(String[]args)throws Exception{ int [] a1 = new int []{1,2,3}; int [] a2 = new int [4]; int [][] a3 = new int[2][3]; String []a4 = new String []{"a","b","c"}; System.out.println(a1 == a2);//false System.out.println(a1.getClass() == a2.getClass());//true //System.out.println(a1 == a4);//不能运行 //System.out.println(a1 == a3);//不能运行 //System.out.println(a1.getClass() == a4.getClass());//false // System.out.println(a1.getClass() == a3.getClass());//false System.out.println(a1.getClass().getName());//[I System.out.println(a1.getClass().getSuperclass().getName());//java.lang.Object System.out.println(a4.getClass().getSuperclass().getName());//java.lang.Object Object aObj1 = a1; Object aObj2 = a4; //Object[] aObj3 = a1;//程序出错 Object[] aObj4 = a3; Object[] aObj5 = a4;//但这是？ System.out.println(a1);//[I@1cfb549 System.out.println(a4);//[Ljava.lang.String;@186d4c1 System.out.println(Arrays.asList(a1));//[[I@1cfb549]基本类型的一维数据可以被当做Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。 System.out.println(Arrays.asList(a4));//[a,b,c] }}
2.5、数组的反射应用
输出结果：package itheima;
import java.lang.reflect.*;import java.util.Arrays;public class ReflectTest{ public static void main(String[]args)throws Exception{ int [] a1 = new int []{1,2,3}; int [] a2 = new int [4]; int [][] a3 = new int[2][3]; String []a4 = new String []{"a","b","c"}; Object obj = null; // printObject(obj); printObject(a4); printObject("xyz"); } private static void printObject(Object obj){ Class clazz = obj.getClass(); if(clazz.isArray()){ int len = Array.getLength(obj); for(int i = 0;i<len;i++){ System.out.println(Array.get(obj,i)); } } else{ System.out.println(obj); } }}
a
b
c
xyz
2.6、ArrayList_HashSet的比较及Hashcode分析
输出结果：package itheima;import java.lang.reflect.*;import java.util.Arrays;import java.util.ArrayList;import java.util.Collection;import java.util.HashSet;public class ReflectTest{ public static void main(String[]args){ Collection collections = new ArrayList(); //Collection collections = new HashSet(); ReflectPoint pt1 = new ReflectPoint(3,3); ReflectPoint pt2 = new ReflectPoint(5,5); ReflectPoint pt3 = new ReflectPoint(3,3); collections.add(pt1); collections.add(pt2); collections.add(pt3); collections.add(pt1); System.out.println(collections.size()); }}class ReflectPoint { private int x ; public int y; public String str1 = "ball"; public String str2 = "basketball"; public String str3 = "itcast"; public ReflectPoint(int x ,int y){ super(); this.x = x; this.y = y; } public String toString(){ return str1 + ":" + str2 + ":" +str3; }}
4
2.7、框架的概念及用反射技术开发框架的原理
反射的作用-->实现框架功能
*框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中，框架与工具类有区别，工具类被用户的类调用，而框架而是调用用户提供的类。
*框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序？我写的框架程序怎样能调用到你以后写的类（门窗）呢?
因为在写程序时无法知道要被调用的类名，所以，在程序中无法直接new某个类的实例对象了，而要用反射方式来做。
*综合案例
先直接用new语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
然后改为采用配置文件夹反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。
（之前使用的有关反射的类已经掌握得差不多了）
在eclipse里的项目栏里右击生成File文件，File name里输入config.properties生成。在文件里输入className = java.util.ArrayList
输出结果：package itheima;import java.io.*;import java.lang.reflect.*;import java.util.*;
public class ReflectTest{ public static void main(String[]args)throws Exception{ InputStream ips = new FileInputStream("config.properties");//在eclipse里的项目栏里右击生成File文件，File name里输入config.properties生成。在文件里输入className = java.util.ArrayList
Properties props = new Properties(); props.load(ips); ips.close(); String className = props.getProperty("className"); Collection collections = (Collection)Class.forName(className).newInstance(); //在这一框架下只要改变config.properties文件里的className的内容就好。 //Collection collections = new ArrayList(); //Collection collections = new HashSet(); ReflectPoint pt1 = new ReflectPoint(3,3); ReflectPoint pt2 = new ReflectPoint(5,5); ReflectPoint pt3 = new ReflectPoint(3,3); collections.add(pt1); collections.add(pt2); collections.add(pt3); collections.add(pt1); System.out.println(collections.size()); }}
4
2.8、用类加载器的方式管理资源和配置文件
package itheima;输出结果：import java.io.*;import java.lang.reflect.*;import java.util.*;public class ReflectTest{ public static void main(String[]args) throws Exception{ //一定要记住用完整的路径，但完整的路径不是硬编码，而是运算出来的。 //getRealPath();//金山词霸/内部 //InputStream ips = new FileInputStream("config.properties"); //InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties")//加载其他文件的方法,配置文件跟类文件放在一起，只要把文件路径放在上面即可 InputStream ips =ReflectTest.class.getResourceAsStream("config.properties");//另一种资源加载方法 Properties props = new Properties(); props.load(ips); ips.close(); String className = props.getProperty("className"); Collection collections = (Collection)Class.forName(className).newInstance();//在这一框架下只要改变config.properties文件里的className的内容就好。 //Collection collections = new ArrayList(); //Collection collections = new HashSet(); ReflectPoint pt1 = new ReflectPoint(3,3); ReflectPoint pt2 = new ReflectPoint(5,5); ReflectPoint pt3 = new ReflectPoint(3,3); collections.add(pt1); collections.add(pt2); collections.add(pt3); collections.add(pt1); System.out.println(collections.size()); }}
4
2.9、由内省引出JavaBean的讲解
内省---
IntroSpector--->JavaBean-->特殊的Java类
class Person{ private int x ; public int getAge(){ return x; } public void setAge(int age){ this.x = age; }}
JavaBean属性的介绍
Age-->如果第二个字母是小的，则把第一个字母变成小的--->age
gettime-->time
setTime-->time
getCPU-->CPU
面试时写出这样的代码：
int getAge(int age){}//笑话
3.0、对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！好处如下：
在JavaEE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作，别人都这么用和要求这么做，那你就没什么挑选的余地！
JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。
内省综合案例
把之前的ReflectPoint改为JavaBean
以下是使用JavaBean的模板package itheima;import java.lang.reflect.Constructor;class ReflectPoint { private int x ; public int y; public String str1 = "ball"; public String str2 = "basketball"; public String str3 = "itcast"; public ReflectPoint(int x ,int y){ super(); this.x = x; this.y = y; } public String toString(){ return str1 + ":" + str2 + ":" +str3; } public int getX() { return x; } public void setX(int x) { this.x = x; } public int getY() { return y; } public void setY(int y) { this.y = y; }}
输出结果：//内省:部分代码利用eclipse重构前
package itheima;import java.beans.PropertyDescriptor;import java.lang.reflect.Method;public class IntorSpectorTest { public static void main(String[] args) throws Exception{ ReflectPoint pt1 = new ReflectPoint(3,5); String propertyName = "x"; //"x"-->"X"--->"getX"--->MethodGetX--> PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass()); Method methodGetX = pd.getReadMethod(); Object retVal = methodGetX.invoke(pt1); System.out.println(retVal); Object value = 7; PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass()); Method methodSetX = pd2.getWriteMethod(); methodSetX.invoke(pt1,value); System.out.println(retVal); System.out.println(pt1.getX()); }}
3
3
7
输出结果：//内省:部分代码利用eclipse重构后package itheima;import java.beans.IntrospectionException;import java.beans.PropertyDescriptor;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;public class IntorSpectorTest { public static void main(String[] args) throws Exception{ ReflectPoint pt1 = new ReflectPoint(3,5); String propertyName = "x"; //"x"-->"X"--->"getX"--->MethodGetX--> Object retVal = getProperty(pt1, propertyName); System.out.println(retVal); setProperty(pt1, propertyName); System.out.println(retVal); System.out.println(pt1.getX()); } private static void setProperty(Object pt1, String propertyName) throws IntrospectionException, IllegalAccessException, InvocationTargetException { Object value = 7; PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass()); Method methodSetX = pd2.getWriteMethod(); methodSetX.invoke(pt1,value); } private static Object getProperty(Object pt1, String propertyName) throws IntrospectionException, IllegalAccessException, InvocationTargetException { PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass()); Method methodGetX = pd.getReadMethod(); Object retVal = methodGetX.invoke(pt1); return retVal; }}
3
3
7
3.1、对JavaBean的复杂内省操作
内省综合案例
*演示用eclipse自动生成ReflectPoint类的setter和getter方法
*直接new一个PropertyDescriptor对象的方式来让大家了解JavaBean API的价值，先用一段代码读取JavaBean的属性，然后再用一段代码设置JavaBean的属性。
*演示用eclipse将读取属性和设置属性的流水账代码分别抽取成方法：
只要调用这个方法，并给这个方法传递了一个对象、属性名和设置值，它就能完成属性修改的功能。
得到BeanInfo最好采用“obj.getClass()”方式，而不要采用“类名.class”方式，这样程序更通用。
*采用遍历BeanInfo的所有属性方式来查找和设置某个ReflectPoint对象的x属性，在程序中把一个类当作JavaBean来看，就是调用IntroSpector.getBeanInfo方法，得到的BeanInfo对象封装了把这个类当作JavaBean看的结果信息。
BeanInfo就是把类看做JavaBean来看，看出一些信息来。
package itheima;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;public class IntorSpectorTest { public static void main(String[] args) throws Exception{ ReflectPoint pt1 = new ReflectPoint(3,5); String propertyName = "x"; //"x"-->"X"--->"getX"--->MethodGetX--> Object retVal = getProperty(pt1, propertyName); System.out.println(retVal); setProperty(pt1, propertyName); System.out.println(retVal); System.out.println(pt1.getX()); } private static void setProperty(Object pt1, String propertyName) throws IntrospectionException, IllegalAccessException, InvocationTargetException { Object value = 7; PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass()); Method methodSetX = pd2.getWriteMethod(); methodSetX.invoke(pt1,value); } private static Object getProperty(Object pt1, String propertyName) throws IntrospectionException, IllegalAccessException, InvocationTargetException { /* PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass()); Method methodGetX = pd.getReadMethod(); Object retVal = methodGetX.invoke(pt1); */ //以上是现在常用的内省代码，以下是以前老师用的较复杂的内省代码 BeanInfo beanInfo = Introspector.getBeanInfo(pt1.getClass());//beanInfo里有很多方法。 PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors(); Object retVal = null; for(PropertyDescriptor pd :pds){ if(pd.getName().equals(propertyName)){ Method methodGetX = pd.getReadMethod(); retVal = methodGetX.invoke(pt1); break; } } return retVal; }}
3.2、使用BeanUtils工具包操作JavaBean
BeanUtils工具包
*演示用eclipse如何加入jar包，先只是引入BeanUtils包，等程序运行出错后再引入logging包，我就直接调用老师的工程测试好了。
*在前面内省自理的基础上，用BeanUtils类先get原来设置好的属性，再将其Set为一个新值。
get属性时返回的结果为字符串，set属性时可以接受任意类型的对象，通常使用字符串。
*用PropertyUtils类先get原来设置好的属性，再将其set为一个新值。
get属性时返回的结果为该属性本来的类型，set属性时只接受该属性本来的类型。
输出结果：package cn.itcast.day1;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 java.util.Map;import org.apache.commons.beanutils.BeanUtils;import org.apache.commons.beanutils.PropertyUtils;public class IntroSpectorTest { /** * @param args */ public static void main(String[] args) throws Exception { // TODO Auto-generated method stub ReflectPoint pt1 = new ReflectPoint(3,5); String propertyName = "x"; //"x"-->"X"-->"getX"-->MethodGetX--> Object retVal = getProperty(pt1, propertyName); System.out.println(retVal); Object value = 7; setProperties(pt1, propertyName, value); System.out.println(BeanUtils.getProperty(pt1, "x").getClass().getName());//要下载BeanUtils工具包，加载在eclipse工程里，同时还要加载日志包，不然会报错，这段代码是获取值 BeanUtils.setProperty(pt1, "x", "9");//注意是字符串 System.out.println(pt1.getX()); /* //java7的新特性//用BeanUtils加载Map对象 Map map = {name:"zxx",age:18}; BeanUtils.setProperty(map, "name", "lhm"); */ BeanUtils.setProperty(pt1, "birthday.time", "111");//为什么是birthday.time?没懂 System.out.println(BeanUtils.getProperty(pt1, "birthday.time"));//111，需要在ReflectPoint里new好Date对象，才不报错 //PropertyUtils.setProperty(pt1,"x","9");//报错 PropertyUtils.setProperty(pt1, "x", 9); System.out.println(PropertyUtils.getProperty(pt1, "x").getClass().getName()); } private static void setProperties(Object pt1, String propertyName, Object value) throws IntrospectionException, IllegalAccessException, InvocationTargetException { PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass()); Method methodSetX = pd2.getWriteMethod(); methodSetX.invoke(pt1,value); } private static Object getProperty(Object pt1, String propertyName) throws IntrospectionException, IllegalAccessException, InvocationTargetException { /*PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass()); Method methodGetX = pd.getReadMethod(); Object retVal = methodGetX.invoke(pt1);*/ BeanInfo beanInfo = Introspector.getBeanInfo(pt1.getClass()); PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors(); Object retVal = null; for(PropertyDescriptor pd : pds){ if(pd.getName().equals(propertyName)) { Method methodGetX = pd.getReadMethod(); retVal = methodGetX.invoke(pt1); break; } } return retVal; }}public class ReflectPoint { private Date birthday = new Date(); private int x; public int y; public String str1 = "ball"; public String str2 = "basketball"; public String str3 = "itcast"; public ReflectPoint(int x, int y) { super(); this.x = x; this.y = y; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + x; result = prime * result + y; return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; final ReflectPoint other = (ReflectPoint) obj; if (x != other.x) return false; if (y != other.y) return false; return true; } @Override public String toString(){ return str1 + ":" + str2 + ":" + str3; } public int getX() { return x;
} public void setX(int x) { this.x = x; } public int getY() { return y; } public void setY(int y) { this.y = y; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; }}
3
java.lang.String
9
111
java.lang.Integer
- 高薪技术知识(2)
- 高薪技术知识(3)
- 高薪技术知识(4)
- 高薪技术
- 黑马程序员_Java高薪技术2
- Java高薪技术
- [转]技术等于高薪？
- 高薪技术排行
- 黑马程序员----高薪技术(JavaBean)
- 黑马程序员_高薪技术
- 黑马程序员--高薪技术--反射
- java基础--高薪技术--反射
- 黑马程序员_高薪技术_7
- 黑马程序员_高薪技术_9
- 黑马程序员_高薪技术笔记
- 黑马程序员-java基础06高薪技术
- 黑马程序员_高薪技术（一）
- 黑马程序员_高薪技术（二）
- linq group by 处理
- 华为文化：任正非的“管理”门道
- 洗脸时不妨用盐水拍拍脸
- UICollectionView的使用方法及demo
- spring quartz 配置多个定时任务
- 高薪技术知识(2)
- JSTL fmt:formatNumber日期、 数字、货币格式化
- oracle 时间差转当前时间
- 背上长痘痘该如何护理？
- C++之引用
- Mybatis传多个参数（三种解决方案）
- vector iterators incompatible
- 短暂假眠给大脑活力
- C++:重载全局new/delete实现跨平台多线程内存检测
