java 反射机制 笔记

一，什么是反射机制　　

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

简单一点说：只要给我类的全名称（包名+类名），就可以使用该类的属性，方法，构造方法。

（以下方法来自Class类）
二，获取构造方法常用方法

Constructor<T> getConstructor(Class<?>... parameterTypes) 
返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。 
Constructor<?>[] getConstructors() 
返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。

Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。 
Constructor<?>[] getDeclaredConstructors() 
返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。 

三，获取属性常用方法

Field getDeclaredField(String name) 
返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。 
Field[] getDeclaredFields() 
返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。 
Field getField(String name) 
返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。 
Field[] getFields() 
返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。

四，获取方法

Field[] getDeclaredFields() 
返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。 
Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 
Method getMethod(String name, Class<?>... parameterTypes) 
返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。 
Method[] getMethods() 
返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。

做一下总结：　

      带有Declared的方法可以获取所有权限修饰的要反射类的方法方法属性构造方法
      不带有Declared的方法只能获取到public修饰的要反射类的方法

 下面看一下代码：

我们要对Person类进行反射

package cn.haoju.reflections;

public class Person {
    
    private String name;
    private int age;
    
    private Person() {
        
    }

    private Person(String name) {
        this.name = name;
    }
    
    @SuppressWarnings("unused")
    private void sayHello() {
        System.out.println("say hello");
    }

    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 "Person [name=" + name + ", age=" + age + "]";
    }    
    
}

获取构造方法：

package cn.haoju.reflections;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ConstructorDemo {
    
    public static void main(String[] args) throws Exception {
        String className = "cn.haoju.reflections.Person";//Person类的全名称
        Class pClass = Class.forName(className);
         getDeclaredConstructors(pClass);
         getDeclaredConstructor(pClass);
         getConstructors(pClass);        
         getConstructor(pClass);
    }

    /**
     *  获取公共的指定参数的构造方法
     * @param pClass
     * @throws NoSuchMethodException
     */
    private static void getConstructor(Class pClass)
            throws NoSuchMethodException {
        Constructor constructor = pClass.getConstructor(String.class);
        System.out.println(constructor);//为空
    }

    /**
     * 获取公共的所有构造方法
     * @param pClass
     */
    private static void getConstructors(Class pClass) {
        Constructor[] constructors = pClass.getConstructors();
        for(Constructor constructor : constructors) {
            System.out.println(constructor);//为空
        }
    }

    /**
     * 通过制定的构造方法参数来获取被反射对象的实例
     * 
     * @param pClass
     * @throws Exception
     */
    private static void getDeclaredConstructor(Class pClass) throws Exception {
    
        Constructor constructor = pClass.getDeclaredConstructor(String.class);
        System.out.println(constructor);
        // private cn.haoju.reflections.Person(java.lang.String)
        constructor.setAccessible(true);// 取消 Java 语言访问检查
        Object obj = constructor.newInstance("lihao");// IllegalAccessException
        System.out.println(obj);
        //打印的数据
        // Person [name=lihao, age=0]
    }

    /**
     * 通过getDeclaredConstructors 获取构造方法    
     * @param pClass
     */
    private static void getDeclaredConstructors(Class pClass) {    
        Constructor[] constructors = pClass.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        //打印的数据
        // private cn.haoju.reflections.Person(java.lang.String)
        // private cn.haoju.reflections.Person()

    }

}

获取字段：

package cn.haoju.reflections;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class FieldDemo {
    
    public static void main(String[] args) throws Exception {
        String className = "cn.haoju.reflections.Person";
        Class<?> pClass = Class.forName(className);
        getDeclaredFields(pClass);
        getFields(pClass);
        setField(pClass);
    }
    
    /**
     * 设置指定的属性  值
     * @param pClass
     * @throws Exception
     */
    private static void setField(Class<?> pClass) throws Exception {        
        
        //获取空的构造方法
        Constructor constructor = pClass.getDeclaredConstructor(null);        
        constructor.setAccessible(true);
        //得到Person实例
        Object obj = constructor.newInstance(null);
        
        //设置name 属性值
        Field field = pClass.getDeclaredField("name");
        field.setAccessible(true);//取消java语言的异常检查
        field.set(obj, "李浩");        
        
        //设置age 属性值
        Field ageField = pClass.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj, 12);
        
        System.out.println(obj);//Person [name=李浩, age=12]
    }
    
    
    /**
     * 获取公有的
     * @param pClass
     */
    private static void getFields(Class<?> pClass) {
        Field[] fields = pClass.getFields();
        for(Field field : fields) {
            System.out.println(field);
        }
    }
    
    /**
     * 获取所有的属性
     * @param pClass
     */
    private static void getDeclaredFields(Class<?> pClass) {
        Field[] fields = pClass.getDeclaredFields();
        for(Field field : fields) {
            System.out.println(field);
        }
        
        //获取到的字段命名
       // private java.lang.String cn.haoju.reflections.Person.name
       // private int cn.haoju.reflections.Person.age
    }

}

获取方法：

package cn.haoju.reflections;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class MethodDemo {
    public static void main(String[] args) throws Exception {
        String className = "cn.haoju.reflections.Person";
        Class pClass = Class.forName(className);
        
        getDeclaredMethods(pClass);
        
        userMethod(pClass);
    }

    /**
     * 反射方法是用
     * @param pClass
     * @throws Exception
     */
    private static void userMethod(Class pClass) throws Exception {
        //工作构造方法拿到Person实例
        Constructor constructor = pClass.getDeclaredConstructor(null);
        constructor.setAccessible(true);        
        Object person = constructor.newInstance(null);
        
        Method method2 = pClass.getDeclaredMethod("sayHello", null);
        method2.setAccessible(true);
        method2.invoke(person , null);//执行该方法 say hello
        
        Method method3 = pClass.getDeclaredMethod("setName", String.class);
        method3.invoke(person, "lisan");
        Method method4 = pClass.getDeclaredMethod("getName", null);
        Object retrun = method4.invoke(person, null);//返回retrurn的结果
        System.out.println(retrun); //lisan
    }

    /**
     * 获取该反射类的所有的公共方法（包括父类的）
     * @param pClass
     */
    private static void getMethods(Class pClass) {
        Method[] methods = pClass.getMethods();
        for(Method method:methods) {
            System.out.println(method);
        }
        
//        public int cn.haoju.reflections.Person.getAge()
//        public void cn.haoju.reflections.Person.setAge(int)
//        public java.lang.String cn.haoju.reflections.Person.toString()
//        public java.lang.String cn.haoju.reflections.Person.getName()
//        public void cn.haoju.reflections.Person.setName(java.lang.String)
//        public final native java.lang.Class java.lang.Object.getClass()
//        public native int java.lang.Object.hashCode()
//        public boolean java.lang.Object.equals(java.lang.Object)
//        public final native void java.lang.Object.notify()
//        public final native void java.lang.Object.notifyAll()
//        public final void java.lang.Object.wait() throws java.lang.InterruptedException
//        public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
//        public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException

    }

    /**
     * 获取改反射类的所有的方法
     * @param pClass
     */
    private static void getDeclaredMethods(Class pClass) {
        Method[] methods = pClass.getDeclaredMethods();
        for(Method method:methods) {
            System.out.println(method);
        }
//        private void cn.haoju.reflections.Person.sayHello()
//        public int cn.haoju.reflections.Person.getAge()
//        public void cn.haoju.reflections.Person.setAge(int)
//        public java.lang.String cn.haoju.reflections.Person.toString()
//        public java.lang.String cn.haoju.reflections.Person.getName()
//        public void cn.haoju.reflections.Person.setName(java.lang.String)
    }
}

java 反射基本使用就这么多了