自动装箱和拆箱 枚举 反射 数组反射的应用。ArrayList和HashSet

 

[java]
view plaincopyprint?

/* 
eclipse的使用技巧。可变参数。基本数据类型自动装箱和拆箱。枚举。反射。数组反射的应用。ArrayList集合和HashSet集合。 
JavaBean。 
*/  
  
  
/*基础加强和JDK1.5新特性. 
 
    基础很重要,就业就看基础掌握的好不好. 
    但不能天天学基础,只有通过高级的应用,才能知道基础怎么用. 
    就像一年纪的题目,五年纪的人来做能拿满分. 
 
eclipse的使用技巧。 
    MyEclipse是eclipse的插件。可以处理j2ee. 
    eclipse用javaw.exe运行，不再是java.exe. 
 
    ide-->itegrity development environment （集成开发环境） 
 
    1）Workspace与project 
        必须要求：会切换工作间与导入项目。 
 
    IDE开发工具都支持使用工程化方式管理一个项目的程序开发过程。一般 
    来说一个相对独立的项目就是一个工程，一个项目中涉及的多个java文件，资源 
    文件等用一个工程进行管理。 
 
    点window-->点击Preferences-->Java-->Compiler(编译器)。有java版本。编译时版本。 
    Java->Installed JREs(java运行版本) 。运行时版本。 
 
    切换工作间：File->Switch Workspace.选择Others,OK后就新建。 
 
    新建一个工程，普通的java工程，New->Project->java Project->输入工程名字。这时可以选用jre版本。 
    在src上，可以选择新建class.会选择新建包名。良好的习惯应该有包名。 
 
    修改工程名字，-->Refactor(重构),新建立的工程配置环境可能改变，如快捷键。 
 
    配置快捷键。window-->Preferences->General-->Keys.输入content. 
    选择content Assist-->按下UnbindCommand(解除绑定)。在下面可以Binding，按下Alt键同时按其他。如/键。 
     
    2）View与调试debug 
    打个断点，程序上选择bebug  as run ，出来调试窗口-->选中变量，点右键->Watch. 
    想回去写程序，在右上角选择java视图。 
    Window->show view->other可以调试视图。 
 
    3）配置编译和运行java版本。 
    点window-->点击Preferences-->Java-->Compiler(编译器)。有java版本。编译时版本。 
    Java->Installed JREs(java运行版本) 。运行时版本。 
    用高版本的jdk编译出来的程序，用低版本不能运行。 
    高版本的jre可以运行低版本jdk编译出来的java程序。 
*/  
/* 
可变参数 
    特点:放在未尾。 
    三点...位于变量类型和变量名之间时，前后有无空格都可。 
    调用可变参数的方法时，编译器为该可变参数隐含创建一个 
    数组，在方法体中以数组的形式访问可变参数。 
    public static int getSun(int x,int ... args){ 
        int sum = x; 
        for(int i=0;i<args.length;i++){ 
            sum += args[i]; 
        } 
        return sum; 
    } 
    面试题。overload与override 的区别. 
 
 
 
基本数据类型的自动装箱和拆箱 
    自动装箱 
    Integer num = 12; 
    自动拆箱 
    System.out.println(num+10); 
 
    基本数据类型的对象缓存。 
    Integer num1 = 12; 
    Integer num2 = 12; 
    System.out.println(num1==num2);//true 
    //基本类型整数在(-128~127)之间，就不创建新对象，大于区间就创建。 
    //享元模式。 
    Integer num1 = 129; 
    Integer num2 = 129; 
    System.out.println(num1==num2);//false 
 
    Integer num1 = Integer.valueOf(12); 
    Integer num2 = Integer.valueOf(12); 
    System.out.println(num1==num2);//true，大于127同样false. 
*/  
/* 
枚举： 
    枚举的作用介绍。jdk1.5新特性。 
    枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个。否则， 
    编译器会报错。这个值在编译时期就被控制。 
*/  
  
public abstract class WeekDay1 {  
  
    /**普通类模拟枚举 
     * @param args 
     */  
    private WeekDay1(){};//让别人创建不了对象  
    public static final WeekDay1 SUN = new WeekDay1() {  
        @Override  
        public WeekDay1 nextDay() {  
            // TODO Auto-generated method stub  
            return MON;  
        }     
    };  
    public static final WeekDay1 MON = new WeekDay1() {  
        @Override  
        public WeekDay1 nextDay() {  
            // TODO Auto-generated method stub  
            return SUN;  
        }  
    };  
      
    /*public WeekDay nextDay(){//独立方法去写 
        if(this == SUN){ 
            return MON; 
        }else{ 
            return SUN; 
        } 
    }*/  
    public abstract WeekDay1 nextDay();//让别人实现它。  
      
    public String toString(){  
        return this == SUN?"SUN":"MON";  
    }  
}  
  
  
public class EnumTest {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        WeekDay1 weekDay = WeekDay1.MON;  
        System.out.println(weekDay.nextDay());  
          
        WeekDay weekDay2 = WeekDay.FRI;  
        System.out.println(weekDay2);  
        System.out.println(weekDay2.name());  
        System.out.println(weekDay2.ordinal());  
        System.out.println(WeekDay.valueOf("SUN").toString());  
        System.out.println(WeekDay.values().length);  
    }  
      
    public enum WeekDay {  
        SUN(1),MON,TUE,WED,THI,FRI,SAT;//分号，所有其他信息都必须列于元素列表之后。  
        private WeekDay() {//枚举的构造方法必须私有。  
            System.out.println("frist");  
        }  
        private WeekDay(int day) {  
            System.out.println("second");  
        }  
    }     
}  
/*枚举就是一个类，枚举的成员就是静态成员。 
    //所有其他信息都必须列于元素列表之后。 
    //枚举的构造方法必须私有。 
    //枚举的成员相当于一个类的实例对象。对象之间用,号隔开 
    SUN(1)相当于创建元素用哪个构造方法。 
    SUN，SUN():调用空的。 
 
    实现带抽象方法的枚举. 
 
    如果枚举只有一个成员，那可以了解为单例设计模式。 
 
*/  
  
    public enum TrafficLamp {  
        RED(30){  
  
            @Override  
            public TrafficLamp nextLamp() {  
                // TODO Auto-generated method stub  
                return GREEN;  
            }  
        }，  
        GREEN(45){  
  
            @Override  
            public TrafficLamp nextLamp() {  
                // TODO Auto-generated method stub  
                return YELLOW;  
            }}，  
        YELLOW(5){  
  
            @Override  
            public TrafficLamp nextLamp() {  
                // TODO Auto-generated method stub  
                return RED;  
            }  
        }，  
        public abstract TrafficLamp nextLamp();//抽象方法，那么每个成员都要实现。  
        private int time;  
        private TrafficLamp(int time){this.time = time;}  
    }  
  
/*反射的基石->Class类 jdk1.2 
Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class. 
    对比。众多的人用一个什么类表示？众多的Java类用一个什么类表示。 
    人——>Person       Person p1 = new Person();Person p2 = new Person(); 
    java类-->Class    Class cls1 = ?;没有构造方法，或方法是私有的，不能直接new. 
如何得到各个字节码对应的实例对象(Class类型) 
    内存中的每份字节码，就是对应的实例对象。通过对象拿字节码。p1.getClass(); 
    还有一个方法得到类的字节码，Class类的静态方法:Class.forName("java.lang.String"); 
如何得到各个字节码对应的实例对象(Class类型) 
三种：类名.class,如：System.class 
    对象.getClass()如:new Date().getClass(); 
    Class.forName("类名"),如:Class.forName("java.util.Date"); 
反射主要用第三种，因为在写程序时还不知道类的名字. 
 
九个预定义Class实例对象。 
八个基本类型:boolean,byte,char,short,int,long,float,double. 
还有一个void. 
    int.class.isPrimitive();//是否是原始类型。 
    int.class = Integer.TYPE; 
    Integer.TYPE;代表基本类型。 
    注意：int.class == Integer.class;//不是一个。 
 
    数组类型的实例变量 
    int[].class.isPerimitive();//不是 
    Class.isArray();//判断是否是数组。字节码。isArray(); 
 
    总之：只要在源程序中出现的类型，都有各自的Class实例对象。例如:int[]... 
    public static void main(String[] args) { 
        // TODO Auto-generated method stub 
        System.out.println(int.class == Integer.class);//不相等 
        System.out.println(int.class == Integer.TYPE);//相等 
        System.out.println(int[].class.isPrimitive());//不是原始 
        System.out.println(int[].class.isArray());//是数组 
    } 
*/  
/* 
反射：总之：反射就是把Java类中的各种成分映射成相应的java类。 
 
Constructor 类(构造函数的反射) 
     
    得到某个类中的所有的构造方法。 
    例子;ConStructor [] cons = Class.forName("java.lang.String").getConstructors(); 
    得到某一个构造方法： 
    ConStructor constructor1 = Class.forName("java.lang.String").getConstructor(StringBuffered.class); 
    拿到构造方法后，就可以去构造一个实例对象。 
    String str2 = (String)constructor1.newInstance(new StringBuffer("abc")); 
    //程序编译时不知道是哪个构造方法的，只有运行时才知道。(String). 
    //获得方法时要用到类型.class,使用方法时要用到相应类型的对象。 
        clazz.newInstance(),运行空构造方法，得到一对象。 
 
        Class clazz = Class.forName("java.lang.String");//拿字节码 
        Constructor con = clazz.getConstructor(StringBuffer.class);//拿某一个构造函数 
        String str = (String)con.newInstance(new StringBuffer("abc"));//要传对应的sb,不能是("abc") 
        System.out.println(str); 
*/  
  
import java.lang.reflect.Constructor;  
public class RefPointDemo {  
    public static void main(String[] args) throws Exception {  
        // TODO Auto-generated method stub  
        /*暴力反射私有的构造函数*/  
        Class clazz = new RefPoint().getClass();  
        Constructor con = clazz.getDeclaredConstructor(int.class,int.class);//Declared是所有的，包括私有。  
        con.setAccessible(true);//设为可使用。  
        RefPoint refpoint = (RefPoint)con.newInstance(5,6);  
        System.out.println(refpoint);  
    }  
}  
 class RefPoint {  
  
    public static int x ;  
    private static int y;  
    public RefPoint(){}  
    private RefPoint(int x, int y) {  
        super();  
        this.x = x;  
        this.y = y;  
    }  
    public String toString()  
    {  
        return "x:"+x+",y:"+y;  
    }  
}  
/* 
Field类:(成员变量的反射) 
    main()...{ 
        RefPoint ref1 = new RefPoint(3,5); 
        Class clazz = ref1.getClass(); 
        Field fi = clazz.getDeclaredField("y");//私有的成员y就要用这个方法。 
        fi.setAccessible(true);//私有的成员y必须为可见 
        int yy =(Integer)fi.get(ref1);//这里才具体到哪个对象一个值 
        System.out.println(yy); 
    } 
*/  
  
import java.lang.reflect.Field;  
//将任意一个对象中的所有String类型的成员变量所对应字符串内容中的"b"改成"a"。  
public class RefFileTest {  
    public static void main(String[] args) throws Exception {  
        StringSSS sss = new StringSSS();  
        show(sss);  
        System.out.println(sss);  
    }  
    public static void show(Object obj) throws Exception{  
        Class clazz = obj.getClass();  
        Field[] field = clazz.getDeclaredFields();  
        for(Field fi:field){  
            if(fi.getType()==String.class){//获取成员的类型，同一个类型判断用==.  
                String oldstr = (String)fi.get(obj);//如果是String,就传入对象，拿到具体的值  
                String newstr = oldstr.replace('b', 'a');//替换b->a.  
                fi.set(obj,newstr);//再设置到原对象上。  
            }  
        }  
    }  
}  
class StringSSS{  
    public String str1 = "ball";  
    public static  String str2 = "baskball";//静态可以被修改，final修饰后常量不可以。  
    public String str3 = "itcast";  
    public String toString(){  
        return "Str1:"+str1+",Str2:"+str2+",Str3:"+str3;  
    }  
}  
/*以前老师不是讲String一初始化，值就不可以改变吗？ 
使用反射，没有改变引用地址，也可以改变它的值？？？*/  
  
/* 
Method类。 
    代表某一类中的成员方法。 
    invoke(str1,1)，如果str1为null,那么为静态方法，不需要对象来调用的。 
    Method methodChatAt = String.class.getMethod("chatAt",int.class); 
    因为一个类中的方法有很多，得到具体的方法用到（方法名，XX），而这个方法有可能被重载， 
    所以要用到参数列表的字节码，综合就是(方法名，参数.class);就是得到具体哪个方法。 
    再调用这个方法。methodChatAt.invoke(str1,1);str1表示作用的某个对象。 
*/  
    public static void main(String[] args) throws Exception {  
        // TODO Auto-generated method stub  
        String str = "abc";  
        Method method = String.class.getMethod("charAt",int.class);//拿到某个方法  
        Character ch = (Character)method.invoke(str, 1);//这里可以是(Character),不可以是char???返回的Object不能转变char？  
        System.out.println(method.invoke(str, 1));//str表示作用的某个对象,为null时表示为静态方法。不需要对象调用。  
        System.out.println(ch+".....");//1.4版本前，invoke(str, 1))写为invoke(str, new Object[]{1}).传入Object数组  
    }  
      
/*练习，自己写程序，调用人家的main()方法,用反射方式。 
    为什么要用反射的方式去调？ 
    写程序时不知道要执行哪个类的，传入参数才知道要调用哪个。  
 
    1.5因为兼容1.4，所以传入（null,new String("111","333","222")）这时会打开数组，参数就不对了 
    应该改成（null,new Object[]{(new String[]{"111","333","222"})}）,先打好包，解开后还是我想要传的. 
    还可以这样做，直接告诉编译器，我就是传给了你一个对象。（null,(Object)new String[]{"111","333","222"}） 
    告诉它不要拆了。 
*/  
  
public class MethodDemo {  
  
    public static void main(String[] args) throws Exception {     
        //new MethodSSS().main(new String[]{"111","222","333"});//没用反射，我们一般都是这样调用，  
          
        //使用反射怎么调用呢？通过参数传入我想要运行哪个类的主函数。  
        Method startMethod = Class.forName(args[0]).getMethod("main", String[].class);  
        startMethod.invoke(null,(Object)new String[]{"111","222","333"});//数组参数这里要打包。  
      
    }  
}  
class MethodSSS{  
    public static void main(String[] args){  
        for(int x=0;x<args.length;x++){  
            System.out.println(args[x]);  
        }  
    }  
}  
  
/* 
数组的反射, 
    具有相同的元素类型的同维数组的字节码是同一个。可以相等==. 
 
    基本数据类型不是Object.所以在Arrays.asList()时，基本数据类型转换时，是将整个 
    数组转换成的，因为一个基本数据类型，不能转换成Object.如int 
 
    调用Arrays.asList()时，高版本满足低版本，所以jdk1.4时，asList(Object[] obj),参数，不符合 
    就返回用1.5方法，变成可变参数asList(T...a); 
 
*/  main(){  
        int[] a1 = new int[3];  
        int[] a2 = new int[4];  
        String[] a3 = new String[]{"1","2","3"};  
        int[][] a4 = new int[3][4];  
          
        System.out.println(a1.getClass()==a2.getClass());//true  
        //System.out.println(a1.getClass()==a3.getClass());//错误  
        //System.out.println(a1.getClass()==a4.getClass());//错误  
        System.out.println(a1.getClass().getName());//[I  
        System.out.println(a1.getClass().getSuperclass().getName());//java.lang.Object  
        System.out.println(a3.getClass().getSuperclass().getName());//java.lang.Object  
          
        Object ab1 = a1;  
        Object ab2 = a3;  
        Object ab3 = a4;  
        Object[] ab4 = a1;//只有这个提示报错，说明int不能转成Object  
        Object[] ab6 = a3;  
        Object[] ab5 = a4;  
        System.out.println(Arrays.asList(a1));//[[I@15ff48b]  
        System.out.println(Arrays.asList(a3));//{1,2,3}  
    }  
  
//数组反射的应用。  
    main(){  
        //printObj(a3+"...");  
        printObj(a3);//这样可以打印  
        printObj("xyz");  
          
    }  
    public static void printObj(Object obj){  
        Class clazz = obj.getClass();  
        if(clazz.isArray()){//拿到字节码判断是不是数组  
            int len = Array.getLength(obj);//拿到数组长度  
            for(int x=0;x<len;x++){  
                System.out.println(Array.get(obj, x));//[Ljava.lang.String;@affc70...为什么我的打不出来？？？  
                                                        //因为我在上面加了...,printObj(a3+"...");  
            }  
        }else{  
            System.out.println(obj);  
        }  
    }  
  
/* 
    ArrayList集合和HashSet集合，HashCode()分析。 
    ArrayList集合，是有顺序的，判断相同与否的依据是:对象的equals()方法，默认比较的是地址值，要想相等，就要重写equals()方法。 
    HashSet集合：是无序的，判断的依据是Hashcode(),相同再比较equals(). 
 
    HashCode()值，让具备HashCode存储的对象，在内在中对应相应的Hash区域。 
    当HashCode依据的算法存储进内存后，就不要修改算法依据的相应的值了。 
    因为一改了之后，HashCode()的值也会改变。会内存泄露。 
    内存泄露：对象使用后，没有被释放。 
    父类引用Collection 分别建立ArrayList,HashSet子类对象,比较它的区别。如元素的大小。 
    复写各方法，可发现不同。 
*/  
  
/* 
    反射的作用->实现框架功能。 
    前面已经小小使用一回了，就是输入名字，运行它的主函数。 
 
    框架要解决的核心问题。 
    因为在写程序时无法知道要被调用的类名，所以在程序中无法直接用new某个类的实例对象了。 
    要用反射方式来做。 
*/  
public class RefTest {  
  
    /**利用反射实现一个小框架， 
     * 在一个文件中写入内容。config.txt,className = java.util.ArrayList  
     * @getRealPath();javaweb开发时，可以得到文件的路径。实际开发一定要完整的路径。InputStream("config.txt"); 
     */  
    public static void main(String[] args) throws Exception {  
        // TODO Auto-generated method stub  
        InputStream ips = new FileInputStream("config.txt");//读取文件,实际开发要用到绝对路径  
        Properties prop = new Properties();  
        prop.load(ips);//文件载入内存  
        ips.close();  
        String className = prop.getProperty("className");//得到文件名字  
        Class clazz = Class.forName(className);  
        //Constructor con = clazz.getConstructor();//得到构造函数  
        //Collection coll = (Collection)con.newInstance();//创建对象  
        Collection coll = (Collection)clazz.newInstance();//空的构造方法直接这样。  
    }  
}  
/* 
用类加载器的方式管理资源和配置文件。 
原理：程序要运行，要加载.class文件，用什么加载这个文件呢？那就是类加载器， 
它能够加载.class文件，为什么就不能加载普通文件呢？肯定能。 
实例对象.getClass().getClassLoader().getResourceAsStream(cn/itcast/day1/config.txt);注意cn前不加/ 
文件在src目录下的。java文件，一保存eclipse就会自动编译到bin目录下去，非.java会拷贝过去。 
.getResourceAsStream()这个方法只读，又读又写，还是用上面那种。InputStream ips = new FileInputStream("config.txt")。 
 
.getClass().getClassLoader().getResourceAsStream()这种方法加载麻烦，那么.class有没有直接加载的方法呢？ 
.getClass().getResourceAsStream("resources/文件名")相对路径，当最前面有/时,要用绝对路径，这是用字节码的简单直接方法 
加载文件，实际上还是用的类加载器加载实现的。 
*/  
/* 
由内省引出的JavaBean的讲解。 
    内省->IntroSpector.-->主要用于对JavaBean进行操作 
    什么是JavaBean,特殊的java类，方法按特殊的规定起名。 
    例如有个age属性，有方法 int getAge(); void setAge(int age). 
    JavaBean也是一个java类，可以进行java类的所有普通操作。 
    1.int getAge();没有参数，返回值是int 
    2.void setAge(int age)。有参数，返回值是void 
    有这二个条件就可以当作JavaBean操作了 
*/  
class Person  
{  
    private int x;  
    public int getAge()//public  
    {  
        return x;  
    }  
    public void setAge(int age)  
    {  
        this.x = age;  
    }  
}  
/* 
上面的Person类当作普通的java类来看，有一个x的成员属性。 
Person类当作一个JavaBean 来看，有一个Age属性。 
Age-->age如果第二个字母是小的，把第一个字母变成小的。 
gettime-->time; 
settime-->time 
getCPU-->CPU，为了整洁。不是cPU 
 
当JavaBean处理，可以更方便，简单。 
    在Java EE开发中，很多环境就要求按照JavaBean方式进行操作。 
    JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。 
*/  
  
import java.beans.IntrospectionException;  
import java.beans.PropertyDescriptor;  
import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
//对javabean的简单操作，获取属性。  
public class JavaBeanDemo {  
  
    public static void main(String[] args) throws Exception {  
        Point p1 = new Point(3,5);  
          
        String propertyName = "x";  
        //普通方式:"x"->"X"->"getX"->MethodGetX-->x获取过程麻烦  
          
        //1.得到名称为propertyName的内省。  
        Object retVal = getProperty(p1, propertyName);//这里用了方法抽取  
        System.out.println(retVal);  
          
        Object obj = 7;  
          
        setProperty(p1, propertyName, obj);  
           
         //Object retVal2 = methodGetX.invoke(p1);  
           
         System.out.println(p1.getX());//当作普通类来获取  
        //System.out.println(retVal2);  
    }  
  
    private static void setProperty(Object p1, String propertyName, Object obj)  
            throws Exception{  
        PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,//这是名称  
                p1.getClass());//  
        Method methodSetX = pd2.getWriteMethod();  
         methodSetX.invoke(p1, obj);  
    }  
  
    private static Object getProperty(Object p1, String propertyName)  
            throws Exception {  
        PropertyDescriptor pd = new PropertyDescriptor(propertyName,//这是名称  
                p1.getClass());//得到javaBean属性，得到哪个对象的内省。  
          
        //2.下面就可以得到它的读的方法。  
        Method methodGetX = pd.getReadMethod();//这里就是得到x的方法。  
          
        //3.应用在哪个对象上，没有参数后面就不写.第2，3步就是反射。  
        Object retVal = methodGetX.invoke(p1);  
        return retVal;//简单方法  
    }  
}  
class Point{  
    Point(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;  
    }  
    private int x;  
    private int y;  
}  
  
/*下面这个内省的复杂方法。为什么要看？程序设计中经常用这种思想。 
在程序中把一个类当作JavaBean来看，就是调用IntroSpector.getBeanInfo方法， 
得到的是Beaninfo对象封装了把这个类当作javaBean看的结果信息。 
*/  private static Object getProperty(XY xy, String name)  
            throws IntrospectionException, IllegalAccessException,  
            InvocationTargetException {  
        /* 
         * PropertyDescriptor pd = new PropertyDescriptor(name,xy.getClass()); 
         
        Method methodGetX = pd.getReadMethod(); 
        Object retVal = methodGetX.invoke(xy); 
        return retVal//;简单方法 
        */  
        BeanInfo bfs = Introspector.getBeanInfo(xy.getClass());//记住这个Introspector类名  
        PropertyDescriptor[] pds = bfs.getPropertyDescriptors();//所有属性信息  
        Object retVal = null;  
        for(PropertyDescriptor pd:pds){  
            if(pd.getName().equals(name)){//名字相同，找到了。  
                Method methodGetX = pd.getReadMethod();  
                retVal = methodGetX.invoke(xy);  
            }  
        }  
        return retVal;//复杂方法  
    }  
  
    /* 
    使用工具操作javaBean 
先去网上下载工具包JavaBean包，解压。 
 
然后把工具包的.jar文件，加到我们的java工程中来。 
局限方法：右击工程名，Build Path-->Configure Build Path-->Libraries->Add  External JARS. 
这种方法不会随着工程转换。换了电脑就运行不了。 
 
下面这种方法是放到工程里面转移。 
在工程下建立一个目录，lib文件夹，然后把刚才的.jar拷贝进来lib。 
然后选择.jar文件，Build Path-->Add to Build Path.前面的图标会变成小奶瓶。 
 
Utils怎么应用呢？ 
里面有静态方法。 
BeanUtils.getProperty(pt1,"x");会有错。没有日志包。 
把日志包的.jar也增加到Build Path.再运行。就可以了。 
set,get这里都是用字符串操作的，因为web上的数据都是用字符串传送的。 
 
对比另外一个类的静态方法，就是用int操作。如下。 
PropertyUtils.setProperty(pt1,"x",9),这个是用属性本身的类型进行操作。 
 
javaBean 可以和Map相互转换。Utils工具有这样的方法。 
 
java7里面，map对象可以这样定义。 
Map map = (name:"zxx",age:18); 
 
 
*/  

android培训、java培训、期待与您交流！