黑马程序员_总结14-java基础加强1

  ----------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

第十四章 Java基础加强1

知识点：

一、静态导入

二、可变参数

三、增强for循环

四、基本数据类型的自动拆箱和装箱

五、枚举（Enum）

六、反射（reflect,不属于新特性）

七、内省（Introspector）与JavaBean类

------------------------------------------------------------------

一、静态导入

1、概述：

import语句可以导入一个类或某个包中的所有类；

import static语句导入一个类中的某个静态方法或所有静态方法，

使用静态导入可以使被导入类的静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。

2、语法举例：

import static java.lang.Math.min; 导入min（）方法

import static java.lang.Math.*; 导入Math类全部的静态方法

3、代码体现：

使用静态导入前：class Test {public static void main(String[] args) {System.out.println(Math.min(3, 6));}}使用静态导入后：import static java.lang.Math.min;class Test {public static void main(String[] args) {System.out.println(min(3, 6));}}

4、好处：通过静态导入，可以去掉类名的前缀，这样就简化了书写。

5、注意：

（1）过度地使用静态导入会在一定程度上降低代码的可读性。

（2）要注意不同类却同名的方法。比如静态导入了Arrays类和Collections类，

引用sort( )时Java不知道要引用哪个类的sort( )。

二、可变参数

1、可变参数：一个方法的参数，不是固定的，即参数是可变的。               

2、何时用：当参数的数据类型已确定，而参数个数不确定时，就可以使用可变参数。

3、可变参数的特点：

（1）...位于变量类型和变量名之间，前后有无空格都可以;
    （2）有多种类型的参数时，它只能出现在参数列表的最后

（3）调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，

在方法体中以数组的形式访问可变参数。

4、代码体现：

public static void main(String[] args)  {     System.out.println(add(2,3));     System.out.println(add(2,3,5));  }  public static int add(int x,int ... args)  {     int sum = x;      for(int i = 0; i < args.length; i++)      {         sum += args[i];      }     return sum;  }  

三、增强for循环

1、格式：

for（数据类型  变量名：集合/数组变量名）{...}

增强for循环，能对数组和实现了Iterator接口的集合类进行遍历。

2、好处：方便了数组和Collection集合的遍历，简化书写。

3、注意

（1）:增强for是用来替代迭代器的。

（2）不要在用增强for遍历集合的时候，用集合对集合本身进行修改。

4、代码体现：

import java.util.ArrayList;public class ForDemo {public static void main(String[] args) {// 数组int[] arr = { 1, 2, 3, 4, 5 };// 普通forfor (int x = 0; x < arr.length; x++) {System.out.println(arr[x]);}// 增强forfor (int x : arr) {System.out.println(x);}// 遍历集合ArrayList<String> al = new ArrayList<String>();al.add("hello");al.add("world");al.add("java");// 普通forfor (int x = 0; x < al.size(); x++) {String s = al.get(x);System.out.println(s);}// 迭代器Iterator<String> it = al.iterator();while (it.hasNext()) {String s = it.next();System.out.println(s);}// 增强forfor (String s : al) {System.out.println(s);}}}

四、基本数据类型的自动拆箱和装箱

1、概述

自动装箱和拆箱是由编译器帮助完成从基本数据类型和基本数据类型的包装类之间的转换。

基本数据类型：byte，short，int，long，double，float，boolean，char，

基本数据类型包装类：Byte，Short，Integer，Long，Double，Float，Boolean，Character，

2、自动装箱和拆箱的过程

（1）  自动装箱：自动把一个基本数据类型封装成Integer对象，再赋给了引用变量。

               Integeri = 100; //编译器自动编译成Integer i = newInteger(100);

       （2）自动拆箱：自动把一个引用类型变量拆箱成一个基本类型数据。

              i+= 100; //编译器自动通过i.intValue();把i转成int类型，再与100相加，最后把i装箱。

3、byte常量池和享元模式

       （1）把数据在1字节(-128 ~ 127)内的，缓存在一个池里，叫byte常量池；

byte范围内的值，是从常量池里面获取并直接赋值给Integer的。

不用重新创建出来，节省了内存空间。

       （2）享元模式：有很多个小的对象，他们有很多属性相同，把他们变成一个对象，

那些不同的属性，把它们变为方法的参数，称之为外部状态，那些相同的属性称之

为这个对象的内部状态。java中会事先将一些比较常用的数据都封装成一个对象，

当需要创建这些数据的对象类型时，直接将事先封装好的对象返回。

byte常量池就用了这个模式，把-128~127封装进常量池里，它们就成了同一个对象。

这样比较节约空间，多个引用共享一个对象，所以称为享元模式。

       （3）代码体现：

Integer i1 = 127;

Integer i2 = 127;Integer i3 = 128;

Integer i4 = 128;  System.out.println(i1==i2);//true  System.out.println(i3==i4);//false

（4）注意：

Integer i5 = new Integer(127);Integer i6= new Integer(127);int i7 = 127;System.out.println(i5 == i6);// false，重新new出来的对象，不是相同的System.out.println(i5 == i7);// true，因为与int类型比较前，i5自动拆箱啦，比较值

五、枚举（java.lang.enum）

1、Enum类

通过enum定义枚举类，在其中列出所有同类的元素常量值作为子类的实例对象使用。枚举类是一个特殊的类，每个元素都是该类的一个实例对象。当一个类的实例个数有限，并且固定，这时就可以用枚举。

2、枚举与接口的常量

接口中的是常量，而枚举用的是对象，并且提供相应的方法。

枚举：enum Week{ SUN，MON...SAT;}接口：interface week{        public static final int SUN =1;         public static final int MON =2;     ...........}

3、作用：

枚举就是让某个类型变量的取值只能为若干固定中的一个，否则编译器就会报错，

减少了运行时期的错误。枚举可以让编译器在编译时就可以控制源程序中填写非法的值，

而普通变量在开发中无法实现这也目标。

4、用普通类模拟枚举功能

需求：用枚举类规定WeekDay类的值。

调用该类时只能是这个类中规定好的那些值，否则编译器不会通过。

    思路：

（1）私有的构造方法

（2）每个元素分别用一个公有的静态成员变量表示

（3）有若干公有方法或抽象方法。采用抽象方法定义nextDay，

就将大量的if.else语句转移成了一个个独立的类。

（4）调用者想打印枚举类中元素的信息，需由编写此类的人定义toString方法。

代码体现：

public abstract class Weekday {//构造方法private Weekday(){}//定义元素常量, 通过匿名内部类实现nextDay()方法public static final Weekday Sun = new Weekday(){public Weekday nextDay(){ return Mon; }};…public static final Weekday Sta = new Weekday(){public Weekday nextDay(){ return Sun; } };//定义抽象的nextDay()方法，替代if…else做法public abstract Weekday nextDay();/*public Weekday nextDay(){if(this == Sun){ return Mon; }…else { return Sun; } }*///重写 toString()方法,供调用者打印元素信息public String toString() {if(this == Sun){ return "Sun"; }else if(this == Mon){ return "Mon"; }…else { return "Sta"; }}}

注意：

（1）若想在一个类中编写完每个枚举类和测试调用类，那么可将枚举类定义成调用类的内部类。

（2）枚举类是一个class，而且是一个不可被继承的final类，其中的元素都是类静态常量。

5、常用方法

（1）public final int ordinal( )：返回枚举常量的序数（在枚举声明中的位置，初始常量序数为零）。

（2）public String toString( )：返回枚举常量的名称，它包含在声明中。

（3）public final Class getClass( )：获取对应的类名

（4）public static values( )：获取数组，并将元素对象放入一个数组中。

（5）public static valueOf(String name)：返回带指定名称的指定枚举类型的枚举常量。

（即是将字符串转为类中对应的对象）

6、应用

（1）定义星期枚举类public enum Weekday{//定义元素对象，SUN(1), MON, TUE, WED, THI, FRI, SAT; //定义无参构造方法 private Weekday (){ System.out.println("first"); } //定义带参构造方法private Weekday (int x){ System.out.println("second"); } }（2）定义交通灯public enum TrafficLamp {// 定义红灯，等待时间后转为另一个灯绿灯RED(30) { public TrafficLamp nextLamp() { return GREEN; } },// 定义绿灯，等待时间后转为另一个灯黄灯GREEN(45) { public TrafficLamp nextLamp() { return YELLOW; } },// 定义黄灯，等待时间后转为另一个灯红灯YELLOW(5) { public TrafficLamp nextLamp() { return RED; } };//成员变量private int time;// 构造方法private TrafficLamp(int time) { this.time = time; }// 抽象方法，转灯public abstract TrafficLamp nextLamp(); }

7、注意事项

（1）元素列表即所有的元素项目，必须放在整个类的最前面。

（2）枚举元素列表的后要有分号与其他成员分隔

（3）构造方法必须定义成私有的 private

（4）在元素后跟上()，就可根据参数指定要使用的构造方法。

（5）枚举类中的每个元素都是它的一个子类对象，当枚举类中存在abstract方法，须在子类后加{}，并在其中实现此方法。

（6）类的方法返回的类型可以是类的类型，

（7）类中可定义静态常量，常量的结果就是自己这个类型的实例对象，

（8）如果枚举只有一个成员，就可以作为一种单例的实现方式，对象只有一个。

六、反射 (java.lang.reflect )不是1.5新特性

 1、反射机制的概述

java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。反射就是让你可以通过名称来得到对象(类，属性，方法)的技术。

2、反射机制的功能 

在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理；在运行状态下，通过class文件对象（class文件对象就是字节码文件对象，属于Class的对象），去使用构造方法，成员变量，成员方法；有利于后期扩展程序，提高灵活性。

3、Class类（java.lang.Class）

（1）Class类：是在Java语言中定义一个特定类的实现。一个类的定义包含成员变量，成员方法，

还有这个类实现的接口，以及这个类的父类。Class类的对象用于表示当前运行的 Java

应用程序中的类和接口。 比如：每个数组均属于一个 Class 类对象，所有具有相同元素类型

和维数的数组共享一个Class 对象。Class是Java程序中各个Java类的总称；它是反射的基石，通过Class类来使用反射。

（2）九个预定义的Class实例对象：基本的 Java 类型(boolean, byte, char, short, int, long, float

      和 double) 和 void 类型也可表示为 Class 对象。

              注意：A：基本类型的Class对象不同于包装类的：int.class ≠ Integer.class

              B：包装类名.TYPE等于对应基本类型的Class对象：int.class =Integer.TYPE

              C：总之，只要是在源程序中出现的类型，都有各自的Class实例对象

（3）数组的反射：具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；

非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

4、Class类的方法

*获取Class类的对象：public static ClassforName(String className)：返回与带有给定字符串名的类或接口相关联的 Class 对象。*获取构造方法：A：public Constructor getConstructor(数据类型的字节码文件对象)：返回一个 Constructor 对象，它反映此类的指定的公共构造方法。B：public Constructor[] getConstructors( )：返回一个Constructor 对象的数组，这些对象反映此类的所有公共构造方法。C：public Constructor getDeclaredConstructor(数据类型的字节码文件对象)：返回一个 Constructor 对象，该对象反映此类或接口的指定的构造方法。D：public Constructor[] getDeclaredConstructors( )：返回 Constructor 对象的一个数组，这些对象反映此类声明的所有构造方法。*获取成员变量：A：public Field getField(String name)：返回一个 Field 对象，它反映此类或接口的指定的公共成员字段。B：public Field[] getFields( )：返回一个Field 对象的数组，这些对象反映此类或接口的所有可访问的公共字段。C：public Field getDeclaredField(String name)：返回一个 Field 对象，该对象反映此类或接口的指定的已声明字段。D：public Field[] getDeclaredFields( )：返回 Field 对象的一个数组，这些对象反映此类或接口所声明的所有字段。*获取成员方法：A：public Method getMethod(String name，Types) name-方法名，Types-形参类型：返回一个 Method 对象，它反映此类或接口的指定的公共成员方法。B：public Method[] getMethods( )：返回一个Method 对象的数组，这些对象反映此类或接口的公共成员方法(包括父类)。C：public Method getDeclaredMethod(String name)：返回一个 Method 对象，该对象反映此类或接口的指定已声明方法。D：public Method[] getDeclaredMethods( )：返回 Method 对象的一个数组，这些对象反映此类或接口声明的所有方法(不包括父类)。*其它方法：A：public boolean isArray( )：判定此 Class 对象是否表示一个数组类。B：public boolean isPrimitive( )：判定指定的 Class 对象是否表示一个基本类型。C：public boolean isArray( )：判定此 Class 对象是否表示一个数组类。D：public String toString( )：将对象转换为字符串。E：public Object newInstance( )：创建此 Class 对象所表示的类的一个新实例。F：public ClassLoader getClassLoader( )：返回该类的类加载器。G：public InputStream  getResourceAsStream(String name)：查找具有给定名称的资源。

（4）获取class字节码文件对象的三种方式

              A：Object类的getClass（）方法

                      Person p = new Person（）;

                      Class c = p.getClass（）;

              B：数据类型的静态的class属性

                      Class c = Person.class;

              C：Class类forName（String className）静态方法

                      Class c = Class.forName（String className）; // className-包名+类名

              推荐：开发使用第三种（因为第三种方式可以结合配置文件使用）.

5、反射中的类

反射就是把Java类中的各种成分映射成相应的java类。 一个Java类用一个Class类的

对象来表示，这个类中的组成部分：构造方法，成员变量，方法等等信息，也用相应类的

实例对象来表示，分别是Contructor、Field、Method等。

6、Constructor构造方法类（java.lang.reflect.Constructor）

A：public Object  newInstance( )：使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例B：public void  setAccessible(boolean flag)：将此对象的 accessible 标志设置为指示的布尔值。值为true时取消Java语言访问检查(暴力访问)，为false时实施检查。C：public String  getName( )：以字符串形式返回此构造方法的名称。

7、Field成员变量类（java.lang.reflect.Field）

A：public void  setAccessible(boolean flag)：将此对象的 accessible 标志设置为指示的布尔值。值为true时取消Java语言访问检查(暴力访问)，为false时实施检查。B：public Object  get(Object obj)：返回指定对象上此 Field 表示的字段的值。如果该值是一个基本类型值，则自动将其包装在一个对象中。C：public String  getName( )：返回此 Field 对象表示的字段的名称。D：public Class getType( )：返回一个Class对象，它标识了此 Field 对象所表示字段的声明类型。E：public void  set(Object obj, Object value)：将指定对象变量上此Field对象表示的字段设置为指定的新值。Set( )方法需要对象的支持，可通过Class类newInstance()方法，在不获取构造方法的时候直接建立对象，

 但需要保证类中有public的空参数构造。代码：Object obj = clazz.newInstance(); field.set(obj, "新字段值");

8、Method成员方法类（java.lang.reflect.Method）

A：public void  setAccessible(boolean flag)：将此对象的 accessible 标志设置为指示的布尔值。值为true时取消Java语言访问检查(暴力访问)，为false时实施检查。B：public String  getName( )：返回此 Method对象表示的字段的名称。C：public Object  invoke(Object obj, Object... args)：对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。 代码：Method method = clazz.getMethod("add", Object.class); 方法名/形参类型method.invoke(array, true);  ArrayList对象/添加的元素 注意：如果method.invoke(null, true); 里的对象为空，说明方法是静态的。

9、应用            

       （1）通过反射获取构造方法并使用（Constructor）

A：无参构造：// 获取字节码文件对象   Class c = Class.forName（"cn.itcast.Person"）;// 获取构造器对象（无参）   Constructor con = c.getConstructor（）;// 通过构造器对象创建对象   Object obj = con.newInstance（）;B：带参构造：// 获取字节码文件对象   Class c = Class.forName（"cn.itcast.Person"）;// 获取构造器对象（带参）   Constructor con = c.getConstructor（String.class， int.class）;// 通过构造器对象创建对象   Object obj = con.newInstance（"小明"， 16）;

（2）通过反射获取成员变量并使用（Field）

A：公共的成员变量// 获取单个的成员变量   Field field = c.getField（"name"）;//给obj对象的field字段赋值为小华   field.set（obj， 小华）;B：私有的成员变量// 获取单个的成员变量   Field field = c.getDeclaredField（"name"）;//给obj对象的field字段赋值为"小华"//私有的成员变量，需暴力访问   field.setAccessible（true）;//暴力访问   field.set（obj， "小华"）;

（3）通过反射获取成员方法并使用（Method）

A：无参数无返回值的方法，无返回值用nullMethod m = c.getMethod（"方法名"， null）;m.invoke（obj， null）;B：带参数有返回值的方法Method m = c.getMethod（"方法名"， xxx.class，yyy.class）;Object obj = m.invoke（obj， "小明"，16）;C：私有方法的调用（需暴力访问），无返回值用nullMethod m = c.getDeclaredMethod（"hello"， null）;m.setAccessible（true）;m.invoke（obj， null）;

10、案例

              （1）通过反射修改成员变量的值，包括私有

import java.lang.reflect.Constructor;import java.lang.reflect.Field;public class ReflectDemo2 {public static void main（String[] args） throws Exception {// 获取字节码文件对象Class c = Class.forName（"cn.itcast.Person"）;// 创建对象Constructor con = c.getConstructor（）;Object obj = con.newInstance（）;// 获取年龄并赋值Field ageField = c.getField（"age"）;ageField.set（obj， 16）;// 获取姓名并赋值（私有的）Field nameField = c.getDeclaredField（"name"）;// 暴力访问私有成员，并赋值nameField.setAccessible（true）;nameField.set（obj， "小明"）;System.out.println（obj）;}}

（2）通过反射运行配置文件

                     配置文件的键有： className， methodName  键是固定的，已知的;值是变化的。

import java.io.FileReader;import java.lang.reflect.Constructor;import java.lang.reflect.Method;import java.util.Properties;public class Test {   public static void main（String[] args） throws Exception {//读取配置文件Properties prop = new Properties（）;FileReader fr = new FileReader（"test.properties"）;prop.load（fr）;fr.close（）;//获取类名String className = prop.getProperty（"className"）;//获取方法名String methodName = prop.getProperty（"methodName"）;//获取字节码文件对象Class c = Class.forName（className）;//创建对象Constructor con = c.getConstructor（）;Object obj = con.newInstance（）;//调用方法， 无返回值用nullMethod m = c.getMethod（methodName， null）;m.invoke（obj， null）;    }}

（3）通过反射，给ArrayList<Integer>中添加String类型的数据（ 反射可以越过泛型检查。）

import java.lang.reflect.Method;import java.util.ArrayList;public class ArrayListTest {    public static void main（String[] args） throws Exception {//创建集合对象ArrayList<Integer> array = new ArrayList<Integer>（）;// 获取字节码文件对象Class c = array.getClass（）;//调用ArrayList的add方法，添加Object类型（即任意类型）Method m = c.getMethod（"add"， Object.class）;//添加String数据m.invoke（array， "hello"）;System.out.println（array）;    }}

七、内省与JavaBean类（java.beans）

       1、内省(Introspector类)：是Java 语言对Bean类属性、事件的一种缺省处理方法。

2、JavaBean类：

是一种特殊的Java类，主要用于传递数据信息，这种类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。只要一个类中含有get和set打头的方法，就可以将其当做JavaBean使用。

3、JavaBean的作用：

如果要在两个模板之间传递多个信息，可将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO），这些信息在类中用私有字段来储存，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问。

4、JavaBean属性的命名方式

一个类被当作javaBean使用时，JavaBean根本看不到java类内部的成员变量。JavaBean的属性是根据其中的setter和getter方法来确定的，而不是依据其中的变量，如方法名为setId，则中文意思是设置id，如果方法名为getId，中文意思即为获取id。

去掉前缀，剩余部分就是属性名称，如果剩余部分的第二个字母小写，则把剩余部分改为小写。如：setAge→age；gettime→time； getCPU→CPU。

5、好处

JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。用内省这套api操作JavaBean比用普通类的方式更方便。

6、内省相关的类与方法

（1）Introspector类  public static BeanInfo getBeanInfo(Class<?> beanClass)：在 Java Bean 上进行内省，了解其所有属性、公开的方法和事件。（2）PropertyDescriptor类：描述 Java Bean 通过一对存储器方法导出的一个属性。  A：public  PropertyDescriptor(String propertyName,Class beanClass)：构造方法，通过字段名和类的字节码对象Class获取PropertyDescriptor  B：public Method  getReadMethod( )：获得应该用于读取属性值的方法。  C：public Method  getWriteMethod( )：获得应该用于写入属性值的方法。  D：public boolean  equals(Object obj)：将此 PropertyDescriptor 与指定对象进行比较。（3）BeanInfo接口  PropertyDescriptor[]  getPropertyDescriptors( )：获得受此 bean 支持的可编辑属性的 PropertyDescriptor 数组。

7、案例

              要求：通过内省访问ReflectPoint类，获取并修改它的私有属性

//定义ReflectPoint类public class ReflectPoint {//字段private int x;private int y;public ReflectPoint(int x, int y) { 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; }

}

（1）方法一：直接通过属性的描述器PropertyDescriptor类，来访问属性的getter/setter 方法

import java.beans.PropertyDescriptor;import java.lang.reflect.Method;public class IntrospectorTest {public static void main(String[] args) throws Exception {//创建ReflectPoint对象，并赋值ReflectPoint pt = new ReflectPoint(3, 5);//获取字段名String propertyName = "x";//构造public PropertyDescriptor(String propertyName,Class beanClass)PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt.getClass());//获取属性的值//public Method getReadMethod():获得应该用于读取属性值的方法。Method methodGetX = pd.getReadMethod();//public Object invoke(Object obj,Object...args):底层get方法无参数,直接获取Object retval = methodGetX.invoke(pt);System.out.println(retval);//设置属性的值//public Method getWriteMethod(): 获得应该用于写入属性值的方法。Method methodSetX = pd.getWriteMethod();//public Object invoke(Object obj,Object... args): 底层set方法设值methodSetX.invoke(pt, 7);//测试结果: x值已成功改为7System.out.println(pt.getX());}}

（2）方法二：通过BeanInfo来获取描述器PropertyDescriptor类，再访问属性方法

步骤：A：通过类Introspector来获取某个对象的 BeanInfo 信息，       B：然后通过 BeanInfo来获取属性的描述器（PropertyDescriptor）数组       C：通过这个属性描述器数组就可以获取某个属性对应的getter/setter方法       D：然后我们就可以通过反射机制来调用这些方法。import java.beans.BeanInfo;import java.beans.Introspector;import java.beans.PropertyDescriptor;import java.lang.reflect.Method;public class IntrospectorTest2 {public static void main(String[] args) throws Exception {//创建ReflectPoint对象，并赋值ReflectPoint pt = new ReflectPoint(3, 5);// 获取字段名String propertyName = "x";// 获取属性的值// public static BeanInfo getBeanInfo(Class beanClass)// 在 Java Bean 上进行内省，了解其所有属性、公开的方法和事件。BeanInfo beaninfo = Introspector.getBeanInfo(pt.getClass());// PropertyDescriptor[] getPropertyDescriptors()// 获取受此 bean 支持的可编辑属性的 PropertyDescriptor 数组。PropertyDescriptor[] pds = beaninfo.getPropertyDescriptors();for (PropertyDescriptor pd1 : pds) {//遍历属性数组,查找与propertyName字段同名的属性if (pd1.getName().equals(propertyName)) {Method methodGetX = pd1.getReadMethod();Object retval = methodGetX.invoke(pt);System.out.println(retval); //x值为3break;}}//构造public PropertyDescriptor(String propertyName,Class beanClass)PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt.getClass());//设置属性的值//public Method getWriteMethod():获得应该用于写入属性值的方法。Method methodSetX = pd.getWriteMethod();//public Object invoke(Object obj,Object...args):底层set方法设值methodSetX.invoke(pt, 7);// 测试结果: x值已成功改为7System.out.println(pt.getX()); //x值为7}}

  ----------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------