框架设计的灵魂——反射

最新推荐文章于 2022-04-18 01:31:18 发布

husky105

最新推荐文章于 2022-04-18 01:31:18 发布

阅读量108

点赞数

分类专栏： Java 文章标签： java 反射 class 类

本文链接：https://blog.csdn.net/weixin_44795839/article/details/107282478

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

反射

将类的各个组成部分封装为其他对象，这就是反射机制

好处

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

Java代码在计算机中经历的三个阶段

在这里插入图片描述

获取Class对象的方式

Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象（多用于配置文件，将类名定义在配置文件中。读取文件，加载类）
类名.class：通过类名的属性class获取（多用于参数的传递）
对象.getClass()：getClass()方法在Object类中定义着。（多用于对象的获取字节码的方式）

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

测试：
类Person.java

package com.helin.domain;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    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;
    }
}

演示类：reflect.java

package com.helin.reflect;

import com.helin.domain.Person;

public class ReflectDemo1 {
    /*
        1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
			* 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
		2. 类名.class：通过类名的属性class获取
			* 多用于参数的传递
		3. 对象.getClass()：getClass()方法在Object类中定义着。
			* 多用于对象的获取字节码的方式
     */
    public static void main(String[] args) throws Exception {
        // 1.Class.forName("全类名")       forName()是Class类的静态方法
        Class cls1 = Class.forName("com.helin.domain.Person");
        System.out.println(cls1);
        // 2.类名.class
        Class cls2 = Person.class;
        System.out.println(cls2);
        // 3.对象.getClass()
        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);

        /*
            同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
         */
        System.out.println(cls1 == cls2);
        System.out.println(cls1 == cls3);
    }
}

结果：
在这里插入图片描述

Class对象的一些获取功能

获取成员变量们
Field[] getFields() ：获取所有public修饰的成员变量
Field getField(String name) 获取指定名称的 public修饰的成员变量

Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)
获取构造方法们
Constructor<?>[] getConstructors()
Constructor getConstructor(类<?>… parameterTypes)

Constructor getDeclaredConstructor(类<?>… parameterTypes)
Constructor<?>[] getDeclaredConstructors()
获取成员方法们：
Method[] getMethods()
Method getMethod(String name, 类<?>… parameterTypes)

Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<?>… parameterTypes)
获取全类名
String getName()

获取成员变量的测试：

* Field：成员变量
	* 操作：
		1. 设置值
			* void set(Object obj, Object value)  
		2. 获取值
			* get(Object obj) 

		3. 忽略访问权限修饰符的安全检查
			* setAccessible(true):暴力反射

类Person.java

package com.helin.domain;

public class Person {
    private String name;
    private int age;

    public String a;
    protected String b;
    String c;
    private String d;


    public Person() {
    }

    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }


    public void eat(){
        System.out.println("eat...");
    }

    public void eat(String food){
        System.out.println("eat..."+food);
    }
}

测试类：

package com.helin.reflect;

import com.helin.domain.Person;

import java.lang.reflect.Field;

public class ReflectDemo2 {
    /*
        1. 获取成员变量们
            * Field[] getFields() ：获取所有public修饰的成员变量
            * Field getField(String name)   获取指定名称的 public修饰的成员变量

            * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
            * Field getDeclaredField(String name)
        2. 获取构造方法们
            * Constructor<?>[] getConstructors()
            * Constructor<T> getConstructor(类<?>... parameterTypes)

            * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
            * Constructor<?>[] getDeclaredConstructors()
        3. 获取成员方法们：
            * Method[] getMethods()
            * Method getMethod(String name, 类<?>... parameterTypes)

            * Method[] getDeclaredMethods()
            * Method getDeclaredMethod(String name, 类<?>... parameterTypes)

        4. 获取全类名
            * String getName()
     */
    public static void main(String[] args) throws Exception {
        //0.获取Person的Class对象
        Class personClass = Person.class;
        /*
             1. 获取成员变量们
                 * Field[] getFields()
                 * Field getField(String name)

                 * Field[] getDeclaredFields()
                 * Field getDeclaredField(String name)

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

        System.out.println("------------");
        //2.Field getField(String name)     获取指定名称的 public修饰的成员变量
        Field a = personClass.getField("a");
        //获取成员变量a 的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);

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

        //Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //Field getDeclaredField(String name)
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);
        d.set(p,"hello");
        System.out.println(p);
    }
}

结果：
在这里插入图片描述
构造器有关方法的测试：
Person.java代码同上

* Constructor:构造方法
	* 创建对象：
		* T newInstance(Object... initargs)  
		*  如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

package com.helin.reflect;

import com.helin.domain.Person;

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

public class ReflectDemo3 {

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

        //0.获取Person的Class对象
        Class personClass = Person.class;
        /*
            2. 获取构造方法们
                 * Constructor<?>[] getConstructors()
                 * Constructor<T> getConstructor(类<?>... parameterTypes)

                 * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
                 * Constructor<?>[] getDeclaredConstructors()
         */


        //Constructor<T> getConstructor(类<?>... parameterTypes)
        Constructor constructor = personClass.getConstructor(String.class, int.class);//构造方法之间的区分靠参数列表
        System.out.println(constructor);
        //创建对象
        Object person = constructor.newInstance("张三", 23);
        System.out.println(person);

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


        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
        //创建对象
        Object person1 = constructor1.newInstance();
        System.out.println(person1);

        // Class对象可以创建对象（比使用构造其更加简单）
        Object o = personClass.newInstance();
        System.out.println(o);


        //constructor1.setAccessible(true);
    }
}

获取成员方法的测试

* Method：方法对象
	* 执行方法：
		* Object invoke(Object obj, Object... args)  

	* 获取方法名称：
		* String getName:获取方法名

Person.java同上
测试类：

package com.helin.reflect;

import com.helin.domain.Person;

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

public class ReflectDemo4 {

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

        //0.获取Person的Class对象
        Class personClass = Person.class;
        /*
          3. 获取成员方法们：
             * Method[] getMethods()
             * Method getMethod(String name, 类<?>... parameterTypes)

             * Method[] getDeclaredMethods()
             * Method getDeclaredMethod(String name, 类<?>... parameterTypes)
         */
        /*
            注意获取方法时需要由方法名和参数列表来确定
         */
        //获取指定名称的方法
        Method eat_method = personClass.getMethod("eat");
        Person p = new Person();
        //执行方法
        eat_method.invoke(p);


        Method eat_method2 = personClass.getMethod("eat", String.class);
        //执行方法
        eat_method2.invoke(p,"饭");

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

        //获取所有public修饰的方法   注意：这里获取的类包含Object中的类
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.print(method);
            String name = method.getName();
            System.out.println(name);
            //method.setAccessible(true);
        }
        //获取全类名
        String className = personClass.getName();
        System.out.println(className);//cn.helin.domain.Person
    }
}

结果：
在这里插入图片描述

husky105

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
框架设计的灵魂——反射

反射将类的各个组成部分封装为其他对象，这就是反射机制好处可以在程序运行过程中，操作这些对象。可以解耦，提高程序的可扩展性。Java代码在计算机中经历的三个阶段获取Class对象的方式Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象（多用于配置文件，将类名定义在配置文件中。读取文件，加载类）类名.class：通过类名的属性class获取（多用于参数的传递）对象.getClass()：getClass()方法在Object类中定义着。（多用于对象的获
复制链接

扫一扫