java 反射

类加载方法：

所有类的对象都是Class的实例。

类加载时会先加载static静态部分，并且从父类的static到子类static依次加载。

final语句块会作为宏定义被加载到特殊位置。

Person类：

public class Person {
    private String name;
    private int age;

    public Person() {
        // TODO Auto-generated constructor stub
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    public void foo(String s) {
        System.out.println("superman is batman's!!" + "   s");
    }

    public void foo(String s, int i) {
        System.out.println("superman is batman's!!" + "   s" + i);
    }

}

Demo主函数类：

public class ReflectionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person person = new Person();
        Class demo1=null;
        Class demo2=null;
        Class demo3=null;
        try {
            // 通过包名加载类
            demo1 = Class.forName("reflection.Person");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 使用类实例反推类
        demo2 = person.getClass();
        // 使用 “类名.class”加载类
        demo3 = Person.class;
        System.out.println(demo1.getName());
        System.out.println(demo2.getName());
        System.out.println(demo3.getName());
    }

}

输出结果：

reflection.Person
reflection.Person
reflection.Person

使用Class实例化其他类对象：

public static void main(String[] args) throws Exception {
        // 异常未处理
        Class c = null;
        c = Class.forName("reflection.Person");
        Person person = (Person) c.newInstance();
        person.setName("naruto");
        System.out.println("Person.name :" + person.getName());
    }

输出：

Person.name :naruto

这其实是调用Person#Person()默认构造方法，当Person()声明为private私有时，Class.forName()方法会报错。因此在一个类中最好有一个无参构造方法。

通过构造器操作类的有参函数及无参函数：

public static void main(String[] args) {
        Class c = null;
        Person p1;
        Constructor[] cons; // 声明一个构造器数组
        try {
            // 加载Person类
            c = Class.forName("reflection.Person");
            // 通过Class实例化其他对象
            p1 = (Person) c.newInstance();
            p1.setName("naruto");
            System.out.println("p1.name :" + p1.getName());
            // 获取全部构造函数
            cons = c.getConstructors();
            // 构造Person实例，cons数组中的索引值与Person中构造函数声明时的位置有关，如果位置不对应会报错
            Person p2 = (Person) cons[1].newInstance("tom", 21);
            System.out.println("p2.name :" + p2.getName() + "p2.age :"
                    + p2.getAge());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

输出：

p1.name :naruto
p2.name :tomp2.age :21

获取类实现的所有接口：

public static void main(String[] args) {
        try {
            Class<?> c1 = Class.forName("reflection.Person");
            Class<?>[] inters = c1.getInterfaces();
            for (int i = 0; i < inters.length; i++) {
                System.out.println(inters[i].getName());
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

输出：

reflection.InterfaceDemo

通过反射获取类信息：

public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("reflection.Person");
            // 获取Person类的父类
            Class<?> class2 = class1.getSuperclass();
            // System.out.println("父类：" + class2.getName());
            // 获取全部构造方法
            Constructor[] cons = class1.getConstructors();
            for (Constructor constructor : cons) {
                System.out.println("构造方法名:" + constructor.getName());
                // 获取构造方法的访问权限
                int no = constructor.getModifiers();
                System.out.println("访问权限:" + Modifier.toString(no));
                // 每个构造方法的参数
                Class p[] = constructor.getParameterTypes();
                for (int i = 0; i < p.length; i++) {
                    System.out.print(p[i].getName() + "   ");
                }
                System.out.println();
            }
            // 获取类全部方法信息
            Method[] methods = class1.getMethods();
             for (int i = 0; i < methods.length; i++) {
             // 获取该方法返回值类型
             Class<?> retuTypes = methods[i].getReturnType();
             // 获取该方法参数类型
             Class<?>[] paraTypes = methods[i].getParameterTypes();
             // 获取该方法抛出的异常
             Class<?>[] exce = methods[i].getExceptionTypes();
             System.out.println();
             }
            // 获取该类全部非私有的属性信息
            Field[] fields = class1.getFields();
            // 获取该类全部属性信息，包括私有属性
            Field[] fields1 = class1.getDeclaredFields();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

调用其他类的方法：

public static void main(String[] args) {
        try {
            Class<?> demo = Class.forName("reflection.Person");
            Method method = demo.getMethod("foo",String.class,int.class);
            method.invoke(demo.newInstance(),"haha",32);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

如果方法访问修饰符为private需要修改访问权限

public static void main(String[] args) {
        try {
            Class<?> demo = Class.forName("reflection.Person");
            //getDeclaredMethod()可以访问所有方法，不管方法的访问修饰符是什么
            Method method=demo.getDeclaredMethod("fun");
            //如果方法访问修饰符为private需要修改访问权限
            method.setAccessible(true);
            method.invoke(demo.newInstance());
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

访问用private修饰的字段也需要修改访问权限：

public static void main(String[] args) {
        try {
            Class<?> demo = Class.forName("reflection.Person");
            Field field=demo.getDeclaredField("name");
            field.setAccessible(true);
            Person p=(Person) demo.newInstance();
            field.set(p, "pepelu");
            System.out.println(field.get(p));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }