精华内容
下载资源
问答
  • Java 动态类添加属性

    千次阅读 2019-10-11 09:28:37
    “衰兰送客咸阳道,天若有情天亦老” 序 有一个这样的功能:展示一个报表,表头是动态的,可以手动新增或删除,也就是说会修改表结构,...但是这里说说实体类动态添加属性。 实现代码 import com.google.common...

    “衰兰送客咸阳道,天若有情天亦老”

    有一个这样的功能:展示一个报表,表头是动态的,可以手动新增或删除,也就是说会修改表结构,新增或删除表字段。然而一般实体类都是对应表结构的,那么如何给实体增加属性呢?虽然我自己的解决方案是直接返回List<map>,然后让对应的列适配到map的key中。但是这里说说给实体类动态添加属性。

    实现代码

    
    import com.google.common.collect.Maps;
    import net.sf.cglib.beans.BeanGenerator;
    import net.sf.cglib.beans.BeanMap;
    import org.apache.commons.beanutils.PropertyUtilsBean;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     *@author 
     *@date 2019/10/9
     *@description
     */
    public class ReflectUtil {
    
        static Logger logger = LoggerFactory.getLogger(ReflectUtil.class);
    
        public static Object getTarget(Object dest, Map<String, Object> addProperties) {
            // get property map
            PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
            PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(dest);
            Map<String, Class> propertyMap = Maps.newHashMap();
            for (PropertyDescriptor d : descriptors) {
                if (!"class".equalsIgnoreCase(d.getName())) {
                    propertyMap.put(d.getName(), d.getPropertyType());
                }
            }
            // add extra properties
            for (Map.Entry<String, Object> entry : addProperties.entrySet()) {
                propertyMap.put(entry.getKey(), entry.getValue().getClass());
            }
    //        addProperties.forEach((k, v) -> propertyMap.put(k, v.getClass()));
            // new dynamic bean
            DynamicBean dynamicBean = new DynamicBean(dest.getClass(), propertyMap);
            // add old value
            for (Map.Entry<String, Class> entry : propertyMap.entrySet()) {
                try {
                    // filter extra properties
                    if (!addProperties.containsKey(entry.getKey())) {
                        dynamicBean.setValue(entry.getKey(), propertyUtilsBean.getNestedProperty(dest, entry.getKey()));
                    }
                } catch (Exception e) {
                    logger.error(e.getMessage(), e);
                }
            }
            ;
            // add extra value
            for (Map.Entry<String, Object> entry : addProperties.entrySet()) {
                try {
                    dynamicBean.setValue(entry.getKey(), entry.getValue());
                } catch (Exception e) {
                    logger.error(e.getMessage(), e);
                }
            }
            ;
            Object target = dynamicBean.getTarget();
            return target;
        }
    
        public static class DynamicBean {
            /**
             * 目标对象
             */
            private Object target;
    
            /**
             * 属性集合
             */
            private BeanMap beanMap;
    
            public DynamicBean(Class superclass, Map<String, Class> propertyMap) {
                this.target = generateBean(superclass, propertyMap);
                this.beanMap = BeanMap.create(this.target);
            }
    
    
            /**
             * bean 添加属性和值
             *
             * @param property
             * @param value
             */
            public void setValue(String property, Object value) {
                beanMap.put(property, value);
            }
    
            /**
             * 获取属性值
             *
             * @param property
             * @return
             */
            public Object getValue(String property) {
                return beanMap.get(property);
            }
    
            /**
             * 获取对象
             *
             * @return
             */
            public Object getTarget() {
                return this.target;
            }
    
    
            /**
             * 根据属性生成对象
             *
             * @param superclass
             * @param propertyMap
             * @return
             */
            private Object generateBean(Class superclass, Map<String, Class> propertyMap) {
                BeanGenerator generator = new BeanGenerator();
                if (null != superclass) {
                    generator.setSuperclass(superclass);
                }
                BeanGenerator.addProperties(generator, propertyMap);
                return generator.create();
            }
        }
    
        public static void main(String[] args) {
            TestClass entity = new TestClass();
            entity.setAge(15);
            entity.setId(1);
            entity.setName("张三");
            //动态设置属性字段
            Map<String, Object> addProperties = new HashMap() {{
                put("sex", "男");
                put("telephone", "123456789");
            }};
            //获取实体中给属性的值
            Object target = getTarget(entity, addProperties);
            System.out.println(getFieldValueByName("id", target));
            System.out.println(getFieldValueByName("name", target));
            System.out.println(getFieldValueByName("age", target));
            System.out.println(getFieldValueByName("sex", target));
            System.out.println(getFieldValueByName("telephone", target));
        }
    
        //获取实体中属性的值
        private static Object getFieldValueByName(String fieldName, Object o) {
            try {
                //通过反射获取值
                String firstLetter = fieldName.substring(0, 1).toUpperCase();
                String getter = "get" + firstLetter + fieldName.substring(1);
                Method method = o.getClass().getMethod(getter, new Class[]{});
                Object value = method.invoke(o, new Object[]{});
                return value;
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
                return null;
            }
        }
    
        //测试类
        public static class TestClass{
            //ID
            private int id;
            //名字
            private String name;
            //年龄
            private int age;
    
            public int getId() {
                return id;
            }
    
            public void setId(int id) {
                this.id = id;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public int getAge() {
                return age;
            }
    
            public void setAge(int age) {
                this.age = age;
            }
        }
    
    }
    
    

    结果:
    在这里插入图片描述
    本文参考至:JAVA“动态”为类添加属性

    展开全文
  • java动态给实体类添加属性

    千次阅读 2020-04-10 11:01:19
    java动态给实体类添加属性 需要的jar包有两个:cglib-3.1.jar 和 google-collections-1.0.jar 如果是maven项目,就不需要cglib-3.1.jar,直接用spring自带的 org.springframework.cglib即可。 1、创建一个实体:...

    java动态给实体类添加属性


    需要的jar包有两个: cglib-3.1.jargoogle-collections-1.0.jar
    如果是maven项目,就不需要cglib-3.1.jar,直接用spring自带的 org.springframework.cglib即可。
    1、创建一个实体:DynamicBean

    public class DynamicBean {
    
        private Object target;
        private BeanMap beanMap;
    
        public DynamicBean(Class superclass, Map<String, Class> propertyMap) {
            this.target = generateBean(superclass, propertyMap);
            this.beanMap = BeanMap.create(this.target);
        }
    
        public void setValue(String property, Object value) {
            beanMap.put(property, value);
        }
    
        public Object getValue(String property) {
            return beanMap.get(property);
        }
    
        public Object getTarget() {
            return this.target;
        }
        /**
         * 根据属性生成对象
         *
         */
        private Object generateBean(Class superclass, Map<String, Class> propertyMap) {
            BeanGenerator generator = new BeanGenerator();
            if (null != superclass) {
                generator.setSuperclass(superclass);
            }
            BeanGenerator.addProperties(generator, propertyMap);
            return generator.create();
        }
    }
    
    

    2、创建映射类,用来生成动态bean

    public class ReflectUtil {
    	private static Logger logger = LoggerFactory.getLogger(ReflectUtil.class);
    	
    	public static Object getObject(Object dest, Map<String, Object> addProperties) {
    	    PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
    	    PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(dest);
    	    Map<String, Class> propertyMap = Maps.newHashMap();
    	    for (PropertyDescriptor d : descriptors) {
    	        if (!"class".equalsIgnoreCase(d.getName())) {
    	            propertyMap.put(d.getName(), d.getPropertyType());
    	        }
    	    }
    	    addProperties.forEach((k, v) -> {
    	    	String sclass = v.getClass().toString();
    	    	if(sclass.equals("class java.util.Date")) {//对日期进行处理
    	    		propertyMap.put(k, Long.class);
    	    	}else {
    	    		propertyMap.put(k, v.getClass());
    	    	}
    	    	
    	    });
    	    DynamicBean dynamicBean = new DynamicBean(dest.getClass(), propertyMap);
    	    propertyMap.forEach((k, v) -> {
    	        try {
    	            if (!addProperties.containsKey(k)) {
    	                dynamicBean.setValue(k, propertyUtilsBean.getNestedProperty(dest, k));
    	            }
    	        } catch (Exception e) {
    	            logger.error("动态添加字段出错", e);
    	        }
    	    });
    	    addProperties.forEach((k, v) -> {
    	        try {
    	        	String sclass = v.getClass().toString();
    		    	if(sclass.equals("class java.util.Date")) {//动态添加的字段为date类型需要进行处理
    		    		Date date = (Date) v;
    		    		dynamicBean.setValue(k, date.getTime());
    		    	}else {
    		    		dynamicBean.setValue(k, v);
    		    	}
    	        } catch (Exception e) {
    	        	logger.error("动态添加字段值出错", e);
    	        }
    	    });
    	    Object obj = dynamicBean.getTarget();
    	    return obj;
    	}
    }
    
    

    3、使用方法
    现有一个用户实体User:

    public class User {
    
    	private String name;
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    }
    

    User只有一个name属性,现在要动态的为User添加年龄属性,代码如下:

    public static void main(String[] args) {
    		User user = new User();
    		user.setName("Daisy");
    		System.out.println("User:"+JSON.toJSONString(user));
    		Map<String,Object> propertiesMap = new HashMap<String,Object>();
    		propertiesMap.put("age", 18);
    		Object obj = ReflectUtil.getTarget(user, propertiesMap);
    		System.out.println("动态为User添加age之后,User:"+JSON.toJSONString(obj));
    }
    

    打印结果如下:

    User:{"name":"Daisy"}
    动态为User添加age之后,User:{"age":18,"name":"Daisy"}
    
    展开全文
  • java动态给对象添加属性并赋值

    万次阅读 2019-04-18 22:00:43
    * @param addValMap 动态需要添加属性属性值 * @return 新的对象 * @throws Exception */ public Object dynamicClass(Object object,HashMap addMap, HashMap addValMap) throws Exception { HashMap ...

    最近工作中剥离通用功能比较多。

    Maven引用:

           <!-- https://mvnrepository.com/artifact/cglib/cglib -->
            <dependency>
                <groupId>cglib</groupId>
                <artifactId>cglib</artifactId>
                <version>2.2.2</version>
            </dependency>

    不要引用太高级的版本。会存在兼容问题。本身有内部依赖。

    核心类:

    import net.sf.cglib.beans.*;
    
    import java.util.*;
    
    public class DynamicBean {
        private Object object = null; //动态生成的类
        private BeanMap beanMap = null; //存放属性名称以及属性的类型
    
        public DynamicBean() {
            super();
        }
    
        public DynamicBean(Map propertyMap) {
            this.object = generateBean(propertyMap);
            this.beanMap = BeanMap.create(this.object);
        }
    
        /**
         * @param propertyMap
         * @return
         */
        private Object generateBean(Map propertyMap) {
            BeanGenerator generator = new BeanGenerator();
            Set keySet = propertyMap.keySet();
            for (Iterator i = keySet.iterator(); i.hasNext(); ) {
                String key = (String) i.next();
                generator.addProperty(key, (Class) propertyMap.get(key));
            }
            return generator.create();
        }
    
        /**
         * 给bean属性赋值
         *
         * @param property 属性名
         * @param value    值
         */
        public void setValue(Object property, Object value) {
            beanMap.put(property, value);
        }
    
        /**
         * 通过属性名得到属性值
         *
         * @param property 属性名
         * @return 值
         */
        public Object getValue(String property) {
            return beanMap.get(property);
        }
    
        /**
         * 得到该实体bean对象
         *
         * @return
         */
        public Object getObject() {
            return this.object;
        }
    }

    帮助类:

    import java.beans.BeanInfo;
    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Method;
    import java.util.*;
    
    public class ClassUtil {
    
        /**
         *
         * @param object   旧的对象带值
         * @param addMap   动态需要添加的属性和属性类型
         * @param addValMap  动态需要添加的属性和属性值
         * @return  新的对象
         * @throws Exception
         */
        public Object dynamicClass(Object object,HashMap addMap, HashMap addValMap) throws Exception {
            HashMap returnMap = new HashMap();
            HashMap typeMap = new HashMap();
    
    
            Class<?> type = object.getClass();
            BeanInfo beanInfo = Introspector.getBeanInfo(type);
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (int i = 0; i < propertyDescriptors.length; i++) {
                PropertyDescriptor descriptor = propertyDescriptors[i];
                String propertyName = descriptor.getName();
                if (!propertyName.equals("class")) {
                    Method readMethod = descriptor.getReadMethod();
                    Object result = readMethod.invoke(object);
                    //可以判断为 NULL不赋值
                    returnMap.put(propertyName, result);
                    typeMap.put(propertyName, descriptor.getPropertyType());
                }
            }
    
            returnMap.putAll(addValMap);
            typeMap.putAll(addMap);
            //map转换成实体对象
            DynamicBean bean = new DynamicBean(typeMap);
            //赋值
            Set keys = typeMap.keySet();
            for (Iterator it = keys.iterator(); it.hasNext(); ) {
                String key = (String) it.next();
                bean.setValue(key, returnMap.get(key));
            }
            Object obj = bean.getObject();
            return obj;
        }
    
    }
    

     

    使用:

            Order order = new Order();
            order.setId(1);
            order.setName("order1");
            List<OrderDetail> orderDetailList = new ArrayList<OrderDetail>();
    
            OrderDetail orderDetail = new OrderDetail();
            orderDetail.setOrderid(1);
            orderDetail.setOrderPrice("1USD");
            orderDetail.setOrderSku("Sku1");
    
            orderDetailList.add(orderDetail);
    
            OrderDetail orderDetail2 = new OrderDetail();
            orderDetail2.setOrderid(1);
            orderDetail2.setOrderPrice("2USD");
            orderDetail2.setOrderSku("Sku2");
            orderDetailList.add(orderDetail2);
    
            try {
                HashMap addMap = new HashMap();
                HashMap addValMap = new HashMap();
                addMap.put("orderDetail", Class.forName("java.util.List"));
                addValMap.put("orderDetail", orderDetailList);
                Object obj2= new ClassUtil().dynamicClass(order,addMap,addValMap);
    
                System.out.println(JSON.toJSONString(obj2));
            } catch (Exception e) {
                e.printStackTrace();
            }

     

    展开全文
  • Java 类动态添加属性字段

    万次阅读 2018-10-22 18:35:11
    因为列是动态的, 首先想到的就是后天拼接JSON格式字符串, 然后返回到前台, 组装表头及内容。 但是当前系统中easyUI版本为1.2,并不支持 data属性(官方从1.3.2开始支持)。所以只能返回list&lt;T&gt; 格式...

    说明:做项目中遇到一种场景,需要根据查询时间段, 获取时间段中中每个月份对应的金额(费用统计)。如截图中的两列

    因为列是动态的, 首先想到的就是后天拼接JSON格式字符串, 然后返回到前台, 组装表头及内容。 但是当前系统中easyUI版本为1.2,并不支持 data属性(官方从1.3.2开始支持)。所以只能返回list<T> 格式。

    网上一搜相关代码很多, 看客可以自己搜索一下。 我这里记录一下我当时使用场景及用法,已备以后使用。

     

    1.需要引用cglib jar包, 我用的版本是2.2

    2.建一个实体对象 DynamicBean.java 。主要用来处理对象。

    public class DynamicBean {
        private Object object = null; // 动态生成的类
    
        private BeanMap beanMap = null; // 存放属性名称以及属性的类型
    
        public DynamicBean() {
            super();
        }
    
        public DynamicBean(Map propertyMap) {
            this.object = generateBean(propertyMap);
            this.beanMap = BeanMap.create(this.object);
        }
    
        /**
         * @param propertyMap
         * @return
         */
        private Object generateBean(Map propertyMap) {
            BeanGenerator generator = new BeanGenerator();
            Set keySet = propertyMap.keySet();
            for (Iterator<String> i = keySet.iterator(); i.hasNext();) {
                String key = (String) i.next();
                generator.addProperty(key, (Class) propertyMap.get(key));
            }
            return generator.create();
        }
    
        /**
         * ��bean���Ը�ֵ
         * @param property ������
         * @param value ֵ
         */
        public void setValue(Object property, Object value) {
            beanMap.put(property, value);
        }
    
        /**
         * ͨ���������õ�����ֵ
         * @param property ������
         * @return ֵ
         */
        public Object getValue(String property) {
            return beanMap.get(property);
        }
    
        /**
         * 返回新生成的对象
         * @return
         */
        public Object getObject() {
            return this.object;
        }
    }

    3. 原来对象, 及需要拼接到对象中的属性字段集合处理方法。

    /**
    *参数说明:
    *  object : 查询结果数组中对象。
    *  moneyMap : 为对象对应所有月份数据集合
    *  解释:已经查询出一组账单对象集合List<Bill> , 而moneyMap为对象中的一个属性 
    *  Map<String,Bigdecimal>, 存放了月份及金额
    */
    private Object dynamicClass(Object object, Map<String, BigDecimal> moneyMap) throws Exception {
            // 字段 - 值 集合
            HashMap<String, Object> returnMap = new HashMap<String, Object>();
            // 字段 - 字段类型 集合
            HashMap<String, Object> typeMap = new HashMap<String, Object>();
            // 获取传入类
            Class<? extends Object> type = object.getClass();
            BeanInfo beanInfo = Introspector.getBeanInfo(type);
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            // 获取对象中已存在的数据
            for (int i = 0; i < propertyDescriptors.length; i++) {
                PropertyDescriptor descriptor = propertyDescriptors[i];
                String propertyName = descriptor.getName();
                if (!propertyName.equals("class") && !propertyName.equals("monthMap")) {
                    Method readMethod = descriptor.getReadMethod();
                    Object result = readMethod.invoke(object, new Object[0]);
                    if (result != null) {
                        returnMap.put(propertyName, result);
                    } else {
                        String propertyType = descriptor.getPropertyType().toString();
                        if (propertyType.contains("java.math.BigDecimal")) {
                            returnMap.put(propertyName, new BigDecimal(0));
                        } else {
                            returnMap.put(propertyName, "");
                        }
                    }
                    typeMap.put(propertyName, descriptor.getPropertyType());
                }
            }
            // 获取月份数据, 变为字段属性
            Set<String> monthKeys = moneyMap.keySet();
            for (Iterator<String> it = monthKeys.iterator(); it.hasNext();) {
                String key = (String) it.next();
                // 字段类型
                typeMap.put(key, Class.forName("java.math.BigDecimal"));
                // 字段对应值
                returnMap.put(key, moneyMap.get(key));
            }
            // map转换成实体对象
            DynamicBean bean = new DynamicBean(typeMap);
            // 赋值
            Set<String> keys = typeMap.keySet();
            for (Iterator<String> it = keys.iterator(); it.hasNext();) {
                String key = (String) it.next();
                bean.setValue(key, returnMap.get(key));
            }
            Object obj = bean.getObject();
            return obj;
        }

     

    做笔记使用, 说不定以后还会用到。

    展开全文
  • Java动态生成以及动态添加属性

    万次阅读 2017-11-18 16:14:20
    有个技术实现需求:动态生成,其中中的属性来自参数对象中的全部属性以及来自参数对象properties文件。 那么技术实现支持:使用CGLib代理。 具体的实现步骤: 1.配置Maven文件: xmlns:xsi=...
  • 给java对象动态添加属性

    万次阅读 热门讨论 2018-09-03 16:53:28
    、不知道大家有没有遇到过这样的需求 ,就java运行的时候 动态给java对象添加属性,最近在项目终于到了,想到了反射去实现,但是最终也没有搞出来。。。哎。。 有的时候 比如你用的是hibernate或者Spring jdb.....
  • JAVA动态”为类添加属性

    万次阅读 2018-01-04 19:35:07
    来源 : https://www.cnblogs.com/frinder6/p/7204574.html部分参考:http://www.cnblogs.com/zy2009/p/6725843.htmlpom.xml中添加:1234567891011&lt;dependency&gt; &lt;groupId&gt;commons-...
  • 动态给类和对象添加属性和方法

    千次阅读 2017-10-20 15:09:30
    动态给类和对象添加属性和方法动态给类和对象添加属性定义一个Personclass Person(object): def __init__(self, name): self.name = name对象添加属性 # 创建2个Person,分别为p1,p2p1 = Person('amy') print...
  • java as一个类添加属性,并对这个属性赋值,查询操作 ,求大神。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • @Document(indexName = "#{@articleIndexName}", type = "java") public class ArticleModel implements Serializable{ private static final long seriaVersionUID = 6320548148250372656L; @Id private String ...
  • java asm 添加属性

    千次阅读 2014-08-04 22:40:45
    1、Person2.java package com.study.asm; public class Person2 { public String name = "yuanyi"; public String address = ...为上述类添加一个age属性: package com.study.asm; import java.io.Fil
  • java获取实体属性名和属性

    千次阅读 2021-01-28 12:22:45
    Java反射中Field描述的是属性信息,功能包括: 获取当前对象的成员变量的类型 对成员变量重新设值 Field常用方法 getType(): 获取属性声明时类型对象(返回class对象) getGenericType() : 返回属性声的...
  • java动态的生成属性、并赋值

    千次阅读 2018-04-03 21:58:42
    * bean 添加属性和值 * * @param property * @param value */ public void setValue(String property, Object value) { beanMap.put(property, value); } /** * 获取属性值 * * @param property * @...
  • Java动态给序列化JSON添加对象

    千次阅读 2019-04-18 20:27:59
    在有时候我们将动态对象转成JSON。需要将另外动态对象插入到JSON中时。就需要如下操作: 工作中,将亚马逊接口通用化的时候。需要将订单明细B 加入到订单主体A中。并且自定义属性AmazonOrderDetail。 正常的操作是...
  • 设置注解的属性 实例 定义 使用 个人遇到的使用场景 场景导入 实例 代码地址 引用 系列导航 设置注解的属性 这种使用场景比较少,但是不失为一种对于注解的深入理解。 实例 定义 Tag.java ...
  • JAVA反射静态内部属性

    千次阅读 2018-11-09 11:47:48
    最近做一功能,将JSONOBJECT的属性全部反射到某一属性中。 我这个很特别:Config中存在好多静态内部,静态内部中全部是静态属性,如何将jsonobject值反射到属性上来? 1、Config public class ...
  • Python 动态添加属性及方法

    千次阅读 2018-03-20 15:12:13
    Python是一门动态语言,动态语言的一个主要的特性就是你那个在运行时,添加属性以及方法。不同于静态语言(例如c,c++,java......)他们都是通过编译后在运行指定的编译后的文件。Python与他们最大的不同就是Python...
  • Java动态类加载

    万次阅读 2011-11-29 10:41:26
    Java动态加载的意义和目的: Java动态加载主要是为了不改变主程序代码,通过修改配置文件就可以操作不同的对象执行不同的功能。主要有利于系统的扩展,例如当我要改变一个功能,只需要做一个,然后编写相应的...
  • 32.JAVA编程思想——JAVA IO添加属性和接口 增添属性和有用的接口 利用层次化对象动态和透明地添加单个对象的能力的做法叫作“装饰器”(Decorator)方案。装饰器方案规定封装于初始化对象中的所有对象都拥有相同...
  • 利用cglibjavabean动态添加属性

    万次阅读 多人点赞 2011-09-23 23:41:16
    、不知道大家有没有遇到过这样的需求 ,就java运行的时候 动态给java对象添加属性,最近在项目终于到了,想到了反射去实现,但是最终也没有搞出来。。。哎。。 有的时候 比如你用的是hibernate或者Spring ...
  • 静态内部不能访问外部属性方法,所以android开发过程中可以优化handler 其他内部可以访问外部,是因为持有外部的引用。 成员内部说明: 成员内部拥有和外部同名的成员变量或者方法时,会发生...
  • 前面介绍了,反射调用的构造方法来创建...在这里简单介绍,反射调用属性和方法会用到的新,Method和Field。 Method的常用API: getModifiers() : 获取方法的修饰符 getName(): 获取到方法的名称 getPar...
  • 在运行状态中,对任意一个都有获取这个的所有属和方法,对于任意一个对象,都能调用它的任意一个方法和属性(包括私有的方法和属性),这种动态获取的信息以及动态调用对象的方法的功能就称为java语言的反射机制。...
  • so,,,现在要使用java代码去动态添加这些控件,并实现如上效果很简单的。。。看代码。。。 /** * 动态添加线性布局 */ private void addLinearLayout() { //initMissionList:存储几条测试数据 for (int i = ...
  • 下面小编就为大家带来一篇Java通过反射机制动态设置对象属性值的方法。小编觉得挺不错的,现在就分享大家,也大家做个参考。一起跟随小编过来看看吧
  • 【深入JAVA】对xml节点添加属性

    千次阅读 2015-04-16 10:21:00
    在阅读的过程中有任何问题,欢迎一起交流 ...对xml中的节点添加属性节点为> Java代码: try {  builder = factory.newDocumentBuilder(); } catch (ParserConfigurationException e1) {  e1.printSt

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 842,406
精华内容 336,962
关键字:

java动态给类添加属性

java 订阅