java 使用反射小结

版权声明：本文为博主原创文章，转载请标明地址。欢迎关注微信订阅号：PM实验室。 https://blog.csdn.net/plain_maple/article/details/62036947

简介：

JAVA反射机制是在程序运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意属性和方法；这种动态获取信息以及动态调用对象方法的功能称为 java 的反射机制。

本文总结了 java 反射的基本使用方法，不涉及反射机制原理。

动态加载类

People 接口：

public interface People {
    public void eat();
}

接口实现类 Student ：

public class Student implements People {

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

主类 Test ：

public class Test {
    public static void main(String[] args) {
        try {
            String classStr = "com.pm.Student";
            Class mClass = Class.forName(classStr);
            People p = (People) mClass.newInstance();
            p.eat();
        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
            e.printStackTrace();
        }
    }
}

输出：

sudent eat

获取类的方法和成员变量

Car 类：

public class Car {
    private boolean window;
    private String wheel;

    public Car() {}

    public Car(boolean window, String wheel) {
        this.window = window;
        this.wheel = wheel;
    }

    public void dirve(String driverName) {
        System.out.println(driverName+"：皮皮虾，我们走！");
    }
}

ClassUtil ，封装获取类的方法和属性的方法：

public class ClassUtil {

    public static void getClassMethod(Object obj) {
        Class mClass = obj.getClass();
        System.out.println("类名：" + mClass.getName());
        //获取所有的public方法，包括继承而来的
        //Method[] ms = mClass.getMethods();
        //获取该类自己声明的方法，不管访问权限
        Method[] ms = mClass.getDeclaredMethods();
        for (Method m : ms) {
            Class returnType = m.getReturnType();
            System.out.println("返回类型：" + returnType.getName());
            System.out.println("方法名：" + m.getName());
            Class[] paramTypes = m.getParameterTypes();
            for (Class paramType : paramTypes) {
                System.out.println("参数类型:" + paramType.getName());
            }
        }
    }

    public static void getClassField(Object obj) {
        Class mClass = obj.getClass();
        //获取所有的public成员变量
        //Field[] fields = mClass.getFields();
        //获取该类自己声明的成员变量
        Field[] fields = mClass.getDeclaredFields();
        for (Field f : fields) {
            Class fieldType = f.getType();
            System.out.println("变量类型：" + fieldType.getName() + " 变量名：" + f.getName());
        }
    }
    
    public static void getClassCon(Object obj) {
        Class mClass = obj.getClass();
        Constructor[] ms = mClass.getConstructors();

        for (Constructor m : ms) {
            Class[] paramTypes = m.getParameterTypes();
            for (Class paramType : paramTypes) {
                System.out.println("构造方法参数类型:" + paramType.getName());
            }
        }
    }
}

测试类，Test2 ：

public class Test2 {
    public static void main(String[] args) {
        //获取类的普通方法、 成员变量、构造方法
        try {
            Class mClass = Class.forName("com.pm.Car");
            Car c = (Car) mClass.newInstance();
            ClassUtil.getClassMethod(c);
            ClassUtil.getClassField(c);
            ClassUtil.getClassCon(c);
        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
            e.printStackTrace();
        }

    }
}

输出：

类名：com.pm.Car
返回类型：void
方法名：dirve
参数类型:java.lang.String
变量类型：boolean 变量名：window
变量类型：java.lang.String 变量名：wheel
构造方法参数类型:boolean
构造方法参数类型:java.lang.String

方法反射的基本操作

Test3 类：

扫描二维码关注公众号，回复： 5850078 查看本文章

public class Test3 {
    public static void main(String[] args) {
        try {
            Car car = new Car();
            Class c = car.getClass();
            //获取dirve方法
            Method m = c.getMethod("dirve", String.class);
            //方法的反射操作
            m.invoke(car, "pm");
        } catch ( NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

输出：

pm：皮皮虾，我们走！