java实现两个对象之间传值及简单的封装

目录

• java两个对象之间传值及封装
• java 参数传递、对象、封装
• 面向对象的三大特征
• 封装表现
• 封装的好处
• 构建set、get方法

java两个对象之间传值及封装

在项目里面使用SSH框架的过程中， 经常涉及到修改，我们只要对部门的部门属性进行修改我们通常的做法是先从数据库把对象查询出来target

再把从页面上传递来的修改过的值封装成为一个对象model，我们需要把model中修改过的属性重新赋值给target，再对target进行保存.完成修改

在这个target.setXxx(model.getXxx)过程中有可能有大量的苦力工作要做，所以我利用反射做了一个简单的封装，只需要传递两个对象，就可以完成重新赋值的过程

import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * @Description:
 * 通过两个对象的传入,进行两个对象的赋值,
 * 共2个参数,把第一个对象中的参数传递给第二个对象
 * @author: 长河
 * @version:    0.0.2beta
 * @Company:
 * @date:       2017年3月26日
 */
public class Demo {
    //model是从前台接受的数据,封装的对象
    //target是从后台根据id查询到的数据,封装的对象
    public static<T> void setValue(T model,T target) throws Exception {
        //获得实体类
        Class clazz = model.getClass();
        //查看有那些字段
        Field[] fields = clazz.getDeclaredFields();
        //遍历
        for (Field field : fields) {
            //属性的名字
            String fieldName = field.getName();
            //属性的类型
            //Class<?> type = field.getType();
            //再得到getter方法的名字
            String getMethodName = "get" + (fieldName.charAt(0)+"").toUpperCase() + fieldName.substring(1);
            Method getMethod = clazz.getMethod(getMethodName);
            //判断model的哪个属性是否为空,利用get方法
            Object object = getMethod.invoke(model);
            if(object!=null) {
                //不为空就进行赋值
                // 通过属性名，来获取对应的setXXX的名字
                String setMethodName = "set" + (fieldName.charAt(0)+"").toUpperCase() + fieldName.substring(1);
                //这是set方法
                Method setMethod = clazz.getMethod(setMethodName, field.getType());
                //这里需要进行类型的强制转换吗?
                setMethod.invoke(target, object);
            }
        }
    }
}

其实我觉得应该是field.getType，得到参数的类型，根据类型控制对象中值的赋予，而不是简单的使用Object进行赋值.不过经过简单的测试，这个类可以使用，没什么大问题.

这是个简单的封装还有其他的需要的条件可以考虑，可以把这个类封装的更好

2019年8月9日15:23:37

更新，增加了object转成Map的方法和Map转object 的方法，还有一个简单的方法

/**
     * 对象转换成Map,以属性名为key, 值为value.全部的转成Map,null也弄进去了
     *
     * @param object
     * @return
     */
    public static Map<String, Object> obj2Map(Object object) {
        Map<String, Object> map = new HashMap<>();
        if (object == null) {
            return map;
        }
        Class<?> clazz = object.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            String name = field.getName();
            Object o = null;
            try {
                o = field.get(object);
                map.put(name, o);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return map;
    }

/**
     * 读取properties 配置文件中的所有内容,全部读取,变成map,以key-value保存
     *
     * @param object
     * @throws IllegalAccessException
     */
    public static Map<String, String> handleBean2Map(Object object) throws IllegalAccessException {
        Map<String, String> map = new HashMap<>();
        Class clazz = object.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            String name = field.getName();
            String value = String.valueOf(field.get(object));
            map.put(name, value);
        }
        return map;
    }

前端姐姐说

{key:value, key:value, key:value, key:value} 这种形式相对于[ {key:A, value:B},{key:A, value:B}, ]这种不好解析，不是很方便。

所以就有了下面的方法，转换成数组：

/**
     * 把Map变成List中的Map,组成key-value 的形式
     *
     * @param map
     * @return
     */
    public static <T> List<Map<String, Object>> map2List(Map<String, T> map) {
        List<Map<String, Object>> newList = new ArrayList<Map<String, Object>>();
        if (map == null || map.size() < 1) {
            return newList;
        }
        for (Entry<String, T> entry : map.entrySet()) {
            Map<String, Object> hashMap = new HashMap<String, Object>(2);
            hashMap.put("key", entry.getKey());
            hashMap.put("value", entry.getValue());
            newList.add(hashMap);
        }
        return newList;
    }

java 参数传递、对象、封装

参数传递分为值传递（传值）和引用传递（传地址）。

面向对象的三大特征

1. 封装

2. 继承

3. 多态

封装表现

1、方法就是一个最基本封装体。

2、类其实也是一个封装体。

封装的好处

1、提高了代码的复用性。

2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。

3、提高了安全性。

构建set、get方法

在类中右键，选择source，选择setter与getter方法

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。