Java学习笔记——反射机制

JAVA反射机制的概念

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

反射机制的功能

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

对于反射机制的功能，Class类提供了很多方法，可以通过API查阅。http://docs.oracle.com/javase/8/docs/api/index.html

获取Class对象（Class对象也就是类名）

• 使用Class类的forName()静态方法。
• 调用某个类的class属性获取相应的Class类。
• 调用某个对象的getClass()方法。

package test1;

/**
 * Created by zengzehao on 17-5-2.
 */
public class ReflectionTest {
    public static void main(String[] args) throws Exception{
        Class class1 = null;
        Class class2 = null;
        Class class3 = null;
        class1 = Class.forName("test1.ReflectionTest");  //使用Class.forName()方法,必须e的是完整包名，否则会找不到相应的类
        class2 = ReflectionTest.class;  //通过类的class属性
        class3 = new ReflectionTest().getClass();  //通过实例的getClass()方法
        System.out.println(class1.getName());
        System.out.println(class2.getName());
        System.out.println(class3.getName());
    }
    /**
    运行结果：
    test1.ReflectionTest
    test1.ReflectionTest
    test1.ReflectionTest
    */
}

通过反射机制实例化一个类的对象

• 通过class对象的newInstance()方法

package test1;

/**
 * Created by zengzehao on 17-5-2.
 */
public class ReflectionTest2 {
    public static void main(String[] args) throws Exception{
        Class class1 = User.class;
        User user = (User) class1.newInstance();
        user.setAge(20);
        user.setName("Xiaoming");
        System.out.println(user.toString());
        //运行结果User [age=20, name=Xiaoming]
    }
}
class User {
    private int age;
    private String name;
    public User() {
        super();
    }
    public User(String name) {
        super();
        this.name = name;
    }
    public User(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

通过反射机制获取类的所有属性和所有方法

package test1;

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

/**
 * Created by zengzehao on 17-5-2.
 */
public class ReflectionTest3 {
    private int age;
    private String Name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public static void main(String[] args) {
        Class class1 = ReflectionTest3.class;
         Field[] fields = class1.getDeclaredFields();  //获取所有的属性
        for(int i=0;i" "+Modifier.toString(fields[i].getModifiers())+" "+fields[i].getName());
        }
        Method[] methods = class1.getMethods();  //获得所有的方法
        for(int i=0;i" "+Modifier.toString(methods[i].getModifiers())+" "+methods[i].getName());
        }
    }
}
/**
int private age
java.lang.String private Name
void public setAge
int public getAge
void public static main
java.lang.String public getName
void public setName
void public final wait
void public final native wait
void public final wait
boolean public equals
java.lang.String public toString
int public native hashCode
java.lang.Class public final native getClass
void public final native notify
void public final native notifyAll
*/

通过反射机制调用某个类的方法

package test1;

import java.lang.reflect.Method;

/**
 * Created by zengzehao on 17-5-2.
 */
public class ReflectionTest4 {
    public static void main(String[] args) throws Exception {
        Class class1 = ReflectionTest4.class;
        Method method1 = class1.getMethod("method1");
        method1.invoke(class1.newInstance());

        Method method2 = class1.getMethod("method2",int.class,String.class);
        method2.invoke(class1.newInstance(),20,"xiaoming");

    }
    public void method1(){
        System.out.println("Java 反射机制 - 调用某个类的方法1.");
    }
    public void method2(int age,String name){
        System.out.println("Java 反射机制 - 调用某个类的方法2.");
        System.out.println("age="+age+" name="+name);
    }
    /**
     * Java 反射机制 - 调用某个类的方法1.
     Java 反射机制 - 调用某个类的方法2.
     age=20 name=xiaoming
     */
}

通过反射机制操作某个类的属性

package test1;

import java.lang.reflect.Field;

/**
 * Created by zengzehao on 17-5-2.
 */
public class ReflectionTest5 {
    private String proprety = null;
    public static void main(String[] args) throws Exception {
        Class clazz = ReflectionTest5.class;
        Object obj = clazz.newInstance();
        // 可以直接对 private 的属性赋值
        Field field = clazz.getDeclaredField("proprety");
        field.setAccessible(true);
        field.set(obj, "Java反射机制");
        System.out.println(field.get(obj));
        /**
         * 运行结果：Java反射机制
         */
    }
}

动态代理这一部分我不太懂，以后补上