Java反射机制(获取Class对象的三种方式+获取Class中的构造函数进行对象的初始化+获取反射类的字段+获取反射类的一般方法)

　　反射技术其实就是动态加载一个指定的类，并获取该类中的所有内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员，简单来说：反射技术可以对一个类进行解剖，反射大大增强了应用程序的可扩展性。

      反射技术的原理如下图所示：

但是要想要对字节码文件进行解剖，必须要有字节码文件对象. 如何获取字节码文件对象呢？

要读取的类文件源码：

 

package Reflect;

public class Person {

    /**
     * @param args
     */
    private String name;
    private int age;
    public Person(){
        System.out.println("Construcor run..");
    }
    public Person(String name,int age){
    this.name=name;
    this.age=age;
    System.out.println("Person param run...");
    }
    public static void method(){
        System.out.println("method run...");
    }
    public static void paramMethod(String name,int age){
        System.out.println("name="+name+"age:"+age);
    }
    public static void staticMethod(){
        System.out.println("static run");
    }
    public void show(){
        System.out.println(name+"Method show run.."+age);
    }

}

 

获取字节码文件对象有三种方式：

（1）
 /*
  * 获取字节码对象的方式：
  * 1，Object类中的getClass()方法的。
  * 想要用这种方式，必须要明确具体的类，并创建对象。
  * 麻烦 
  */

public static void getObject_1() {
        Person p=new Person();
        Class<? extends Person> classz=p.getClass();
        System.out.println(classz);
        Person p1=new Person();
        Class<? extends Person> classz1=p.getClass();
        System.out.println(classz1);
        System.out.println(classz==classz1);
    }

（2）
 /*
  * 方式二：
  * 任何数据类型(基本数据类型和引用数据类型)都具备一个静态的属性.class来获取其对应的Class对象。
  * 相对简单，但是还是要明确用到类中的静态成员。
  * 还是不够扩展。
  *
  */

public  static void getObject_2() {
    
        Class classz=Person.class;
        Class classz1=Person.class;
        System.out.println(classz==classz1);
    }

(3)

 /*
  * 方式三：
  * 只要通过给定的类的 字符串名称就可以获取该类，更为扩展。
  * 可是用Class类中的方法完成。
  * 该方法就是forName.
  * 这种方式只要有名称即可，更为方便，扩展性更强。
  */

public  static void getObject_3() throws ClassNotFoundException {
        String classname="Reflect.Person";
        Class classz=Class.forName(classname);
        System.out.println(classz);
    }

获取Class中的构造函数初始化对象：

(1)调用空参数的构造函数：使用Class类中的newInstance()方法

　//早期：new时候，先根据被new的类的名称找寻该类的字节码文件，并加载进内存，
  // 并创建该字节码文件对象，并接着创建该字节文件的对应的Person对象.

  //现在：
  String name = "cn.itcast.bean.Person";
  //找寻该名称类文件，并加载进内存，并产生Class对象。
  Class clazz = Class.forName(name);
  //如何产生该类的对象呢？
  Object obj  = clazz.newInstance();

(2)调用带参数的构造函数：先要获取指定参数列表的构造函数对象，然后通过该构造函数的对象的newInstance(实际参数)进行对象的初始化

/*
   * 当获取指定名称对应类中的所体现的对象时，
   * 而该对象初始化不使用空参数构造该怎么办呢？
   * 既然是通过指定的构造 函数进行对象的初始化，
   * 所以应该先获取到该构造函数。 通过字节码文件对象即可完成。
   * 该方法是：getConstructor(paramterTypes);
   * 
   */

 

//带参数初始化新创建的对象
    public  static void createNewObject_param() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        String classname="Reflect.Person";
        Class classz=Class.forName(classname);
        Constructor constructor=classz.getConstructor(String.class,int.class);
        constructor.newInstance("Java",30);
    }

 获取反射类的字段：

    public static void getFiledDemo() throws ClassNotFoundException,
            NoSuchFieldException, SecurityException, InstantiationException,
            IllegalAccessException {
        Class classz = Class.forName("Reflect.Person");
        Field field = null;
        field = classz.getDeclaredField("age");
        field.setAccessible(true);
        Object obj = classz.newInstance();
        field.set(obj, 89);
        Object o = field.get(obj);
        System.out.println(o);
    }

获取反射类的成员方法：

(1)获取空参数一般方法

private static void getMethodDemo_2() throws Exception {
        Class clazz = Class.forName("Reflect.Person");

        Method method = clazz.getMethod("show", null);// 获取空参数一般方法。

        // Object obj = clazz.newInstance();
        Constructor constructor = clazz.getConstructor(String.class, int.class);
        Object obj = constructor.newInstance("linux", 37);

        method.invoke(obj, null);
    }

(2)获取带参数的一般方法

private static void getMethodDemo_3() throws Exception {

        Class clazz = Class.forName("Reflect.Person");

        Method method = clazz.getMethod("paramMethod", String.class, int.class);

        Object obj = clazz.newInstance();

        method.invoke(obj, "Ruby", 89);
    }

(3)获取反射类的公有、私有方法

private static void getMethodDemo() throws ClassNotFoundException {
        Class classz = Class.forName("Reflect.Person");
        Method[] methods = classz.getMethods();// 获取反射类中所有共有的方法
        methods = classz.getDeclaredMethods();// 获取本类中包括私有的所有的方法
        for (Method method : methods) {
            System.out.println(method);
        }
    }

 

---

本文为博主原创文章，转载请注明出处：http://www.cnblogs.com/ysw-go/
1、本博客的原创原创文章，都是本人平时学习所做的笔记，如有错误，欢迎指正。
2、如有侵犯您的知识产权和版权问题，请通知本人，本人会即时做出处理文章。
3、本博客的目的是知识交流所用，转载自其它博客或网站，作为自己的参考资料的，感谢这些文章的原创人员