java 反射---------比较两个相同类型的对象相同属性的属性值是否相同的具体调用

一.Java反射的概念：

 

      在Java运行时环境中，对于任意一个类，可以知道这个类有哪些属性和方法。 对于任意一个对象，可以调用它的任意一个方法。 这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。

 

反射结构分析

Java反射原理：将普通java类的各个组成部分分别封装为对象，包括类的成员变量、成员方法、成员构造。

其所对应的对象分别是：Field、Method、Constructor。

2.反射的相关函数，用法

        

 一.class对象  

 通过类的字节码对象，即Class对象获取

Class类将所有的普通java类作为对象。

三个阶段获取Class对象的方法

1. Class.forName(“全类名”)

   将字节码文件加载进内存，并返回class对象。多用于配置文件

2. 类名.class

   通过类名的class属性获取，该方法常用于参数的传递。

3. 对象名.getClass()

   getClass()方法定义于Object类中，用于对象获取字节码。

同一个字节码文件(*.class)在程序运行过程中，只会被加载一次。无论通过哪种方法获取的class对象都是同一个。

 

Class对象中的常用方法

获取成员变量

方法名	作用
Field[] getFields()	获取所有public修饰的成员变量
Field getField(String name)	获取指定名称的 public修饰的成员变量
Field[] getDeclaredFields()	获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)	获取指定名称的成员变量，不考虑修饰符

 

Field类的常用方法

方法名	作用
void set(Object obj, Object value)	设置值，将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
Object get(Object obj)	获取值，返回指定对象上此 Field 表示的字段的值
setAccessible(true)	忽略访问权限修饰符的安全检查

当访问私有变量时，必须设置setAccessible(true)来忽略访问权限修饰符的安全检查，否则没有权限访问。

 

 

案例

 public static void main(String[] args) throws Exception{

        Student student=new Student(); //新建一个对象
        student.setId("01");           //设置改对象的id值
        student.setName("tom");        //设置改对象的name值
        student.setBirthday("2020-03-05"); //设置改对象的Birthday值
        student.setSex("男");              //设置改对象的性别值


             Class  clazz =Class.forName("Student"); //获取该类
             Class  clazz2=Student.class;            //类.class
             Class  clazz3=student.getClass();       //对象.getclass

              Field field = null;                      

              field = clazz.getDeclaredField("id");//获取类的指定属性包含私有属性

                   int modifiers  =field.getModifiers();  //获取类的指定属性的修饰符
           if(Modifier.isPrivate(modifiers)){            //指定属性的修饰符是否为private
               field.setAccessible(true);                //如果属性为private就设置为可以访问
           }
            Object id  =field.get(student);              //获取该对象的属性值

           if(id instanceof String){
               System.out.println("id = " + id);
               field.set(student,"002");             //更改该对象的属性值
               System.out.println("id = " + student.getId());
           }

    }

 

 

student类

 

public class Student {

    private String id;

    private String name;

    private String sex;

    private String birthday;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}

 

获取构造函数的相关方法

 

获取构造方法

方法名	作用
Constructor[] getConstructors()	返回此 Class 对象所表示的类的所有公共构造方法。
Constructor getConstructor(类... parameterTypes)	返回此 Class 对象所表示的类的指定参数公共构造方法。
Constructor[] getDeclaredConstructors()	返回此 Class 对象所表示的类的所有构造方法，不考虑修饰符。
Constructor getDeclaredConstructor(类... parameterTypes)	返回此 Class 对象所表示的类的指定参数构造方法，不考虑修饰符。

Constructor类中的常用方法

方法名	作用
T newInstance(Object... initargs)	实例化一个对象

        Class cls = Student.class;
        //方法一
        Constructor c1 = cls.getConstructor(String.class,String.class,String.class,String.class);
        Object s1 = c1.newInstance("帝释天","24","看小说","001");
        System.out.println(s1);
        //方法二 调用空参构造
        Constructor c2 = cls.getConstructor();
        Object s2 = c2.newInstance();
        System.out.println(s2);
        //方法三  由Class对象直接创建
        Object c3 = cls.newInstance();
        System.out.println(c3);

 

获取函数的相关方法

 

获取成员方法

方法名	作用
Method[] getMethods()	获取所有public修饰的成员方法
Method getMethod(String name, 类... parameterTypes)	获取指定参数形式的 public修饰的成员方法
Method[] getDeclaredMethods()	获取所有成员方法，不考虑修饰符
Method getDeclaredMethod(String name, 类... parameterTypes)	获取指定参数形式的成员方法，不考虑修饰符

Method类中的常用方法

方法名	作用
Object invoke(Object obj, Object... args)	执行方法，对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
String getName	获取方法名

 

  Class cls = Student.class;
        Student stu = new Student();
        //执行带参数方法
        Method song1 = cls.getMethod("song", String.class);
        song1.invoke(stu, "你确定这就是爱吗");
        //执行无参数方法
        Method song2 = cls.getMethod("song");
        song2.invoke(stu);
        //获取方法名
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }





 public void song() {
        System.out.println("We are the word...");
    }
    public void song(String songs) {
        System.out.println("我会唱"+songs);
    }

invoke(Object obj, Object... args) 对该对象，执行该方法；

 

3.比较的相关工具类的书写

 

package com.etoppaas.insureagent.common.utils;

import com.etoppaas.common.tools.EmptyUtils;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 比较相同类的相同属性值是否相同
 */
public class CompareClassUtil {

    public static Boolean compareTwoClass(Object class1, Object class2, List ignoreFieldList) throws ClassNotFoundException, IllegalAccessException {


        //动态的获取指定对象的class
        Class clazz1 = class1.getClass();
        Class clazz2 = class2.getClass();

        // 获取类中所有的属性(public、protected、default、private)，但不包括继承的属性，返回 Field 对象的一个数组
        Field[] field1 = clazz1.getDeclaredFields();
        Field[] field2 = clazz2.getDeclaredFields();

        //遍历属性列表field1
        for (int i = 0; i < field1.length; i++) {
            //遍历属性列表field2
            for (int j = 0; j < field2.length; j++) {
                //如果field1[i]属性名与field2[j]属性名内容相同

                if (field1[i].getName().equals(field2[j].getName())) {
                    Boolean checkIgnoreField = true;
                    if (EmptyUtils.isNotEmpty(ignoreFieldList)) {
                        for (int ignoreFieldNum = 0; ignoreFieldNum < ignoreFieldList.size(); ignoreFieldNum++) {
                            //如果要忽略的类型里存在，就跳过这个方法
                            if (field1[i].getName().equals(ignoreFieldList.get(ignoreFieldNum))) {
                                checkIgnoreField = false;
                            }
                        }
                        if (checkIgnoreField) {
                            //调过本次循环的下面语句执行
                            continue;

                        }

                        if (!compareTwo(field1[i], field2[j], class1, class2)) {
                            return false;
                        }
                        break;
                    } else {
                        if (!compareTwo(field1[i], field2[j], class1, class2)) {
                            return false;
                        }
                        break;

                    }
                }


            }
        }
        return true;

    }

    /**
     * 对比两个数据是否内容相同
     *
     * @param
     * @return boolean类型
     */
    public static boolean compareTwo(Field field1, Field field2, Object class1, Object class2) throws IllegalAccessException {

        //让我们可以访问私有变量的值
        field1.setAccessible(true);
        field2.setAccessible(true);
        //如果field1[i]属性值与field2[j]属性值内容不相同
        //为了不重写equals方法目前只能比较基础的类型
        if ("java".equals(field1.getGenericType().toString())) {

        }
        //返回该类下面对应的该属性值，并返回结果
        Object object1 = field1.get(class1);
        Object object2 = field2.get(class2);
        if (object1 == null && object2 == null) {
            return true;
        }
        if (object1 == null && object2 != null) {
            return false;
        }
        if (object1.equals(object2)) {
            return true;
        }
        return false;
    }


}