Java高薪技术学习总结-02

Java高薪技术总结

Java高薪技术总结-02

1.7、透彻分析反射的基础-Class类

反射的基石-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();//得到字节码的方式2
Class.forName("java.lang.String");//得到这个类的字节码3
Class cls1 = void.class;

有九个预定义的字节码，就是八个基本数据对象和void的字节码

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
    }
}

*参看Class.isPrimitive方法的帮助

*int.class == Integer.TYPE

*数组类型的Class实例对象：Class.isArray()

总之，只要是在源程序中出现的类型都有各自的Class实例对象，例如int[]，void....

1.8理解反射的概念

• 反射

反射就是把Java类中的各种成分映射成相应的java类。例如，一个java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类，表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

System.exit()-->methodObj1
System.getProperties()-->methodObj2
Method-->methodObj1
         methodObj2

学生总结：反射就是把Java类中的各个成分映射成相应的java类。

一个类中的每一个成员都可以用相应的反射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();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。 该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

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));//c

        ReflectPoint pt1 = new ReflectPoint(3,3);
        Field fieldY = pt1.getClass().getField("y");
        System.out.println(fieldY.get(pt1));//3
        Field 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"。

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})形式

Demo

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"});，编译器会作特殊处理，编译时不把参数当做数组看待，也就不会数组打散成若干个参数了。

Demo

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工具类用于完成对数组的反射操作。

*思考题：怎么得到数组中的元素类型？

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、数组的反射应用

Demo

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分析

Demo

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

Demo

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、用类加载器的方式管理资源和配置文件

Demo

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

Demo

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;
    }
}

以下是使用JavaBean的模板

Demo

//内省:部分代码利用eclipse重构前
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

Demo

//内省:部分代码利用eclipse重构后
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来看，看出一些信息来。

Demo

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属性时只接受该属性本来的类型。

Demo

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