学习笔记——JAVA反射<1>反射机制的介绍和基本操作

reflect
1，反射机制
2，动态编译
3，动态执行javascript代码
4，动态字节码操作

动态语言：程序运行的时候仍然能够改变程序的结构或变量的类型
反射机制：
1>运行时加载，探知，使用编译期间完全未知的类
2>程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已经加载的类，都能够知道这个类的所有属性和方法，对于任何一个对象，都能够调用他的任意一个方法和属性
Class c =Class.forName(“com.bjsxt.test.User”);
3>加载完类之后，在对内存中，就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类结构信息。我们可以通过这个对象看到类结构。这个对象就像一面镜子，透过这个镜子可以看到类的结构，所以，我们成为：反射

测试各种获取java.lang.Class对象的获取方式

package study;

/**
 * 测试java.lang.Class对象的获取方式
 * 
 * @author http://blog.csdn.net/thewaiting/
 *
 */
public class ReflectionDome {
    public static void main(String[] args) {
        String path = "study2.User";
        try {
            Class clazz = Class.forName(path);
            System.out.println(clazz);

            Class strClazz = String.class;

            Class strClazz2 = path.getClass();

            Class intClazz = int.class;

            int[] arr01 = new int[10];
            int[] arr02 = new int[30];
            int[][] arr03 = new int[10]不一样  
            System.out.println(arr01.getClass().hashCode());//一样
            System.out.println(arr02.getClass().hashCode());

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

package study2;

public class User {
    private int id;
    private int age;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    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;
    }
    public User() {

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


}

应用反射获取类的信息(类的名字，属性，方法，构造器)

package study;

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

/**
 * 应用反射获取类的信息(类的名字，属性，方法，构造器)
 * 
 * @author http://blog.csdn.net/thewaiting/
 *
 */
public class ReflectionDome {
    public static void main(String[] args) throws NoSuchFieldException, SecurityException, NoSuchMethodException {
        String path = "study2.User";
        try {
            Class clazz = Class.forName(path);
            System.out.println(clazz);
            //获取包名+类名
            System.out.println(clazz.getName());
            //获得类名
            System.out.println(clazz.getSimpleName());
            //获得属性
            Field[] fields=clazz.getDeclaredFields();//获得所有field
            Field[] fields2 = clazz.getFields();//获得public的field
            Field field = clazz.getDeclaredField("name");//获得单个         
            //获得方法
            Method[] method = clazz.getDeclaredMethods();//获得全部方法信息
            Method method2 = clazz.getDeclaredMethod("getName", null);
            Method method3 = clazz.getDeclaredMethod("setName", String.class);//区分重载的方法
            //获得构造器
            Constructor[] constructors = clazz.getDeclaredConstructors();//获取所有构造器
            Constructor constructor = clazz.getConstructor(null);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

通过反射动态的操作：构造器，方法，属性

package study;

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

import study2.User;

/**
 * 通过反射动态的操作：构造器，方法，属性
 * @author http://blog.csdn.net/thewaiting/
 *
 */
public class ReflectionDome {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException,
            SecurityException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
        String path = "study2.User";
        try {
            Class clazz = Class.forName(path);
            // 通过动态调用构造的方法，构造方法
            // 无参
            User user = (User) clazz.newInstance();// 其实是调用了无参构造器
                                                    // javabean必须要有无参构造的与纳音
            // 有参
            Constructor<User> constructor = clazz.getDeclaredConstructor(int.class, int.class, String.class);
            User user2 = constructor.newInstance(10, 21, "Tom");
            // 测试
            System.out.println(user2.getName());
            // 通过反射调用普通方法
            User user3 = (User) clazz.newInstance();
            Method method = clazz.getDeclaredMethod("setName", String.class);
            method.invoke(user3, "Jack");// 激活
            System.out.println(user3.getName());
            // 通过反射操作属性
            User user4 = (User) clazz.newInstance();
            Field field = clazz.getDeclaredField("name");
            field.setAccessible(true);//这个属性不需要做安全检查了，可以直接访问
            field.set(user4, "Amy");

            System.out.println(user4.getName());
            System.out.println(field.get(user4));//反射调用
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}