Java反射的基本应用——代码详解

Java反射的基本应用——代码详解

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


public class ReflectTest2 {

    public static void main(String[] args)
            throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException,
            IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {

        /************** 获取Class的三种方法 **************/


        // first way Access
        Access access = new Access();
        Class c1 = access.getClass();
        // second way
        Class c2 = Access.class;
        // third way
        Class c3 = Class.forName("***.***.***.Access");//带完整包名

        // 获取类的反射 反射得到的类型为Class
        Class c = Access.class;
        // 实例化Class c
        Object o = c.newInstance();


        /************** 获取对象的属性(field) **************/


        // --- 获取对象中一个名为pub_name的属性(此方式只可访问由public修饰的)
        Field field = c.getField("pub_name");

        // 获取属性的名字
        System.out.println(field.getName());
        // 获取属性的修饰符
        System.out.println(field.getModifiers());
        // 获取属性类型
        System.out.println(field.getType());
        // 获取属性值
        System.out.println(field.get(o));

        // --- 获取对象中全部的public修饰的属性

        Field[] fields = c.getFields();
        // 通过增强for遍历输出
        for (Field f1 : fields) {
            System.out.println(f1);
        }

        // --- 获取对象中所有访问权限的属性

        Field field2 = c.getDeclaredField("pro_name");
        System.out.println(field2.isAccessible());
        System.out.println(field2.getName());
        System.out.println(field2.getModifiers());
        // 获取属性值时 需要通过setAccessible()取消对Java访问控制的检查
        field2.setAccessible(true);
        // 所有get(Object o)带参的方法均有Java访问控制检查
        System.out.println(field2.get(o));

        // --- 获取对象中全部的所有访问权限的属性

        Field[] fields2 = c.getDeclaredFields();
        // 通过增强for遍历输出
        for (Field f2 : fields2) {
            System.out.println(f2);
        }


        /************** 获取对象的方法 (method) **************/


        // --- 调用public修饰的无参的方法
        Method method = c.getMethod("run");
        method.invoke(o);

        // --- 调用public修饰的有参的方法
        // first way
        Method method2 = c.getMethod("say", String.class, int.class);
        method2.invoke(o, "hello", 18);
        // second way
        Method method3 = c.getMethod("say", new Class[] { String.class, int.class });
        method3.invoke(o, new Object[] { "Hello", 18 });

        // --- 调用所有修饰符修饰的方法

        // see方法是由protected修饰符修饰的 因为本类与Access属于同包,因此public protected
        // defult修饰的方法可以直接访问
        Method method4 = c.getDeclaredMethod("see");
        method4.invoke(o);
        // private方法是由private修饰符修饰的
        // 因为本类没有对Access的private的访问权限，因此需要通过方法取消Java语言访问控制的检查
        Method method5 = c.getDeclaredMethod("talk");
        method5.setAccessible(true);
        method5.invoke(o);

        // --- 返回全部的方法
        Method[] methods = c.getMethods();
        for (Method m1 : methods) {
            System.out.println(m1);
        }

        // --- 返回全部的方法 不包含父类的
        Method[] methods2 = c.getDeclaredMethods();
        for (Method m2 : methods2) {
            System.out.println(m2);
        }


        /*********** 获取对象的构造器 (Constructor) ***********/


        // --- 调用无参的构造器
        Constructor con1 = c.getConstructor();
        // 用构造器创造对象实例
        Object o2 = con1.newInstance();

        // --- 调用有参的构造器
        Constructor con2 = c.getConstructor(new Class[] { String.class });
        Object o3 = con2.newInstance(new Object[] { "tom" });

        // --- 调用private修饰的(所有修饰符修饰的)构造器
        // Access(int prameter)是private修饰符修饰的构造器
        // 因为本类没有对Access的private的访问权限，因此需要通过方法取消Java语言访问控制的检查
        Constructor con3 = c.getDeclaredConstructor(new Class[] { int.class });
        con3.setAccessible(true);
        Object o4 = con3.newInstance(new Object[] { 1 });

        // --- 返回全部的构造器
        Constructor[] cons = c.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }

    }

}



public class Access {
    public  String pub_name="pub";

    String def_name="def";

    protected String pro_name="pro";

    private String pri_name="pri";

    public Access() {
        System.out.println("this is no praameter constructor !");
    }

    public Access(String pub_name) {
        System.out.println("this is has praameter constructor !");
    }   

    private Access(int pri_name){
        System.out.println("this is private constructor !");
    }

    public void run(){
        System.out.println("Access..run...");
    }
    public void say(String msg,int age){
        System.out.println("Say--"+msg+"--"+age);
    }
    protected void see(){
        System.out.println("Access..pro...see");
    }
    private void talk(){
        System.out.println("Access..pri...talk");
    }

    public String getPub_name() {
        return pub_name;
    }
    public void setPub_name(String pub_name) {
        this.pub_name = pub_name;
    }
    public String getDef_name() {
        return def_name;
    }
    public void setDef_name(String def_name) {
        this.def_name = def_name;
    }
    public String getPro_name() {
        return pro_name;
    }
    public void setPro_name(String pro_name) {
        this.pro_name = pro_name;
    }
    public String getPri_name() {
        return pri_name;
    }
    public void setPri_name(String pri_name) {
        this.pri_name = pri_name;
    }
    @Override
    public String toString() {
        return "Access [pub_name=" + pub_name + ", def_name=" + def_name + ", pro_name=" + pro_name + ", pri_name="
                + pri_name + "]";
    }

}