Java学习之反射

反射

作用：

把一个对象的成员变量、构造方法、成员函数（方法）转换为对象，然后进行动态调用。反射是框架设计的“灵魂”技术！

注意：

代码对象从创建到产生结果的过程中，要经历过编译，加载，运行，三个阶段。

编译：将 .Java 文件转换为字节码 .class 文件。（此时代码还存在于硬盘中）

加载：将 .class 文件加载到内存中，以便编辑器进行操作。

运行：使内存中的代码产生结果。

类加载器：

加载：

指的是将类的class文件读入到内存，并为之创建一个java.lang.Class对象，也就是说，当程序中使用任何类时，系统都会为之建立一个java.lang.Class对象。

 

类的加载由类加载器完成，类加载器通常由JVM提供，这些类加载器也是所有程序运行的基础，JVM提供的这些类加载器通常被称为系统类加载器。除此之外，开发者可以通过继承ClassLoader基类来创建自己的类加载器。

 

通过使用不同的类加载器，可以从不同来源加载类的二进制数据，通常有如下几种来源。

• 从本地文件系统加载class文件。
• 从JAR包加载class文件。
• 通过网络加载class文件。

把一个Java源文件动态编译，并执行加载。

类加载器通常无须等到“首次使用”该类时才加载该类，Java虚拟机规范允许系统预先加载某些类。

作用：

• 将硬盘上的Class文件加载到内存（方法区）以便后续的操作。
• 类加载器加载完成后会在堆区创建一个class对象，用来表示加载的“类结构”。

反射的第一步：获取到堆中的class对象

方法：

• Class.forName (全限定类名) 获取Class对象(然后cls.newInstance() 获取实例化对象)，这种一般配合配置文件使用
•  类名.Class 获取响应类型的class对象，常用于参数列表用于传参
•  对象名.getClass() 用于方法内部，用于确定传入参数的具体类型

代码案例：

package com.reflex.bean;

public class Person {
    private String Id;
    public String name;
    public String age;
    protected String gender;

    public String getId() {
        return Id;
    }

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public void setId(String id) {

        Id = id;
    }

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

    public void setAge(String age) {
        this.age = age;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Person(String id, String name, String age, String gender) {

        Id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person() {

    }

    private void reflexDemo() {
        System.out.println("this is a test!");
    }

    @Override
    public String toString() {
        return "Person{" +
                "Id='" + Id + '\'' +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
    private void eat(){
        System.out.println("eat food!");
    }
}

 

 

package com.reflex.demo;

import com.reflex.bean.Person;

public class demo1 {
    public static void main(String[] args) throws Exception {
//        1、    Class.forName (全限定类名) 获取Class对象(然后cls.newInstance() 获取实例化对象)，这种一般配合配置文件使用
        Class cls1 = Class.forName("com.reflex.bean.Person");
//        2、    类名.Class 获取响应类型的clszz 对象，常用于参数列表用于传参
        Class<Person> cls2 = Person.class;
//        3、    对象名.getClass() 用于方法内部，用于确定传入参数的具体类型
        Person person = new Person();
        Class cls3 = person.getClass();
        System.out.println(cls1);
        System.out.println(cls2);
        System.out.println(cls3);
        System.out.println(cls1 == cls2);
        System.out.println(cls2 == cls3);
        System.out.println(cls1 == cls3);
        System.out.println(cls1.getName());
        System.out.println(cls1.getClassLoader());
    }
}

cls1 == cls2 == cls3  说明：无论通过这三种方法的哪一种方法，获取的Class对象有且只有一个！（class对象只创建一次）

反射的第二步：通过Class对象获取对应的构造函数、成员变量、成员方法对象

常用方法：

• Field getField​(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定公共成员字段。
• Field[] getFields​() 返回一个包含 Field对象的数组， Field对象反映由该 Class对象表示的类或接口的所有可访问的公共字段。
• Field getDeclaredField​(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定声明字段。
• Field[] getDeclaredFields​() 返回一个 Field对象的数组，反映了由该 Class对象表示的类或接口声明的所有字段。
• Method getMethod​(String name, Class<?>... parameterTypes) 返回一个 方法对象，该对象反映由该 Class对象表示的类或接口的指定公共成员方法。
• Method[] getMethods​() 返回一个包含 方法对象的数组， 方法对象反映由该 Class对象表示的类或接口的所有公共方法，包括由类或接口声明的对象以及从超类和超级接口继承的类。
• Method getDeclaredMethod​(String name, Class<?>... parameterTypes) 返回一个 方法对象，它反映此表示的类或接口的指定声明的方法 Class对象。
• Method[] getDeclaredMethods​() 返回一个包含 方法对象的数组， 方法对象反映由 Class对象表示的类或接口的所有声明方法，包括public，protected，default（package）访问和私有方法，但不包括继承方法。
• Constructor<T> getConstructor​(Class<?>... parameterTypes) 返回一个 Constructor对象，该对象反映由该 Class对象表示的类的指定公共构造函数。
• Constructor<?>[] getConstructors​() 返回一个包含 Constructor对象的数组， Constructor对象反映了由该 Class对象表示的类的所有公共构造函数。
• Constructor<T> getDeclaredConstructor​(Class<?>... parameterTypes) 返回一个 Constructor对象，该对象反映由此 Class对象表示的类或接口的指定构造函数。
• Constructor<?>[] getDeclaredConstructors​() 返回反映由该 Class对象表示的类声明的所有构造函数的 Constructor对象的数组。

注意：可获取到public修饰的方法和属性（public），getDeclareXXX获取到对象中所有修饰符修饰的方法和属性（public，protect，private）。

 

代码案例：

package com.reflex.demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;


public class demo2 {
    public static void main(String[] args) throws Exception {
        //获取class对象
        Class cls = Class.forName("com.reflex.bean.Person");
        String name = cls.getName();
        System.out.println(name);
        //获取构造函数对象
        System.out.println("---------分割线-----------");
        Constructor[] constructors = cls.getConstructors();
        for (Constructor con : constructors) {
            System.out.println(con);
        }
        System.out.println("---------分割线-----------");
        Constructor[] declaredConstructors = cls.getDeclaredConstructors();
        for (Constructor Dcon : declaredConstructors) {
            System.out.println(Dcon);
        }
        //获取方法对象
        System.out.println("---------分割线-----------");
        System.out.println("会获取到继承Object类的方法");
        Method[] methods = cls.getMethods();
        for (Method me : methods) {
            System.out.println(me);
        }
        System.out.println("---------分割线-----------");
        Method[] declaredMethods = cls.getDeclaredMethods();
        for (Method Dme : declaredMethods) {
            System.out.println(Dme);
        }
        //获取属性对象
        System.out.println("---------分割线-----------");
        Field[] fields = cls.getFields();
        for (Field fi : fields) {
            System.out.println(fi);
        }
        System.out.println("---------分割线-----------");
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field Dfi : declaredFields) {
            System.out.println(Dfi);
        }
        System.out.println("---------分割线-----------");
        Object per = cls.newInstance();
        Field id = cls.getDeclaredField("Id");
        //获取和修改private修饰的方法和属性，需要设置暴力反射
        id.setAccessible(true);
        id.set(per,"123456");
        System.out.println(per);
    }
}

 

反射的使用案例：在不改变代码的情况下获取到不同对象和方法

实现：配置文件+反射（框架设计的雏形）

代码案例：

package com.reflex.bean;

public class Person {
    private String Id;
    public String name;
    public String age;
    protected String gender;

    public String getId() {
        return Id;
    }

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public void setId(String id) {

        Id = id;
    }

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

    public void setAge(String age) {
        this.age = age;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Person(String id, String name, String age, String gender) {

        Id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person() {

    }

    private void reflexDemo() {
        System.out.println("this is a test!");
    }

    @Override
    public String toString() {
        return "Person{" +
                "Id='" + Id + '\'' +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
    private void eat(){
        System.out.println("eat food!");
    }
}

package com.reflex.bean;


public class Student {
    private String Id;
    public String name;
    public String age;
    protected String gender;

    public String getId() {
        return Id;
    }

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public void setId(String id) {

        Id = id;
    }

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

    public void setAge(String age) {
        this.age = age;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Student(String id, String name, String age, String gender) {

        Id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Student() {

    }

    private void reflexDemo() {
        System.out.println("this is a test!");
    }

    @Override
    public String toString() {
        return "Person{" +
                "Id='" + Id + '\'' +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
    private void study(){
        System.out.println("study...");
    }
}

package com.reflex.demo;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;


public class demo3 {
    public static void main(String[] args) throws Exception{
        //创建properties对象
        Properties prop = new Properties();
        //获取类加载器
        ClassLoader classLoader = demo3.class.getClassLoader();
        //通过类加载器获取配置文件
        InputStream in = classLoader.getResourceAsStream("prop.properties");
        //加载配置文件
        prop.load(in);
        //通过配置文件获取对象的属性
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");
        //通过反射获取对象
        Class cls = Class.forName(className);
        Object obj = cls.newInstance();
        //获取方法对象
        Method method = cls.getDeclaredMethod(methodName);
        //因为方法修饰为private，设置暴力反射（不设置无权访问会报错）
        method.setAccessible(true);
        //调用方法
        method.invoke(obj);
    }
}

配置文件：

名字：

prop.properties

 

内容：

#className=com.reflex.bean.Person
#methodName=eat
className=com.reflex.bean.Student
methodName=study

获取构造函数、成员属性和成员方法对象的相关操作，建议结合着API文档进行拓展学习！