JAVA进阶学习-反射机制_小白学反射-CSDN博客

本文链接：https://blog.csdn.net/MadridBai/article/details/69053381

我自己搭建了个人主页，博客会先在这里更新哦！点这里–>我的个人主页

JAVA 反射机制

Java Reflaction in Action中有这么一句话，反射是运行中的程序检查自己和软件运行环境的能力，它可以根据它发现的进行改变。通俗的讲就是反射可以在运行时根据指定的类名获得类的信息。

平时开发中我们实例化一个类的过程一般是这样的：引入需要的“包类”的名称–>通过new实例化–>取得实例化对象

而JAVA得反射机制允许我们将这个过程反过来：实例化对象–>getClass()方法–>得到完整的“包类”名称

JAVA反射机制提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
生成动态代理

反射机制的使用

我们通过一个简单的例子来说明反射机制的使用：

创建一个Creature类，如下：

public class Creature<T> {

    public double weight;
    public void breath(){
        System.out.println("呼吸！");
    }

}

创建一个Person类继承Creature类,为了让该类复杂一点，我们实现Comparable接口，声明一些简单的属性和方法，如下：

public class Person extends Creature<String> implements Comparable {

    public String name;
    private 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;
    }

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

    public Person() {
        super();
    }

    public Person(String name) {
        super();
        this.name = name;
    }

    public Person(int age) {
        super();
        this.age = age;
    }

    public void show() {
        System.out.println("我是一个人");
    }

    public void display(String nation) {
        System.out.println("我来自：" + nation);
    }

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

    @Override
    public int compareTo(Object o) {

        return 0;
    }

}

在Java中java.lang.Class是反射的源头，我们创建了一个类，通过编译(javac.exe),生成对应的.class文件，之后使用JVM的类加载器加载此.class文件，此.class文件加载到内存之后，就是一个运行时类，会被存放在缓存区，那么这个运行时类本身就是一个Class的实例！

如果类的实现没有发生改变，那么该类的.class文件只会被生成和加载一次，并且一个类在JVM中只会有一个Class实例。

我们创建一个测试类TestReflection来使用JAVA反射机制中的常用方法。

获取Class的实例

@Test
public void test() throws ClassNotFoundException {

        // 1.调用运行时类本身的.class属性
        Class myClass = Person.class;
        System.out.println(myClass.getName());

        // 2.通过运行时类的对象获取
        Person p = new Person();
        Class myClass1 = p.getClass();
        System.out.println(myClass1.getName());

        // 3.通过Class的静态方法获取
        Class myClass2 = Class.forName("test.Person");
        System.out.println(myClass2.getName());

        // 4.通过类的加载器
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class myClass3 = classLoader.loadClass("test.Person");
        System.out.println(myClass3.getName());


    }

四条输出语句输出的结果都是test.Person(包名.类名)，这四种方法在使用上并没有优劣之分。

创建运行时类的对象

@Test
    public void test4() throws ClassNotFoundException, InstantiationException, IllegalAccessException{


        String className = "test.Person";
        Class myClass = Class.forName(className);
        Person p = (Person) myClass.newInstance();//调用无参的构造方法
        p.setAge(10);
        p.setName("Tom");
        System.out.println(p);


    }

输出：

Person [name=Tom, age=10]

获取运行时类的属性

@Test
    public void test5(){

        Class myClass = Person.class;
        //1.获取对应的运行时类的属性
        //(1)getFields()只能获取到运行时类中及其父类中声明为public的属性
        Field[] fields = myClass.getFields();
        for(Field f : fields){
            System.out.println(f);
        }

        System.out.println();

        //(2)getDeclaredFields() 获取运行时类本身声明的所有属性
        Field[] fields1 = myClass.getDeclaredFields();
        for(Field f : fields1){
            System.out.println(f);
        }

        System.out.println();

        //2.获取属性的各个部分的内容
        Field[] fields2 = myClass.getDeclaredFields();
        for(Field f : fields2){
            //变量名
            System.out.print("属性名:"+f.getName());
            //权限修饰符
            int i = f.getModifiers();
            String modifer = Modifier.toString(i);
            System.out.print(" 权限修饰符:"+modifer);
            //变量类型
            System.out.print(" 属性类型:"+f.getType());


            System.out.println();
        }

    }

输出：

public java.lang.String test.Person.name

public double test.Creature.weight

public java.lang.String test.Person.name

private int test.Person.age

属性名:name 权限修饰符:public 属性类型:class java.lang.String

属性名:age 权限修饰符:private 属性类型:int

获取父类和接口

@Test
    public void test6(){

        Class myClass = Person.class;
        Class parentClass = myClass.getSuperclass();
        System.out.println("Person的父类是:"+parentClass.getName());

        Class inters[] = myClass.getInterfaces();
        System.out.print("Person 实现的接口:");
        for(Class c : inters){
            System.out.println(c.getName());
        }

    }

输出：

Person的父类是:test.Creature

Person 实现的接口:java.lang.Comparable

调用运行时类的指定方法

@Test
    public void test7() throws Exception{

        Class myClass = Person.class;

        // 1.创建myClass对应的运行时类Person的对象
        Person p = (Person) myClass.newInstance();

        // 2.通过反射调用运行时类的属性
        // public
        Field f1 = myClass.getField("name");
        f1.set(p, "Tom");

        // 非public
        Field f2 = myClass.getDeclaredField("age");
        f2.setAccessible(true);
        f2.set(p, 10);

        // 3.通过反射调用运行时类的指定方法
        Method m1 = myClass.getMethod("show");
        m1.invoke(p);
        Method m2 = myClass.getMethod("display", String.class);
        m2.invoke(p, "US");

        System.out.println(p);

    }

输出：

我是一个人

我来自：US

Person [name=Tom, age=10]

动态代理

在JAVA中要实现动态代理就要用到反射机制的特性，代码如下：

//业务接口
interface Subject {
    void action();
}

// 业务接口实现类
class RealSubject implements Subject {

    public void action() {
        System.out.println("我是被代理类");
    }

}

// 动态的代理类
class MyInvocationHandler implements InvocationHandler {

    Object obj;

    // 给被代理类的对象实例化，返回一个代理类的对象
    public Object blind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
    obj.getClass().getInterfaces(), this);
    }

    // 当通过代理类的对象发起对被重写的方法的调用时，都会转化为对如下的invoke方法的调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnVal = method.invoke(obj, args);
        return returnVal;
    }

}

public class TestProxy {

    public static void main(String[] args) {

        // 被代理对象
        RealSubject real = new RealSubject();
        // 创建一个实现了InvocationHandler接口的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        // 调用blind方法，动态的返回一个同样实现了real所在类实现的接口的代理类的对象
        Object obj = handler.blind(real);
        Subject sub = (Subject) obj;// 此时sub就是代理类对象
        sub.action();// 调用的是MyInvocationHandler类的invoke方法

    }

}