Java编程反射机制用法入门与实例总结

本文实例讲述了Java编程反射机制用法。分享给大家供大家参考，具体如下：

前言：反射:动态获取类 （字节码文件 如本篇中的Person.class）,并对其成员进行运行。反射在Android应用层的开发中可能遇到会稍微少一点，但对于想打通底层的小伙伴来说，必须要熟练掌握运用。

实体类

Person.java

package com.sunwenou.reflect;// 包名
public class Person {
  private String name;
  private int age;
  public Person() {// 无参
  }
  public Person(String name, int age) {// 带参
    super();
    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;
  }
  @Override
  public String toString() {
    return name+","+age;
  }
  public void show() { // 空参
    System.out.println("show");
  }
  public void fun(String ss) { // 带参
    System.out.println(ss);
  }
  public static void function() { // 静态
    System.out.println("static");
  }
}

动态获取字节码文件的方法

本篇中为使博文看起来简洁，一概抛出Exception，并省略import，下同。

package com.sunwenou.reflect;
public class Demo1 {
  /**
   * 动态获取字节码文件的方法
   * 1:使用Object类提供的 Class getClass()方法
   *  这种方法需要对象
   * 2:每种数据类型都有一个静态的class属性,这个属性返回的这种数据类型所属字节码文件对象
   *  int.class  Person.class
   * 3:使用 Class提供的 forName()方法
   *  只需要提供一个字符串，这个字符串由 包名+类名 构成
   */
  public static void main(String[] args) throws Exception {
    //getClaz();
    //getCalz2();
    getClaz3();
  }
  //使用 Class提供的 forName()方法
  public static void getClaz3() throws Exception {
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    Class<?> claz2 = Class.forName("com.sunwenou.reflect.Person");
    System.out.println(claz==claz2);
  }
  //每种数据类型都有一个静态的class属性
  public static void getCalz2() {
    Class<Person> p1 = Person.class;
    Class<Person> p2 = Person.class;
    System.out.println(p1==p2);
  }
  //使用Object类提供的 Class getClass()方法
  public static void getClaz() {
    Person person1 = new Person();
    Class<? extends Person> claz = person1.getClass();//Person.class
    Person person2 = new Person();
    Class<? extends Person> claz2 = person2.getClass();//Person.class
    System.out.println(claz==claz2);
  }
}

动态获取类，并创建对象

package com.sunwenou.reflect;
public class Demo2 {
  public static void main(String[] args) throws Exception {
    //createObj();
    createObj2();
  }
  public static void createObj2() throws Exception {
    //Person person = new Person("lisi",23);
    //得到字节码文件对象
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");//Person.class
    //得到带参数的构造方法所属的Constructor类型的对象
    Constructor constructor = claz.getConstructor(String.class,int.class);
    //使用Constructor类提供的创建对象的方法创建对象
    Person person = (Person)constructor.newInstance("lisi",23);
    System.out.println(person);
  }
  public static void createObj() throws Exception {
    //Person person = new Person();
    //得到字节码文件对象
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    Object obj = claz.newInstance();//默认使用空参的构造方法创建对象
    System.out.println(obj);
  }
}

动态获取类并为成员变量赋值

package com.sunwenou.reflect;
public class Demo3 {
  public static void main(String[] args) throws Exception {
    //Person p = new Person();
    //p.name = "lisi";
    //得到字节码文件对象
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    //得到成员变量所属的Field类型的对象
    //Field field = claz.getField("name");//得到的是public权限的成员
    Field field = claz.getDeclaredField("name");//得到所有声明的字段
    System.out.println(field);
    //非静态成员变量是依赖于对象的
    Object obj = claz.newInstance();
    field.setAccessible(true);//暴力破解, 设置为可访问的
    field.set(obj, "张三");
    System.out.println(obj);
  }
}

动态获取类，并执行方法

package com.sunwenou.reflect;
public class Demo4 {
  public static void main(String[] args) throws Exception {
    //method1();
    method2();
    method3();
  }
  public static void method3() throws Exception {
    //得到字节码文件对象
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    Method m = claz.getMethod("function", null);
    m.invoke(null, null);
  }
  ////执行带参数的方法
  public static void method2() throws Exception {
    //得到字节码文件对象
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    Method m = claz.getMethod("fun", String.class);
    Object obj = claz.newInstance();
    m.invoke(obj, "hello");
  }
  //执行无参的方法
  public static void method1() throws Exception {
    //Person person = new Person(); person.show();
    //得到字节码文件对象
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    //得到被执行的方法所属的字节码文件对象
    Method m = claz.getMethod("show", null);
    //非静态方法是依赖于对象的
    Object obj = claz.newInstance();
    //执行方法
    m.invoke(obj, null);
  }
}

这就是反射的基本用法，我们就可以在不能通过正常创建对象的时候通过对象的字节码文件来创建对象，并执行其中的方法，你学会了吗？？

希望本文所述对大家java程序设计有所帮助。

原文链接：http://blog.csdn.net/u014158743/article/details/52939229