高新技术

　

第一节：可变参数与OverLoad相关面试题分析

1.        说说overload和override的区别

l  overload：它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。

l  在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序。

l  不能通过访问权限、返回类型、抛出的异常进行重载；

l  方法的异常类型和数目不会对重载造成影响；

l  对于继承来说，如果某一方法在父类中是访问权限是private，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

l  override：可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。

l  覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

l  覆盖的方法的返回值必须和被覆盖的方法的返回一致；

l  覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

l  被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

 

2.        可变参数的特点：

l  只能出现在参数列表的最后；

l  …位于变量类型和变量名之间，前后有无空格都可以。

l  调用可变参数的方法时，编译器为该可变阐述隐含创建一个数据，在方法体中以数据的形式访问可变参数。

3.        示例:

public static int add(int x,int… args){

         intsum = x;

         for(inti=0;i<args.length;i++){

         sum+= args[i];

}

return sum;

}

 

第二节：java5的增加for循环

1.        语法

l  for(type变量名: 集合变量名){…}

2.        注意事项：

l  迭代变量必须在（）中定义.

l  集合变量可以是数组或实现了Iterable接口的集合类.

3.        举例:

l  public static int add(int x;int… args){

int sum = x;

for(int arg : args){

         sum+= arg[i];

}

return sum;

}

第三节：基本数据的自动拆装箱及享元设计模式

1.        装箱及拆箱操作

l  Integer iObj = 3;

l  System.out.println(iObj + 12);

publicclass AutoBox {

    publicstaticvoid main(String[] args) {

       IntegeriObj = 12;

       System.out.println(iObj + 12);

      

       Integeri1 = 127;

       Integeri2 = 127;

       Integeri3 = 128;

       Integeri4 = 128;

       System.out.println(i1 == i2);//true  (-128~127)这里涉及到享元模式

       System.out.println(i3 == i4);//false

    }

}

2.        享元模式 flyweight

l  如果有很多很小的对象，有很多相同的东西，就可以变成一个对象，其他的不同的就作为外部属性，作为方法参数传入.

l  在word就用到了享元模式，26个字母就用26个对象,比如i字符只有一个对象I,只需要i.display(intx, int y)显示在不同位置。

 

第三节：枚举(没有看完第2阶段)

1.        为什么要有枚举？

l  问题：要定义星期几或性别的变量，该怎么定义？假设用1~7分别表示星期一到星期日，但有人可能会写成int weekday=0；

l  枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

2.        用普通类模拟枚举的实现原理，定义一个Weekday的类来模拟枚举功能。

l  私有的构造方法

l  每个元素分别用一个共有的静态成员变量表示

l  可以有若干共有方法或抽象方法，例如，要提供nextDay方法必须是抽象的。

publicclass EnumTest {

    publicstaticvoid main(String[] args) {

       WeekDayweekDay = WeekDay.MON;

       System.out.println(weekDay.nextDay());

    }

}

abstractclass WeekDay {

    private WeekDay(){}

   

    publicfinalstatic WeekDaySUN =new WeekDay(){

       public WeekDay nextDay() {

           returnMON;

       }

    };

    publicfinalstatic WeekDayMON =new WeekDay(){

       public WeekDay nextDay() {

           returnSUN;

       }

    };

    publicabstract WeekDay nextDay();

    public String toString(){

       returnthis==SUN ? "SUN":"MON";

    }

}

3.        java5的枚举的基本应用

l  举例：定义一个Weekday的枚举。

l  扩展：枚举类的values.falueOf.name.toString.ordinal等方法

l  总结:  枚举是一种特殊的类，其中的每个元素都是该类的一个实例对戏那个，例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName();

 

第四节：透彻分析反射的基础_Class类

1.        反射的基石->Class类

l  JAVA程序中的各个JAVA类属于同一类食物,描述这类事物的JAVA类名就是CLASS

l  例如: 人àPerson     JAVAàClass

l  对比提问:Person类代表人,他的实例对象就是张三等具体的人,Class类代表JAVA类,它的各个实例对象又分别对应什么?

        对应个各类在内存中的字节码,例如:Person类的字节码,ArrayList类的字节码等.

        一个类被类加载器加载到内存中,占用一片存储空间,这个空间里面的内容就是累的字节码,不同的类的字节码是不同的,所以他们在内存中的内容是不容的,这一个个的空间可分用一个个的对象来表示,这些对象显然具有相同的类型,这个类型是什么呢?

l  如何得到各个字节码队形的实例对象(Class类)

        实例化对象.getClass()

        类.class

        Class.forName(“包.类”);

l  注意:

        int.class == Integer.TYPE  (代表了包装的基本类型的字节码)

        int[].class.isPrimitive()  == false (数组也是一种类型,但不是原始类型)

 

第五节：反射

1.        什么是反射?

l  反射是通过Class类把java类中的各种成分映射成相应的java类.

l  一个类中的组成部分:成员变量,方法,构造方法,包等信息都可以用相应的类的实例对象来表示,他们是:Field,Method,Contructor,Package

第六节：构造方法的反射应用

1.        Constructor类

l  得到某个类的所有的构造方法:

        Constructor[]  constructor =  Class.forName(“java.lang.String”).getConstructor();

l  得到某一个构造方法:

        Constructor constructor =Class.forName(“java.lang.String”).getConstructor();

l  创建实例对象

        通常方法: String str = new String(“abc”);

        反射方法: String str = (String)constructor.newInstance(“abc”);

l  得到明确的构造方法:String(char[] value)

        Class.forName(“java.lang.Stirng”).getConstrustor(char[].class);

l  Class.newInstance()方法:

        例子:String obj = (String)Class.forName(“java.lang.String”).newInstance();

        该方法内部先得到默认的构造方法,然后用改构造方法创建实例对象.

        该方法用到了缓存机制来保存默认构造方法的实例对象.

 

第七节：成员变量的反射

1.        Field类:代表某个类中的一个成员变量

l  示例:

package org.reflect;

import java.lang.reflect.*;

public class ReflectDemo1 {

         public static void main(String[] args)throws Exception{

                   ReflectPoint rp = new ReflectPoint(10,15);

                   Class<?> c = rp.getClass();

                   Field fY = c.getField("y");

                   Object y = fY.get(rp);

                   //查看声明的属性

                   Field fX = c.getDeclaredField("x");

                   //暴力反射

                   fX.setAccessible(true);

                   Object x = fX.get(rp);

                   System.out.println(x+" "+y);

         }

}

class ReflectPoint{

         private int x;

         public int y;

         public ReflectPoint(int x,int y) {

                   super();

                   this.x = x;

                   this.y = y;

         }

         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 String toString(){

                   return "坐标为:"+this.x+" "+this.y;

         }

}

 

2.        综合案例

package org.reflect2;

import java.lang.reflect.*;

public class ReflectDemo {

         public static void main(String[] args)throws Exception{

                   ReflectPoint rp =new ReflectPoint(10,15);

                   changeStringValue(rp);

                   System.out.println(rp);

        

         }

         public static void changeStringValue(Object obj)throws Exception{

                   Field[] fields = obj.getClass().getFields();

                   for(Field field : fields){

                            Class<?>  fieldType = field.getType();

                            String str = null;

                            if(fieldType == String.class){

                                     str = (String) field.get(obj);

                                     str = str.replace('b','a'); 

                                     field.set(obj,str);

                            }                                            

                   }       

         }

}

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 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 String getStr1() {

                   return str1;

         }

         public void setStr1(String str1) {

                   this.str1 = str1;

         }

         public String getStr2() {

                   return str2;

         }

         public void setStr2(String str2) {

                   this.str2 = str2;

         }

         public String getStr3() {

                   return str3;

         }

         public void setStr3(String str3) {

                   this.str3 = str3;

         }

         public String toString(){

                   return "坐标为:"+this.x+" "+this.y+str1+" "+str2+" "+str3;

         }

}

 

 

第八节：成员方法的反射

1.        Method类

l  Method类代表某个类中的一个成员方法.

l  得到类中的某一个方法:

        例子: Method charAt =

 Class.forName(“java.lang.String”).getMethod(“charAt”,int.class);

l  调用方法:

        通常方式: char c = new String(“abc”).charAt(1);

        反射方法: Method charAt =

     Class.forName(“java.lang.String”).getMethod(“charAt”,int.class);

char c = charAt.invoke(newString(“abc”),1);

如果传递给Method对象的invoke()方法的一个参数为null,这有着什么样的意义呢?说明该Method对象对应的是一个静态方法.

l  getMethod()和getDeclaredMethod()的区别?

        getMethod()能拿到继承父类的方法,但是拿不到private修饰的私有方法.(通常使用这种)

        getDeclaredMethod()能拿到类声明的所有的方法.

 

l  jdk1.4和jdk1.5的invoke方法的区别:

        JDK1.5:public Objectinvoke(Object obj,Object…args)

        JDK1.4:public Objectinvoke(Object obj,Object[] args)

需要将一个数组作为参数传递给invoke方法是,数组中的每个元素分别对应被

l  对接收数组参数的成员方法进行反射:

        目标:写一个程序,这个程序能够根据用户提供的类名,去执行该类中的main方法,用普通方式完成后,要明白为什么要用反射方式去调用?

package org.reflect2;

import java.lang.reflect.*;

public class ReflectMethod {

         public static void main(String[] args)throws Exception{

                   //正常方式

                   TestArguments.main(new String[]{"111","222","333"});

                   //反射方式

                   String startClassName = args[0];

                   MethodmainMethod =

Class.forName(startClassName).getMethod("main", String[].class);

                   mainMethod.invoke(null,new Object[]{new String[]{"111","222","333"}});

                   //另一种方法(下划线为重点内容)

                   mainMethod.invoke(null,(Object)new String[]{"111","222","333"});

         }

}

class TestArguments{

         public static void main(String[] args){

                   for(String arg : args){

                            System.out.println(arg);

                   }

         }

}

 

第九节：数组的反射

1.        数组与Object的关系及其反射类型:

l  具有相同位数和元素类型的数组属于同一个类型,即具有相同的Class示例对象.

l  代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class.

l  基本类型的一位数组可以被当做Object类型使用,不能当做Object[]类型使用,非基本类型的一维数组.

l  Arrays.aslist()方法处理int[]和String[]的差异

l  Array工具类用于完成对数组的反射操作.

l  思考:怎么得到数组中的元素类型?(没有方法)

2.        数组反射示例:

package org.reflect3;

import java.lang.reflect.Array;

public class ReflectArray {

         public static void main(String[] args) {

                   String[] a4 = new String[]{"a","b","c"};

                   printObject(a4);

                   printObject("abc");

         }

         public static void printObject(Object obj){

                   Class<?> c = obj.getClass();

                   if(c.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);

                   }

         }

}

 

第十节：框架的概念及用反射技术开发框架的原理

1.        框架与框架要解决的核心问题

l  我做房子卖给用户住,由用户自己安装门窗和空调,我做的房子就是框架,用户需要使用我的框架,把门窗插入进我的提供的框架中.框架与工具类有区别,工具类被用户类调用,而框架则是调用用户提供的类.

2.        框架要解决的核心问题

l  我在写框架(房子)时,你这个用户可能还在上小学,还不会写程序?我写的框架程序怎么能调用到你以后写的类(门窗)呢?

l  因为在写程序时无法知道要被调用的类名,所以在程序中无法直接new某个类的实例对象了,而要用反射方式来做.

3.        综合案例:

l  先直接用new语句创建ArrayList和HashSet的实例对象,演示用eclipse自动生成ReflectPoint类的equals和hashcode方法,比较两个类两个集合的运行结果差异.

l  然后改为采用配置文件家反射的方式创建ArrayList和HashSet的实例对象,比较观察运行结果差异.

package org.reflect4;

import java.io.*;

import java.lang.reflect.*;

import java.util.*;

public class ReflectDemo {

         public static void main(String[] args)throws Exception{

                   InputStream fis = new FileInputStream("config.properties");

                   Properties p = new Properties();

                   p.load(fis);

                   String className = p.getProperty("className");

                   Class<?> c = Class.forName(className);

                   Collection collections = (Collection) c.newInstance();             

                   ReflectPoint a1 =new ReflectPoint(10,15);

                   ReflectPoint a2 =new ReflectPoint(5,5);

                   ReflectPoint a3 =new ReflectPoint(10,15);

                   collections.add(a1);

                   collections.add(a2);

                   collections.add(a3);

                   collections.add(a1);                  

                   System.out.println(collections.size());

        

         }

         public static void changeStringValue(Object obj)throws Exception{

                   Field[] fields = obj.getClass().getFields();

                   for(Field field : fields){

                            Class<?>  fieldType = field.getType();

                            String str = null;

                            if(fieldType == String.class){

                                     str = (String) field.get(obj);

                                     str = str.replace('b','a'); 

                                     field.set(obj,str);

                            }                                            

                   }       

         }

}

class ReflectPoint{

         private int x;

         public int y;

         public ReflectPoint(int x,int y) {

                   super();

                   this.x = x;

                   this.y = y;

         }

         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 String toString(){

                   return "坐标为:"+this.x+" "+this.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;

                   ReflectPoint other = (ReflectPoint) obj;

                   if (x != other.x)

                            return false;

                   if (y != other.y)

                            return false;

                   return true;

         }       

}

config.properties文件内容

className=java.util.HashSet

                   通过修改config.properties文件内容决定调用哪个类.

第十一节：用类加载器的方式管理资源和配置文件

1.        管理配置文件的几种方式:

package org.reflect4;

import java.io.*;

import java.lang.reflect.*;

import java.util.*;

public class ReflectDemo {

         public static void main(String[] args)throws Exception{

                   //第一种方式:这种方式不但可以读取,而且可以改变配置文件.

                   //InputStream fis = new FileInputStream("config.properties");

                   //第二种方式:关键是通过Class目录去找配置文件,但是这种方式不能更改保存配置文件

                   //InputStream fis =

                   //      ReflectDemo.class.getClassLoader().getResourceAsStream("org"+File.separator+"reflect4"+File.separator+"config.properties");

                   Properties p = new Properties();

                   //第三种方式:在src目录下建立一个包org.reflect4.resource,把配置文件放到这个包中,写上相对路径

                   //InputStream fis = ReflectDemo.class.getResourceAsStream("resource/config.properties");

                   //第四种方式:绝对路径

                   InputStream fis = ReflectDemo.class.getResourceAsStream("/org/reflect4/resource/config.properties");

                   p.load(fis);

                   String className = p.getProperty("className");

                   Class<?> c = Class.forName(className);

                   Collection collections = (Collection) c.newInstance();             

                   ReflectPoint a1 =new ReflectPoint(10,15);

                   ReflectPoint a2 =new ReflectPoint(5,5);

                   ReflectPoint a3 =new ReflectPoint(10,15);

                   collections.add(a1);

                   collections.add(a2);

                   collections.add(a3);

                   collections.add(a1);                  

                   System.out.println(collections.size());

        

         }

}

class ReflectPoint{

         private int x;

         public int y;

         public ReflectPoint(int x,int y) {

                   super();

                   this.x = x;

                   this.y = y;

         }

         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 String toString(){

                   return "坐标为:"+this.x+" "+this.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;

                   ReflectPoint other = (ReflectPoint) obj;

                   if (x != other.x)

                            return false;

                   if (y != other.y)

                            return false;

                   return true;

         }       

}

 

第十二节：由内省引出JavaBean的讲解

1.        概述

l  JavaBean是一种特殊的Java类,主要用于传递数据信息,这种java类中的方法主要用于访问私有的字段,且方法名符合某种命名规则.

l  如果要在两个模块之间传递多个信息,可以将这些信息封装到一个JavaBean中,这种JavaBean的实例对象通常称之为值对象(Value Object,简称VO).

l  一个符合JavaBenan特点的类可以当做普通类一样进行使用,但是把它当JavaBean使用肯定需要带来一些额外的好处,我们才会去了解和应用JavaBean.

        在Java EE开发中,经常要使用到JavaBean.很多环境就要求按JavaBean方式进行操作,别人都这么用和要求这么做,那么我们也没什么选择的余地.

        JDK中提供了对JavaBean进行操作的一些API,这套API就称为内省,如果要你自己去通过getX方法来访问私有的X,会有难度,用内省这套API操作JavaBean比用普通类的方式更方便.

l  IntroSpector(内省)àJavaBeanà特殊的JAVA类,具有规范的get,set方法.

l  标准bean

class Person{

   private String name;

   public void setName(String name){

       this.name = name;

}

public String getName(){

    return name;

}

}

l  属性 Ageà如果第二个字母是小写的,则把第一个字母变小写àage

第十三节：对JavaBean的简单内省操作

1.        简单内省操作(掌握)

package org.reflect4;

import java.beans.*;

import java.lang.reflect.*;

public class IntroSpector {

 

         private static PropertyDescriptor pd;

         public static void main(String[] args)throws Exception {

                   ReflectPoint rp1 = new ReflectPoint(3, 5);

                  

                   String propertyName ="x";

                   Object retVal = getProperty(rp1, propertyName);

                   System.out.println(retVal);

                  

                   Object value = 7;

                   setProperty(rp1, propertyName, value);

                   System.out.println(rp1.getX());

         }

         private static void setProperty(ReflectPoint rp1, String propertyName,

                            Object value) throws IntrospectionException,

                            IllegalAccessException, InvocationTargetException {

                   PropertyDescriptor pd2 = new PropertyDescriptor(propertyName, rp1.getClass());

                   Method metSetX = pd2.getWriteMethod();

                   metSetX.invoke(rp1, value);

         }

         private static Object getProperty(ReflectPoint rp1, String propertyName)

                            throws Exception {

                   pd = new PropertyDescriptor(propertyName, rp1.getClass());

                   Method metGetX = pd.getReadMethod();

                   Object retVal = metGetX.invoke(rp1);

                   return retVal;

         }

 

}

class ReflectPoint{

         private int x;

         private int y;

         public ReflectPoint(int x,int y) {

                   super();

                   this.x = x;

                   this.y = y;

         }

         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 String toString(){

                   return "坐标为:"+this.x+" "+this.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;

                   ReflectPoint other = (ReflectPoint) obj;

                   if (x != other.x)

                            return false;

                   if (y != other.y)

                            return false;

                   return true;

         }       

}

2.        复杂内省操作(了解,提高代码思路)

package org.reflect5;

import java.beans.*;

import java.lang.reflect.*;

public class IntroSpector {

         private static PropertyDescriptor pd;

         public static void main(String[] args)throws Exception {

                   ReflectPoint rp1 = new ReflectPoint(3, 5);     

                   String propertyName = "x";

                   Object retVal = getProperty(rp1, propertyName);

                   Object value = 7;

                   setProperty(rp1, propertyName, value);

         }

         private static void setProperty(ReflectPoint rp1, String propertyName,

                            Object value) throws IntrospectionException,

                            IllegalAccessException, InvocationTargetException {

                   /*

                   PropertyDescriptor pd2 = new PropertyDescriptor(propertyName, rp1.getClass());

                   Method metSetX = pd2.getWriteMethod();

                   metSetX.invoke(rp1, value);

                   */

                   BeanInfo bi = Introspector.getBeanInfo(rp1.getClass());

                   PropertyDescriptor[] pds = bi.getPropertyDescriptors();

                   for(PropertyDescriptor pd : pds){

                            if(pd.equals(propertyName)){

                                     Method met = pd.getWriteMethod();

                                     met.invoke(rp1, value);

                                     break;

                            }

                   }

                  

         }

         private static Object getProperty(ReflectPoint rp1, String propertyName)

                            throws Exception {

                   /*

                   pd = new PropertyDescriptor(propertyName, rp1.getClass());

                   Method metGetX = pd.getReadMethod();

                   Object retVal = metGetX.invoke(rp1);

                   */

                   BeanInfo bi = Introspector.getBeanInfo(rp1.getClass());

                   PropertyDescriptor[] pds = bi.getPropertyDescriptors();

                   Object retVal = null;

                   for(PropertyDescriptor pd : pds){

                            if(pds.equals(propertyName)){

                                     Method met = pd.getReadMethod();

                                     retVal = met.invoke(rp1);

                                     break;

                            }

                   }

                   return retVal;

         }

}

class ReflectPoint{

         private int x;

         private int y;

         public ReflectPoint(int x,int y) {

                   super();

                   this.x = x;

                   this.y = y;

         }

         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 String toString(){

                   return "坐标为:"+this.x+" "+this.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;

                   ReflectPoint other = (ReflectPoint) obj;

                   if (x != other.x)

                            return false;

                   if (y != other.y)

                            return false;

                   return true;

         }       

}

3.          

第十四节：对Beanutils工具包简单的掌握

1.        一般在项目下建一个lib文件夹,把需要的jar包copy到这个文件夹中,然后利用eclipse右键,选择BuildPath

2.        好处:

l  web服务器(Sting)àBeanUtils.setProperty()(String)àjava.value(int)

l  java.value(int)àBeanUtils.getProperty()(String)àweb服务器(String)

l  支持属性的级联操作

3.        PropertyUtils以属性本身进行操作,BeanUtils以String类型进行操作.