Java——浅谈反射

最新推荐文章于 2024-08-08 17:05:21 发布

原创最新推荐文章于 2024-08-08 17:05:21 发布 · 254 阅读

0 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

7 篇文章

订阅专栏

反射

什么是反射？反射做了什么事？反射的特征？

反射是框架的设计的灵魂。
那什么是框架呢？框架就是半成品的软件，可以再框架的基础上进行软件开发。
反射做了什么事呢？
反射机制：将类的各个组成部分封装为其他对象，（很难理解的概念）
我们不妨再这里想想，类是由什么组成的。
类是由属性和行为组成的——说人话就是成员变量和成员方法，当然还有构造方法。
那么，反射特征，或者说反射有什么好处呢？
1. 可以在程序运行过程中，操作这些对象。
2. 可以解耦，提高程序的可扩展性。

那我们了解了反射是么，那我们是不是要了解下反射是怎么做的工作呢?

首先小北，先带着大家的目光先看看，怎么获取Class对象

这里又三种方式去获取Class对象。
1.Class.forName(“类名”):可以看到是Class文件，也就是.java文件编译进内存时，返回的Class对象。
*一般用在什么时候呢，多用于配置文件，将类名定义在配置文件中。
2.类名.class:可以理解为，编译完成后的.class文件，所以通过类名的属性class获取。
*一般用于参数的传递
3.对象.getClass()：getClass()方法在Object类中定义着。
* 多用于对象的获取字节码的方式

小北不妨按照刚刚的123顺序，来写代码参照理解。

我们首先创建一个自定义类，
实例为Person类

public class Person {
    String name;
    int age;

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



    public String getA() {
        return a;
    }

    public void setA(String a) {
        this.a = a;
    }

    public String getB() {
        return b;
    }

    public void setB(String b) {
        this.b = b;
    }

    public String getC() {
        return c;
    }

    public void setC(String c) {
        this.c = c;
    }

    public String getD() {
        return d;
    }

    public void setD(String d) {
        this.d = d;
    }
    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;
    }


    //无参构造方法
    public Person() {
        System.out.println("无参构造方法");
    }

    //一个参数的构造方法
    public Person(String name) {
        this.name = name;
        System.out.println("有参数的构造方法");
    }

    //两个参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("两个参数的构造方法");
    }
    //全参的构造方法
    public Person(String name, int age, String a, String b, String c, String d) {
        this.name = name;
        this.age = age;
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        System.out.println("全参的构造方法");
    }

    //受保护的构造方法
    protected Person(String a,String b,String c){
        this.a = a;
        this.b = b;
        this.c = c;
        System.out.println("受保护的构造方法");
    }
    //私有的构造方法
    private Person(String a,String b){
        this.a=a;
        this.b=b;
        System.out.println("私有的构造方法");
    }


    public void showPerson1(String s){

        System.out.println("调用了：公有的，String参数的showPerson1(): s = " + s);

    }

    protected void showPerson2(){

        System.out.println("调用了：受保护的，无参的showPerson2()");

    }

    void showPerson3(){

        System.out.println("调用了：默认的，无参的showPerson3()");

    }

    private String showPerson4(int age){

        System.out.println("调用了，私有的，并且有返回值的，int参数的showPerson4(): age = " + age);

        return "Person";

    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
}
gs) throws Exception {
        //第一种方式获取,Class对象，forName("全类名")
        Class c1 = Class.forName("reflex.Person");//全类名，包含包名
        System.out.println(c1);

        //第二种方式获取,类名.class
        Class c2 = Person.class;
        System.out.println(c2);

        //第三种方式获取,对象.getClass()
        Person p=new Person();
        Class c3 = p.getClass();
        System.out.println(c3);

        //我们可以比较一下三种方式获取的结果
        System.out.println(c1==c2);//比较一二种方式获取的结果
        System.out.println(c2==c3);//比较二三种方式获取的结果
    }
}

我们可以来看下，实现的结果：
这里写图片描述

介绍下，再反射中Class对象功能

获取成员变量
Field[] getFields() ：获取所有public修饰的成员变量
Field getField(String name) 获取指定名称的 public修饰的成员变量
Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符（Declared）公然的
Field getDeclaredField(String name)

/*
###Class对象功能：
    1. 获取成员变量们
        * Field[] getFields() ：获取所有public修饰的成员变量
        * Field getField(String name)   获取指定名称的 public修饰的成员变量

        * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符（Declared）公然的
        * Field getDeclaredField(String name)

/*
Class对象功能：
    1. 获取成员变量们
        * Field[] getFields() ：获取所有public修饰的成员变量
        * Field getField(String name)   获取指定名称的 public修饰的成员变量

        * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符（Declared）公然的
        * Field getDeclaredField(String name)
 */
public class ReflexDemo1  {
    public static void main(String[] args) throws Exception {

        //首先获取Persen的Class对象
        Class c = Person.class;
        //1.Field[] getFields():获取所有public修饰的成员变量
        Field[] f1 = c.getFields();
        for (Field field:f1) {
            System.out.println(field);
        }
        System.out.println("++++++++++++++++++");
        //2.Field getField(String name)   获取指定名称的 public修饰的成员变量
        Field a = c.getField("a");
        //获取成员变量的值
        Person p=new Person();
        Object value = a.get(p);
        System.out.println(value);//默认值为null
        //设置a的值
        a.set(p,"zs");
        System.out.println(p);

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

        //3.Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符（Declared）公然的
        Field[] declaredFields = c.getDeclaredFields();
        for(Field f:declaredFields){
            System.out.println(f);
        }
        //4.Field getDeclaredField(String name)
        Field c1 = c.getDeclaredField("c");
        //忽略权限修饰符的安全检查
        c1.setAccessible(true);//暴力反射
        Object value2 = c1.get(p);//直接运行会报错
        System.out.println(value2);
      }
    }

这里写图片描述

获取构造方法们
Constructor<>[] getConstructors() 默认无参
Constructor<> getConstructor(类<>… parameterTypes)
Constructor<> getDeclaredConstructor(类<>… parameterTypes)
Constructor<>[] getDeclaredConstructors()

/*
获取构造方法们
        * Constructor<?>[] getConstructors()  默认无参
        * Constructor<T> getConstructor(类<?>... parameterTypes)

        * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
        * Constructor<?>[] getDeclaredConstructors()
 */
public class ReflexDemo2 {
    public static void main(String[] args) throws Exception {
        //首先获取Persen的Class对象
        Class personClass = Person.class;

        //1.Constructor<?>[] getConstructors()  默认无参
        System.out.println("所有public修饰的构造方法==========");
        Constructor[] constructors = personClass.getConstructors();
        for (Constructor cs:constructors){
            System.out.println(cs);
        }

        System.out.println("获取public无参数构造方法===========");
        //2.Constructor<T> getConstructor(类<?>... parameterTypes)
        Constructor constructor = personClass.getConstructor(null);
        System.out.println(constructor);

        System.out.println("获取私有构造方法，并调用==============================");
        //3.Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
        Constructor declaredConstructor = personClass.getDeclaredConstructor(String.class);
        System.out.println(declaredConstructor);

        System.out.println("所有的构造方法(包括：私有、受保护、默认、公有=============");
        //4.Constructor<?>[] getDeclaredConstructors()
        Constructor[] declaredConstructors = personClass.getDeclaredConstructors();
        for (Constructor cs2:declaredConstructors){
            System.out.println(cs2);
        }

    }

}

输出结果：
这里写图片描述

获取成员方法们：
Method[] getMethods()
Method getMethod(String name, 类<>… parameterTypes)
Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<>… parameterTypes)

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

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

 */
public class ReflexDmo3 {
    public static void main(String[] args) throws Exception {

        //首先获取Persen的Class对象
        Class personClass = Person.class;
        System.out.println("获取所有的public方法==================");
        //1.Method[] getMethods()
        Method[] methods = personClass.getMethods();
        for (Method m:methods){
            System.out.println(m);
        }

        System.out.println("获取public的showPerson1()方法=========");
        //2.Method getMethod(String name, 类<?>... parameterTypes)
        Method showPerson1 = personClass.getMethod("showPerson1", String.class);
        System.out.println(showPerson1);
        //创建一个Person对象
        Object o = personClass.getConstructor().newInstance();
        showPerson1.invoke(o,"张三");

        System.out.println("获取所有的方法，包括私有的===============");
        //3.Method[] getDeclaredMethods()
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method dm:declaredMethods){
            System.out.println(dm);
        }

        System.out.println("获取私有的showPerson4()方法============");
        //4.Method getDeclaredMethod(String name, 类<?>... parameterTypes)
        Method showPerson4 = personClass.getDeclaredMethod("showPerson4", int.class);
        System.out.println(showPerson4);

    }
}