能让小白10分钟就理解Java反射的文章 超详细

反射机制

概述

编程可以分为动态语言和静态语言，我们常见的动态语言有PHP,C#，JavaScript
静态语言就是 Java c/c++
所谓的动态语言，就是可以在它运行的时候，来做出一些操作，可以修改它的执行内容

而反射机制的加入，使Java成为了一个准动态语言

本文内容

1. 获取对象
2. 获取构造器
3. 获取属性
4. 获取方法
5. 给属性赋值
6. 调用方法

获得对象

反射机制如何获取一个对象？？？，我们在pojo包下新建一个Test类

package live.fanxing.reflection.pojo;

public class Test {
    String name;
    int 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 "Test{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Class.forName()

通过包的路径来获取一个类

Class test1 = Class.forName("live.fanxing.reflection.pojo.Test");

.Class()

根据一个类名后面跟 .class可以获取到

Test.class

.getClass

把这个class创建一个新的实例，然后通过getClass方法来获取

new Test().getClass()

然后我们测试一下

package live.fanxing.reflection;

import live.fanxing.reflection.pojo.Test;

public class Reflection01 {
    public static void main(String[] args) throws ClassNotFoundException {
        test();
    }
    static void test() throws ClassNotFoundException {

        System.out.println(Class.forName("live.fanxing.reflection.pojo.Test"));
        System.out.println(new Test().getClass());
        System.out.println(Test.class);
    }

}

可以看到，我们通过这三种方法获取到了，但是我们发现打印出来的结果都是一样的，这说明了说明？？

在java中，不管是创建的实例还是什么，它只有一个Class保存到了堆中，创建实例，反射获取，静态获取都是获取的这个class

获取构造器

首先，我们在Test类上加两个构造器，一个无参，一个有参，一个public，一个private

public Test(){

}

private Test(String name,int age){
    this.name = name;
    this.age = age;
}

获取全部构造器

Class对象中给我们提供了两个常用的方法来获取构造器 getConstructors()和getDeclaredConstructors()

使用 getConstructors()会获取到当前类的全部为public类型的构造器

使用getDeclaredConstructors() 会获取到当前类的全部构造器，包括private和public

我们下面写代码来测试一下看看

Class test1 = Class.forName("live.fanxing.reflection.pojo.Test");

Constructor[] constructors = test1.getConstructors();
for (Constructor constructor : constructors) {
    System.out.println(constructor);
}

Constructor[] constructors1 = test1.getDeclaredConstructors();
for (Constructor constructor : constructors1) {
    System.out.println("declared:"+constructor);
}

在看下运行的结果

我们看到上方的图片，可以看出来，第一个循环只打印了public类型的无参构造器，第二个循环打印出来了 无参和有参

获取指定构造器

获取指定构造器，根据构造器的参数样式来获取构造器，可以使用getConstructor()和getDeclaredConstructor()

这两个方法其实和上面的区别一样，一个获取public，一个获取全部

这两个方法里面有个parameterTypes参数，为什么要有参数呢？？

想想我们有参和无参构造器是用什么区别的，参数个数，和参数的类型，这个参数是让我们传入它这些构造器的参数的类型

用代码来演示下，我们用getConstructor()测试下

Constructor constructors = test1.getConstructor(null);  //这一行是获取到的是无参构造器，因为它里面没有任何参数，所以我们填入null
Constructor constructors1 = test1.getConstructor(String.class,int.class);//这个是获取到有参构造器的，我们有参构造器里有两个参数，一个是String类型的一个是int类型的，所以我们传入String.class,int.class，如果是其他类型的话，就传入其它的那个类型就行

我们看下打印的截图

我们可以看到报错了，报错的行数在第25行，也就是获取到有参构造器的时候，不要忘了，我们的有参构造器是私有的，这个

getConstructor()方法是获取不到私有的，我们把第25行改成下面的代码

Constructor constructors1 = test1.getDeclaredConstructor(String.class,int.class);

然后我们加两个打印，把constructors和constructors1打印到控制台，在看看

获取属性

获取全部属性

获取属性也有Declared和不加Declared区分，通过上面获取构造器，我们也可以很快的认识到getFields()和getDeclaredFields()的区别

我们将Test类中的 name属性改成public类型的

public String name;
int age;

然后在用这两个方法获取的属性然后进行遍历

Field[] fields = test1.getFields();
Field[] fields1 = test1.getDeclaredFields();

for (Field field : fields) {
    System.out.println(field);
}
System.out.println("========");
for (Field field : fields1) {
    System.out.println(field);
}

然后我们在查看打印到控制台的效果

获取指定属性

获取指定的属性也就是把上面获取全部属性的方法最后的s给去掉就行，然后会有一个name的参数，我们应该填写这个属性的名称，比如说获取name

因为name是public类型的，getField() 方法也可以获取到

Field field = test1.getField("name");
Field field1 = test1.getDeclaredField("name");
System.out.println(field);
System.out.println("field1:"+field1);
System.out.println("================");
//但是我们在试试获取到age,我们调整下顺序，把declared的方法放上面，不加这个的那个方法肯定会报错
Field field3 = test1.getDeclaredField("age");
System.out.println("field3:"+field3);
Field field2 = test1.getField("age");
System.out.println("field2:"+field2);

获取方法

获取全部方法

获取方法也和上方一样，有declared的区别，它也有两个方法 ，只不过这两个方法的区别与上面有相同处也有不同处

Method[] method = test1.getMethods();
for (Method method1 : method) {
    System.out.println(method1);
}
System.out.println("================");
Method[] methods = test1.getDeclaredMethods();
for (Method method1 : methods) {
    System.out.println(method1);
}

看下控制台图片

getMethods()方法会把父类的所有public方法也一块获取到，但是所有的private方法是获取不到的

getDeclaredMethods() 会获取到本类中的所有方法，包括private

获取指定方法

Method method = test1.getMethod("TestFather",null); //取父类
Method method1 = test1.getMethod("setName",String.class);//取当前类中的public方法
Method method2 = test1.getDeclaredMethod("setAge",int.class); //取本类中的公有方法
System.out.println(method);
System.out.println(method1);
System.out.println(method2);

用反射创建一个实例

创建实例我们需要使用到newInstance()方法，我们还用上方的test1这个Class对象，用它来创建一个Test的实例

直接用Class对象创建

Test a =  (Test) test1.newInstance();
System.out.println(a);

使用构造器来创建

使用 Class对象直接创建的话，我们可以看到输出的name为null，这说明它使用了无参构造器的方法来创建了，那么我们怎么用有参构造器来创建？？

// 1.先获取到它的构造器，
Constructor constructors1 = test1.getDeclaredConstructor(String.class,int.class);
System.out.println(constructors1);

// 2.用这个构造器来创建一个实例
Test b = (Test)constructors1.newInstance("fanxing",18);
System.out.println(b);

然后我们看下这两种办法打印的结果

用反射给属性赋值

上面一步我们已经创建好新的实例了，我们这次使用构造器创建的实例，把它的age给改了

Test b = (Test)constructors1.newInstance("fanxing",18);
System.out.println(b);

Field field = test1.getDeclaredField("age");

field.setInt(b,20);
System.out.println(b.getAge());

可以看到报错了，无法访问类的成员变量。

我们在赋值前，我们加一行代码

field.setAccessible(true);

Constructor constructors1 = test1.getDeclaredConstructor(String.class,int.class);
System.out.println(constructors1);

Test b = (Test)constructors1.newInstance("fanxing",18);
System.out.println(b);

Field field = test1.getDeclaredField("age");
field.setAccessible(true);
field.setInt(b,20);
System.out.println("修改后的年龄为：" + b.getAge());

然后在看下结果

用反射执行方法

本篇最后的内容，通过反射来调用方法

invoke : 执行当前的方法

Method method  = test1.getDeclaredMethod("setAge",int.class);  //获取方法
System.out.println("执行setAge:" + method.invoke(b, 190));  //执行，invoke的参数：第一个是用于哪个实例，后面是它这个方法中的参数，按顺序
Method method1 = test1.getDeclaredMethod("getAge",null);  //因为 getAge没有参数，所以后面的用null
System.out.println("执行getAge:"+ method1.invoke(b,null));