A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

代码可运行,但是不知道中间过程会不会有不到地方.

存在一个JavaBean,它包含以下几种可能的属性:
       1:boolean/Boolean
       2:int/Integer
       3:String
       4:double/Double
     属性名未知,现在要给这些属性设置默认值,以下是要求的默认值:
       String类型的默认值为字符串 www.itheima.com
       int/Integer类型的默认值为100
     boolean/Boolean类型的默认值为true
       double/Double的默认值为0.01D.
  只需要设置带有getXxx/isXxx/setXxx方法的属性,非JavaBean属性不设置,请用代码实现

  思路:
          1.首先设置好javaBean类.取名为MyJavaBean
          2.在类中设置好get,set方法.
          3.属性名未知,我可以通过反射获取到所有的字段,把它们放入一个字段数组里.
          4,通过遍历,获取到对应的类型和名称,然后再通过构造函数,通过对象然后设置该值.
                  1>通过遍历,然后再通过fi[x].getName() 获取到此时这个字段的名字.
                  2>有了字段的名字,就可以获取到对应的字段,然后通过暴力反射使其可以访问和设置.
                  3>再通过对象和要求的值set;
         
* */

public class Demo12 {
        public static void main(String[] args) throws Exception{
               
                Class clazz = Class.forName("cn.day11.testBean2");  //获取类的字节码.
                Object bean = clazz.newInstance();         //创建一个新实例.
               
                Field[] fi = clazz.getDeclaredFields();      //通过字节码获取到所有的Field对象,用数组接受.

               
                ForMethod(fi,clazz,bean);
                System.out.println(bean);
        }

        public static void ForMethod(Field[] fi,Class clazz,Object bean) throws Exception {
               
                for(int x = 0; x < fi.length; x ++)    //对Field对象数组进行遍历.
                {           
                        String s = fi[x].getType().toString();    //获取他们的字段类型,如果是包装就是类型全名
        //                System.out.println(s);
                       
                        String ss  = s.subSequence(s.lastIndexOf(".")+1, s.length()).toString();  //此处省略了判断.获取类型字符串

                        if(ss.equals("boolean") || ss.equals("Boolean"))  //用类型字符串进行比较.如果是这个类型,就添加相应的值.
                        {
                                Field fiel = clazz.getDeclaredField(fi[x].getName());  //fi[x]获取字段名字,返回的是一个字符串.
                                fiel.setAccessible(true);             //暴力请求.设置允许.
                                fiel.set(bean, true);
                        }
                        else if(ss.equals("String"))
                        {
                                Field fiel = clazz.getDeclaredField(fi[x].getName());
                                fiel.setAccessible(true);
                                fiel.set(bean, "www.itheima.com");
                        }
                        else if(ss.equals("int") || ss.equals("Integer"))
                        {
                                Field fiel = clazz.getDeclaredField(fi[x].getName());
                                fiel.setAccessible(true);
                                fiel.set(bean,100);
                        }
                        else if(ss.equals("double") ||ss.equals("Double"))
                        {
                                Field fiel = clazz.getDeclaredField(fi[x].getName());
                                fiel.setAccessible(true);
                                fiel.set(bean,0.01D);
                        }
                }
               
        }
}

class testBean2
{
        private boolean b;  
        private Integer i;
        private String str;  
        private double d;  
       
        public Boolean getB()
        {   
                return b;  
        }  
        public void setB(Boolean b)
        {   
                this.b = b;  
        }  
        public Integer getI()
        {   
                return i;
        }  
        public void setI(Integer i)
        {   this.i = i;  
        }  
        public String getStr()
        {  
                return str;  
        }  
        public void setStr(String str)
        {   
                this.str = str;  
        }  
        public Double getD()
        {   
                return d;  
        }
       
        public void setD(Double d)
        {   
                this.d = d;  
        }
        @Override
        public String toString() {
                return "MyJavaBean [boo=" + b + ", i=" + i + ", s=" + str + ", d=" + d
                                + "]";
        }

4 个回复

倒序浏览
  1. package com.itheima;

  2. import java.beans.BeanInfo;
  3. import java.beans.Introspector;
  4. import java.beans.PropertyDescriptor;

  5. public class Test7 {

  6.         /**
  7.          * 7、 存在一个JavaBean,它包含以下几种可能的属性:
  8.        1:boolean/Boolean
  9.        2:int/Integer
  10.        3:String
  11.        4:double/Double
  12.      属性名未知,现在要给这些属性设置默认值,以下是要求的默认值:
  13.        String类型的默认值为字符串 www.itheima.com
  14.        int/Integer类型的默认值为100
  15.      boolean/Boolean类型的默认值为true
  16.        double/Double的默认值为0.01D.
  17.   只需要设置带有getXxx/isXxx/setXxx方法的属性,非JavaBean属性不设置,请用代码实现

  18.          * @param args
  19.          *
  20.          *
  21.          * 思路:
  22.          * 由于属性名未知,所以可以通过内省的方式,并使用BeanInfo的getPropertyDescriptors()方法
  23.          * 获得所有javaBean属性,然后遍历,将指定类型的属性设置为默认值。
  24.          *
  25.          */
  26.         public static void main(String[] args)throws Exception {
  27.                
  28.                 //创建待设置的对象javaBean。
  29.                 JavaBean jb = new JavaBean();
  30.                
  31.                 //调用IntroSpector类的getBeanInfo()方法获得该类的BeanInfo对象。
  32.                 BeanInfo beaninfo = Introspector.getBeanInfo(jb.getClass());
  33.                
  34.                 //调用beaninfo对象的getPropertyDescriptors()方法得到该类的所有javaBean属性的数组。
  35.                 PropertyDescriptor[] pds = beaninfo.getPropertyDescriptors();
  36.                
  37.                 //遍历该数组,通过getPropertyType()方法判断属性类型,将指定类型的属性设置为默认值。
  38.                 for(PropertyDescriptor pd:pds)
  39.                 {
  40.                         if(pd.getPropertyType()==boolean.class)
  41.                         {
  42.                                 pd.getWriteMethod().invoke(jb, true);
  43.                         }
  44.                         if(pd.getPropertyType()==int.class)
  45.                         {
  46.                                 pd.getWriteMethod().invoke(jb, 100);
  47.                         }
  48.                        
  49.                        
  50.                         if(pd.getPropertyType()==String.class)
  51.                         {
  52.                                 pd.getWriteMethod().invoke(jb, "www.itheima.com");
  53.                         }
  54.                         if(pd.getPropertyType()==double.class)
  55.                         {
  56.                                 pd.getWriteMethod().invoke(jb, 0.01D);
  57.                         }
  58.                        
  59.                 }
  60.                
  61.                 //验证属性是否设置成功。
  62.                 System.out.println(jb.isFlag());
  63.                 System.out.println(jb.getN());
  64.                 System.out.println(jb.getStr());
  65.                 System.out.println(jb.getS());
  66.                 System.out.println(jb.getD());
  67.                 System.out.println(jb.method());
  68.        
  69.                
  70.         }

  71. }

  72.        
复制代码



这是我入学测试的时候做的,你可以参考一下。
回复 使用道具 举报
你可以看看我的代码。。。
回复 使用道具 举报
本帖最后由 Rain2692 于 2014-12-27 21:41 编辑
  1. /**
  2.          *第八题:
  3.          *存在一个JavaBean,它包含以下几种可能的属性:
  4.      * 1:boolean/Boolean
  5.      * 2:int/Integer
  6.      * 3:String
  7.      * 4:double/Double
  8.      *属性名未知,现在要给这些属性设置默认值,以下是要求的默认值:
  9.        String类型的默认值为字符串 www.itheima.com
  10.        int/Integer类型的默认值为100
  11.        boolean/Boolean类型的默认值为true
  12.        double/Double的默认值为0.01D.
  13.      *只需要设置带有getXxx/isXxx/setXxx方法的属性,非JavaBean属性不设置,请用代码实现
  14.          *
  15.          */
  16.         public static void main(String[] args) throws IntrospectionException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
  17.         
  18.                 JavaBeanTest pt = new JavaBeanTest();//创建对象
  19.         ArrayList<String> al = new ArrayList<String>();//创建集合为了存储成员变量的名字
  20.         ArrayList<Object>  Values = new ArrayList<>(); //创建集合,不施加泛型约束,为了存取将要赋的值
  21.         Values.add(true);//依次存入将要设置的默认值
  22.         Values.add(100);
  23.         Values.add("www.itheima.com");
  24.         Values.add(0.01D);
  25.         
  26.                 Field[] fd = pt.getClass().getDeclaredFields();//利用反射机制获取成员变量
  27.                
  28.                 for(Field f :fd)
  29.                 {
  30.                   if(!f.isAccessible())//暴力反射
  31.                        f.setAccessible(true);
  32.                         String s =f.getName().substring(0,1).toUpperCase()+f.getName().substring(1);//javaBean的函数设置规则,首字母大写,获取成员变量名
  33.                         al.add(s);//将转换后的成员变量名加入集合
  34.                 }
  35.                
  36.                 String PropertyName = null;
  37.                 Object value = null;
  38.                 //然后通过循环遍历,进行赋值操作
  39.                 for(int i=0;i<al.size();i++)
  40.                 {
  41.                         PropertyName = al.get(i);
  42.                         value = Values.get(i);        
  43.                    setProperties(pt, PropertyName, value);
  44.                 }
  45.                
  46.            //取值操作如下,打印出默认值来
  47.                 for(int i=0;i<al.size();i++)
  48.                 {
  49.                         PropertyName = al.get(i);
  50.                         System.out.println(PropertyName.toLowerCase()+": "+getProperty(pt, PropertyName));
  51.                 }
  52.                         
  53.         }

  54.         //抽取成一个方法 ,传值最后将处理后的值返回。
  55.         private static Object getProperty(Object pt, String PropertyName)
  56.                         throws IntrospectionException, IllegalAccessException,
  57.                         IllegalArgumentException, InvocationTargetException {
  58.                
  59.                 PropertyDescriptor pd = new PropertyDescriptor(PropertyName,pt.getClass());
  60.                 Method methodGetX = pd.getReadMethod();
  61.                 Object retVal = methodGetX.invoke(pt);
  62.                 return retVal;
  63.         }
  64.    //抽取成一个方法,传值进行处理设置默认值
  65.         private static void setProperties(Object pt, String PropertyName,
  66.                         Object value) throws IntrospectionException,
  67.                         IllegalAccessException, IllegalArgumentException,
  68.                         InvocationTargetException {
  69.                
  70.                 PropertyDescriptor pd = new PropertyDescriptor(PropertyName,pt.getClass());
  71.                 Method methodSetX = pd.getWriteMethod();
  72.                 methodSetX.invoke(pt, value);
  73.         }
复制代码
回复 使用道具 举报
  1. public class JavaBeanTest {
  2.         private Boolean bool = false;
  3.         private Integer integer = null;
  4.         private String str = null;
  5.         private double d = 0;
  6.        
  7.         public Boolean getBool() {
  8.                 return bool;
  9.         }
  10.         public Integer getInteger() {
  11.                 return integer;
  12.         }
  13.         public String getStr() {
  14.                 return str;
  15.         }
  16.         public double getD() {
  17.                 return d;
  18.         }
  19.         public void setBool(Boolean bool) {
  20.                 this.bool = bool;
  21.         }
  22.         public void setInteger(Integer integer) {
  23.                 this.integer = integer;
  24.         }
  25.         public void setStr(String str) {
  26.                 this.str = str;
  27.         }
  28.         public void setD(double d) {
  29.                 this.d = d;
  30.         }
  31.        
  32. }
复制代码
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马