java反射、Class类对象

java反射

在了解反射之前，先看一下java代码在计算机中经历的三个阶段：

• 第一个阶段：源代码阶段，.java文件被编译为.class文件存放在硬盘上
• 第二个阶段：Class类对象阶段，类加载器将.class文件加载到内存中，成为一个Class类的实例。
• 第三阶段：运行时阶段，通过new创建对象

通过Class类对象的实例可获取到三个对象：Field（封装属性的有关信息）、Constructor（封装构造器的有关信息）、Method（封装方法的有关信息）。

Field常用的方法：

方法	描述
getName()	获取字段名称
getType()	获取字段类型
setAccessible(true)	设置属性操作
set(obj,value)	为属性设置值
get(obj)	获取属性值

Constructor常用的方法：

方法	描述
getName()	返回构造函数的名称
getParameterCount()	返回形参的数量
newInstance(Object… initargs)	使用指定的初始化参数来创建和初始化构造函数的声明类的新实例

Method常用的方法：

方法	描述
getName()	获取方法的名称
Object invoke(Object obj, Object … args)	调用方法

反射：

将类的各个组成部分封装为其它对象，属性->Field、构造方法->Constructor、方法->Method，这就是反射机制

反射的好处：

1. 可以在程序运行过程中，操作这些对象
2. 可以解耦，提高程序的可扩展性

获取Class对象的方式：

1. 源代码阶段获取。Class.forName(“类名”)，将字节码加载进内存，返回Class对象。多用于配置文件，将类名定义在配置文件中。读取文件，加载类。
2. Class类对象阶段获取。类名.class。
3. 运行时阶段获取，对象.getClass()，getClass()方法在Object类中定义着
4. 使用类加载器获取

		// 1.源代码阶段获取，Class.forName("类名")
        Class cls = Class.forName("com.szly.domain.Person");
        System.out.println(cls);  // class com.szly.domain.Person
        
        // 2.Class类对象阶段获取，类名.class
        Class cls2 = Person.class;
        System.out.println(cls2);  // class com.szly.domain.Person
        
        // 3.运行时阶段获取，对象.getClass()
        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);  // class com.szly.domain.Person
        
        // 4.使用类加载器获取
        ClassLoader classLoader = ReflectDemo1.class.getClassLoader();
        Class cls4 = classLoader.loadClass("com.szly.domain.Person");
        System.out.println(cls4);  // class com.szly.domain.Person


        System.out.println(cls == cls2);  // true
        System.out.println(cls == cls3);  // true
        System.out.println(cls3 == cls2);  // true
        System.out.println(cls == cls4);  // true

注：同一个字节码文件（*.class）在一次程序运行中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

Class类常用的方法：

方法	描述
Class forName(String className)	返回指定字符串的类关联的Class对象
Field[] getFields()	获取所有public修饰的成员变量
Field getField(String s)	获取指定名称的public修饰的成员变量
Field[] getDeclaredFields()	获取所有的成员变量（不考虑访问修饰符）
Field getDeclaredField(String s)	获取指定的成员变量（不考虑访问修饰符）
Constructor getConstructor(Class<?>… parameterTypes)	返回一个构造函数对象
Constructor<?>[] getConstructors()	返回所有的构造函数
T newInstance()	通过Class类对象创建一个类的实例
Method getMethod(String name, Class<?>… parameterTypes)	返回一个Method对象，该对象反映此Class对象表示的类或接口的指定公共成员方法
Method[] getMethods()	获取所有public修饰的方法
Method getDeclaredMethod(String name, Class<?>… parameterTypes)	获取指定的成员方法（不考虑访问修饰符）
Method[] getDeclaredMethods()	获取所有的成员方法（不考虑访问修饰符）
String getName()	以String形式返回此Class对象表示的实体名称（类，接口，数组类，原始类型或void）

Class对象的功能：

1. 获取成员变量

		// 获取Class类对象
        Class clazz = Class.forName("com.szly.domain.Person");

        // 获取public修饰的成员变量
        Field[] fields = clazz.getFields();
        for(Field field : fields){
            System.out.println(field);
        }

        Person p = new Person();
        // 获取public修饰的成员变量
        Field name = clazz.getField("name");
        // 设置public修饰的成员变量的值
        name.set(p, "tom");
        // 获取public修饰的成员变量的值
        System.out.println(name.get(p));

        //获取所有的成员变量（包括私有的）
        Field[] fieldAll = clazz.getDeclaredFields();
        for(Field field : fieldAll){
            System.out.println(field);
        }

        // 暴力反射，忽略访问权限修饰符的安全检查
        // 为属性赋值前需要设置可操作，破坏了封装性可以为私有字段赋值。
        fieldAll[1].setAccessible(true); // fieldAll[1]为私有属性age的Field类对象
        fieldAll[1].set(p, 16);
        System.out.println(fieldAll[1].get(p));

2. 获取构造方法

        // 获取Class对象
        Class p = Person.class;
        // 获取有参构造方法
        Constructor c = p.getConstructor(String.class, int.class);
        // 利用有参构造方法创建对象
        Object obj = c.newInstance("tom", 16);
        System.out.println(obj);  // Person{name='tom', age=16}

        // 如果使用使用空参创建对象，可以使用Class对象的newInstance()方法来简化创建对象
        Object obj2 = p.newInstance();
        System.out.println(obj2);  // Person{name='null', age=0}

3. 获取成员方法

        // 获取类对象
        Class clazz = Person.class;
        // 获取指定指定名称的方法
        Method m = clazz.getMethod("learn");
        Person p1 = new Person();
        // 执行实例p1的方法
        m.invoke(p1);

        System.out.println("-------------------------");

        // 获取所有public修饰的方法，包括Object类的方法
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            // 获取方法名
            String s = method.getName();
            System.out.println(s);
        }

        System.out.println("-------------------------");
        
        // 获取私有方法，并调用
        Method private_method = clazz.getDeclaredMethod("identify");
        // 暴力反射
        private_method.setAccessible(true);
        private_method.invoke(p1);
        System.out.println(private_method.getName());

4. 获取类名

		Class<Person> clazz = Person.class;
        String className = clazz.getName();
        System.out.println(className);  // com.szly.domain.Person

反射机制常用的一个场景：

通过配置文件动态创建类对象，并进行相应的操作。与平常使用new来创建对象相比，最大的好处就是可以动态配置一些东西，不用每一次都要在代码里面去new或者做其他的事情，以后要改的话直接改配置文件即可，代码维护起来就很方便了。再者就是有时候要适应某些需求，Java类里面不一定能直接调用相关的方法，这时候也可以通过反射机制来实现。

下面是使用反射加载配置文件，动态创建对象的一个案例：

pro.properties文件中配置以下相关类的信息：

className=com.szly.domain.Person
methodName=learn

使用反射机制创建对象并调用learn方法：

        // 1. 加载配置文件
        Properties prop = new Properties();
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        prop.load(is);

        // 2. 获取配置文件中的数据
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        // 3. 加载类进内存
        Class cls = Class.forName(className);
        // 4. 创建对象
        Object o = cls.newInstance();
        // 5. 获取方法对象
        Method method = cls.getMethod(methodName);
        // 6. 调用方法
        method.invoke(o);

总结：

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法，这种动态获取、调用对象方法的功能称为java语言的反射机制。