Java反射机制

【案例1】通过一个对象获得完整的包名和类名

public class Demo {
    int age;
    String name;
  }  

public class Testit1 {
//    java反射详解：通过一个对象活的完整的包名和类名
public static void main(String[] args) {
    Demo demo = new Demo();
    System.out.println(demo.getClass().getName());
   }
}
 【运行结果】：Reflect.Demo
   添加一句：所有类的对象其实都是Class的实例。

【案例2】实例化Class类对象

  public class Demo {
        int age;
       String name;
   }

  public class Testit2 {
public static void main(String[] args) {
    Class<?> demo1 = null;
    Class<?> demo2 = null;
    Class<?> demo3 = null;

    try {
  //            一般经尽量采用这种形式
        demo1 = Class.forName("reflect12.Demo");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    demo2 = new Demo().getClass();
    demo3 = Demo.class;
    System.out.println("类名称1  "+demo1.getName());
    System.out.println("类名称2  "+demo2.getName());
    System.out.println("类名称3  "+demo3.getName());
     }
  }
  【运行结果】：
  类名称1  reflect12.Demo
  类名称2  reflect12.Demo
  类名称3  reflect12.Demo

【案例3】通过Class实例化其他类的对象通过无参构造实例化对象

  public class Person3 {
private String name;
private int 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 display() {
    String s = String.format("姓名=%s,年龄=%d", name, age);
    System.out.println(s);
}
@Override
public String toString() {
    return "[" + this.name + " " + this.age + "]";
}
  //    所以大家以后再编写使用Class实例化其
  他类的对象的时候，一定要自己定义无参的构
  造函数
  //    public Person3(String name, int age) {
 //        this.name = name;
  //        this.age = age;
  //    }
  }

  public class Testit3 {
public static void main(String[] args) {
    Class<?> demo = null;
    try {
        demo = Class.forName("reflect3.Person3");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    Person3 person3 = null;
    try {
        person3 = (Person3) demo.newInstance();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    person3.setAge(22);
    person3.setName("南城的人");
    person3.display();
    System.out.println(person3);
     }
  }
【运行结果】：
姓名=南城的人,年龄=22
[南城的人 22]

但是注意一下，当我们把Person中的默认的无参构造函数取消的时候，
比如自己定义只定义一个有参数的构造函数之后，会出现错误：

比如我定义了一个构造函数：

public Person(String name, int age) {
    this.age=age;
    this.name=name;
}
然后继续运行上面的程序，会出现：

java.lang.InstantiationException: Reflect.Person
at java.lang.Class.newInstance0(Class.java:340)
at java.lang.Class.newInstance(Class.java:308)
at Reflect.hello.main(hello.java:39)
Exception in thread "main" java.lang.NullPointerException
at Reflect.hello.main(hello.java:47)

所以大家以后再编写使用Class实例化其他类的对象的时候，
一定要自己定义无参的构造函数

【案例4】通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）

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

public Person4(int age, String name) {
    this.age = age;
    this.name = name;
}
public Person4(int age) {
    this.age = age;
}
public Person4(String name) {
    this.name = name;
}
public Person4() {
}
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 "["+this.name+"  "+this.age+"]";
  }
}
【运行结果】：
[null  0]
[南城的人  0]
[null  22]
[南城的人  22]

【案例5】 返回一个类实现的接口：

  public interface China {
public static final String name="南城";
public static  int age=20;
public void sayChina();
public void sayHello(String name, int age);
}

public class Person5 implements China {
private String sex;
public Person5(String sex) {
    this.sex = sex;
}
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}
@Override
public void sayChina() {
}
@Override
public void sayHello(String name, int age) {
   }
}

public class Testit5 {
public static void main(String[] args) {
    Class<?> demo = null;
    try {
        demo = Class.forName("reflect5.Person5");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
//        保存所有接口的数组
    Class<?> intes[] = demo.getInterfaces();
    for (int i = 0; i < intes.length; i++) {
        System.out.println("实现的接口  " + intes[i].getName());
    }
   }
}
【运行结果】：
  实现的接口  reflect5.China

（注意，以下几个例子，都会用到这个例子的Person类，所以为节省篇幅，此处不再粘贴Person的代码部分，只粘贴主类hello的代码）

【案例6】：取得其他类中的父类

 public class Testit6 {
public static void main(String[] args) {
    Class<?> demo = null;
    try {
        demo = Class.forName("reflect5.Person5");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    Class<?> temp = demo.getSuperclass();
    System.out.println("继承的父类 " + temp.getName());
    }
}
【运行结果】：
 继承的父类 java.lang.Object

感谢http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html