TIII-Android技术篇之反射

构造+属性+方法+访问权限

/**
 * 作者：张风捷特烈
 * 时间：2018/5/6:10:40
 * 邮箱：1981462002@qq.com
 * 说明：反射测试类
 */
public class Person {
    private int age;
    private String name;
    private boolean isMan;
    public String address="beijing";

    public Person() {
        System.out.println("空参构造执行...");
    }

    public Person( String name, int age,boolean isMan) {
        this.age = age;
        this.name = name;
        this.isMan = isMan;
        System.out.println("三参构造执行...");

    }

    public void publicShow() {
        System.out.println("I am " + name + ",I " + age + "years");
    }

    public static void staticShow() {
        System.out.println("staticShow");
    }


    private void privateShow() {
        System.out.println("I am " + name + ",I " + age + "years");
    }

    public void paramShow(String str,int num) {
        System.out.println("I am " + str + ",I " + num + "years");
    }
}

Class是一个类，而且它只有一个私有的构造函数，说明它不能通过new来获取对象，构造函数传入一个ClassLoader。
每个类被加载进入内存之后,系统就会为该类生成一个对应的java.lang.Class对象,
通过该Class对象就可以访问到JVM中的这个类，就可以获取某类的一切

private Class(ClassLoader loader) {
    // Initialize final field for classLoader.  The initialization value of non-null
    // prevents future JIT optimizations from assuming this final field is null.
    classLoader = loader;
}

Object类中有一个native方法获取Class
public final native Class<?> getClass();

    public static void getClass_1() {
        Person person = new Person();
        Class<? extends Person> personClass = person.getClass();
    }

public static void getClass_2() {
    Class<Person> personClass = Person.class;
}

public static void getClass_3() {
    try {
        Class<?> person = Class.forName("top.toly.bean.Person");
     System.out.println(person);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

/**
 * 通过反射建无参实例
 */
public static void createInstance() {
    //早期：new 的时候，先根据类名寻找到该类的字节码文件，并加载到内存，创建该字节码文件对象。
    // 再创建该字节码文件对相应的Person对象
    try {
        String className = "top.toly.bean.Person";
        // 寻找到该类的字节码文件，并加载到内存，创建该字节码文件对象。
        Class<?> clazz = Class.forName(className);
        Object instance = clazz.newInstance();
        System.out.println(instance instanceof Person);//true
    } catch (Exception e) {
        e.printStackTrace();
    }

 /**
  * 通过反射建有参实例
  */
 private static void createInstance_2() {
     try {
         String className = "top.toly.bean.Person";
         // 寻找到该类的字节码文件，并加载到内存，创建该字节码文件对象。
         Class<?> clazz = Class.forName(className);
         Constructor<?> constructor = clazz.getConstructor(String.class, int.class, boolean.class);
         Object instance = constructor.newInstance("捷特", 24, true);
         System.out.println(instance);
         //Person{age=24, name='捷特', isMan=true, address='beijing'}
     } catch (Exception e) {
         e.printStackTrace();
     }
 }

// 获得该类所有的构造器，不包括其父类的构造器
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
// 获得该类所以public构造器，包括父类 
public Constructor<T> getConstructor(Class<?>... parameterTypes)

/**
 * 获取公共字段
 */
public static void getPublicField() throws Exception {
    String className = "top.toly.bean.Person";
    // 寻找到该类的字节码文件，并加载到内存，创建该字节码文件对象。
    Class<?> clazz = Class.forName(className);
    Field address = clazz.getField("address");//获取公有字段
    Object o = address.get(clazz.newInstance());
    System.out.println(o);//beijing
}

/**
 * 获取私有字段
 */
public static void getPrivateField() throws Exception {
    String className = "top.toly.bean.Person";
    // 寻找到该类的字节码文件，并加载到内存，创建该字节码文件对象。
    Class<?> clazz = Class.forName(className);
    Constructor<?> constructor = clazz.getConstructor(String.class, int.class, boolean.class);
    Object instance = constructor.newInstance("捷特", 24, true);
    //可以获取所有类型字段
    Field name = clazz.getDeclaredField("age");
    //想要访问私有，需要将可获取置为true
    name.setAccessible(true);
    //设置私有成员值
    name.setInt(instance,30);
    //获取私有成员值
    Object o = name.get(instance);
    System.out.println(o);//30
}

/**
 * 获取公共方法
 */
public static void getPublicMethod() throws Exception {
    String className = "top.toly.bean.Person";
    // 寻找到该类的字节码文件，并加载到内存，创建该字节码文件对象。
    Class<?> clazz = Class.forName(className);
    //创建实例
    Constructor<?> constructor = clazz.getConstructor(String.class, int.class, boolean.class);
    Object instance = constructor.newInstance("捷特", 24, true);
    Method[] methods = clazz.getMethods();//只能获取公有方法，包括父类
    for (Method m : methods) {
        System.out.println(m);
    }
    //获取公共无参
    Method publicShow = clazz.getMethod("publicShow", null);
    //调用函数：invoke
    publicShow.invoke(instance, null);
    //获取公共有参
    Method paramShow = clazz.getMethod("paramShow", String.class, int.class);
    paramShow.invoke(instance, "龙少", 24);
}

/**
 * 获取私有方法
 */
public static void getPrivateMethod() throws Exception {
    String className = "top.toly.bean.Person";
    // 寻找到该类的字节码文件，并加载到内存，创建该字节码文件对象。
    Class<?> clazz = Class.forName(className);
    Method[] declaredMethods = clazz.getDeclaredMethods();//获取该类中的所有方法
    //创建实例
    Constructor<?> constructor = clazz.getConstructor(String.class, int.class, boolean.class);
    Object instance = constructor.newInstance("捷特", 24, true);
    for (Method m : declaredMethods) {
        System.out.println(m);
    }
    Method privateShow = clazz.getDeclaredMethod("privateShow", null);
    privateShow.setAccessible(true);
    privateShow.invoke(instance,null);
}