java反射技术

什么是 Reflection 反射，为什么要用它

Java 强类型语言，但是我们在运行时有了解、修改信息的需求，包括类信息、成员信息以及数组信息。

---

反射的入口：java.lang.Class

对每一种对象，JVM 都会实例化一个 java.lang.Class 的实例，java.lang.Class 为我们提供了在运行时访问对象的属性和类型信息的能力。Class 还提供了创建新的类和对象的能力。最重要的是，Class 是调用其他反射 API 的入口，我们必须先获得一个 Class 实例才可以进行接下来的操作。

---

几种得到Class对象的三种方法（返回值全为Class）

1. Class.forName([包名+类名])方法

2. [对象名].getClass 方法

3. [类名].class 方法

---

具体使用

Class.forName()方法

如果我们有一个类的完整路径，就可以使用 Class.forName(“类完整的路径”) 来得到相应的 Class，这个方法只能用于引用类型

---

接口

public interface fruit {
    boolean plant=true;
    public void fun1();
}

实现

public class APPLE implements fruit {
    public String color = "Red";
    private String Version = "HFS";
    static boolean isForEat = true;

    public String getVersion() {
        return Version;
    }
    public void setVersion(String version) {
        Version = version;
    }
    @Override
    public void fun1() {
        System.out.println("你可以修改我不");
    }

    void fun2() {
        System.out.println("我想你不能");
    }

    APPLE() {
    }

    public APPLE(String color) {
        this.color = color;
    }

    public APPLE(String color, String Version) {
        this.color = color;
        this.Version = Version;
    }
    public static void fun3(){
        System.out.println("这是静态方法");
    }
}

反射代码>获取方法，接口，方法等

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class reflectTest {
    //此方法用于获取类
    public static void getReflectClass() {
        //创建一个对象
        APPLE apple = new APPLE();

        //Class.forName方法获得Class(推荐)
        Class tmp1 = null;
        try {
            tmp1 = Class.forName("reflection.APPLE");
            System.out.println(tmp1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //通过[对象名].getClass方法获得Class
        Class tmp2 = apple.getClass();
        System.out.println(tmp2);

        //通过[类名].class方法获得Class
        Class tmp3 = APPLE.class;
        System.out.println(tmp3);
    }

    //此方法用于获取方法
    public static void getClassMethod() {
        //创建一个对象
        APPLE apple2 = new APPLE();
        //Class.forName方法获得Class(推荐)
        Class C = null;
        try {
            C = Class.forName("reflection.APPLE");
        } catch (Exception e) {
            e.printStackTrace();
        }

        //获取此类的公共方法（本类和父类或父接口的方法。拿不到私有方法）
        Method[] methods = C.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("======================");
        //获取当前类的所有方法(不涉及父类方法)
        methods = C.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
    }

    //拿到所有的接口
    public static void getAllInterface() {
        //Class.forName方法获得Class(推荐)
        Class tmp1 = null;
        try {
            tmp1 = Class.forName("reflection.APPLE");
        } catch (Exception e) {
            e.printStackTrace();
        }
        Class[] interfaces = tmp1.getInterfaces();
        for (Class inter : interfaces) {
            System.out.println(inter);
        }
    }

    public static void createNewInstance() throws Exception {
        //Class.forName方法获得Class(推荐)
        Class tmp1 = null;
        try {
            tmp1 = Class.forName("reflection.APPLE");
        } catch (Exception e) {
            e.printStackTrace();
        }
        APPLE apple = (APPLE) tmp1.newInstance();
        apple.fun1();
    }

    public static void getAllFields() {
        //Class.forName方法获得Class(推荐)
        Class tmp1 = null;
        try {
            tmp1 = Class.forName("reflection.APPLE");
        } catch (Exception e) {
            e.printStackTrace();
        }
        //拿到所有的公共属性(getFields只能看到本类和父类的共有属性，只有带了public才能看到)
        Field[] fields = tmp1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("=================");
        //拿到本类的所有属性
        fields = tmp1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }


    }


    public static void main(String[] args) {
//        getClassMethod();
//        getAllInterface();
//        getAllFields();
//        System.out.println("类名称：" + tmp1.getName());
        try {
            createNewInstance();
        } catch (Exception E) {
            E.printStackTrace();
        }

    }
}

修改属性，调用方法：

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

import static java.lang.Class.forName;

public class modifyObject {
    APPLE apple1=new APPLE("Yellow");

//    修改属性
    public void modifyField(){
        try {
//            获得Class
            Class appleClass=Class.forName("reflection.APPLE");
//            获得某一属性
            Field field=appleClass.getField("color");

//            获得所有属性
            Field[] fields=appleClass.getDeclaredFields();
            for(Field field1:fields){
                System.out.println(field);
            }
//            public java.lang.String reflection.APPLE.color
//            private java.lang.String reflection.APPLE.Version
//            static boolean reflection.APPLE.isForEat
//            修改public属性
            fields[0].set(apple1,"RED");
//            修改private属性
            fields[1].setAccessible(true);
            fields[1].set(apple1,"Pink");
//            修改static属性
            fields[2].set(apple1,false);

        }catch (Exception E){
            E.printStackTrace();
        }
    }

//    修改方法
    public void modifyMethod() throws InvocationTargetException, IllegalAccessException {
        Class AppleClass= null;
        try {
            AppleClass=Class.forName("reflection.APPLE");
        }catch (Exception e){
            e.printStackTrace();
        }
        Method[] methods=AppleClass.getDeclaredMethods();
        for (Method method:methods){
            System.out.println(method);
        }
//        方法的调用
        methods[3].invoke(apple1,null);

    }
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {
        new modifyObject().modifyMethod();
    }
}