java.lang.Class类和反射机制创建对象

                  java.lang.Class类

    Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是Class类。Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建。

      Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象。 
      虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类（型）都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。
      基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也都对应一个 Class 对象。 
      每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。

      一般某个类的Class对象被载入内存，它就用来创建这个类的所有对象。

一、获取Class实例的三种方式：
     (1)利用对象调用getClass()方法获取该对象的Class实例；
     (2)使用Class类的静态方法forName()，用类的名字获取一个Class实例（staticClass forName(String className)  Returns the Classobject associated with the class or interface with the given stringname. ）；
     (3)运用.class的方式来获取Class实例，对于基本数据类型的封装类，还可以采用.TYPE来获取相对应的基本数据类型的Class实例
   在newInstance()调用类中缺省的构造方法 ObjectnewInstance()（可在不知该类的名字的时候，常见这个类的实例） Creates a new instance of the class represented by this Classobject.
   在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象

public class ClassTest {
     public static void main(String [] args)throws Exception{
         String str1="abc";
         Class cls1=str1.getClass();
         Class cls2=String.class;
         Class cls3=Class.forName("java.lang.String");
         System.out.println(cls1==cls2);
         System.out.println(cls1==cls3);
     }
 }

返回结果为：true,true.
解释： 虚拟机只会产生一份字节码， 用这份字节码可以产生多个实例对象。

二、Class类的常用方法
    1、getName() 
    一个Class对象描述了一个特定类的属性，Class类中最常用的方法getName以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。

    2、newInstance()
    Class还有一个有用的方法可以为类创建一个实例，这个方法叫做newInstance()。例如：
    x.getClass.newInstance()，创建了一个同x一样类型的新实例。newInstance()方法调用默认构造器（无参数构造器）初始化新建对象。

    3、getClassLoader() 
    返回该类的类加载器。

    4、getComponentType() 
    返回表示数组组件类型的 Class。

    5、getSuperclass() 
    返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。

    6、isArray() 
    判定此 Class 对象是否表示一个数组类。

三、Class的一些使用技巧
    1、forName和newInstance结合起来使用，可以根据存储在字符串中的类名创建对象。例如
    Object obj = Class.forName(s).newInstance();

    2、虚拟机为每种类型管理一个独一无二的Class对象。因此可以使用==操作符来比较类对象。例如：
    if(e.getClass() == Employee.class)...

反射

      反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示Java类的Class类显示要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

      一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以的得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

构造方法的反射应用

Consturctor(构造器)类代表某个类中的一个构造方法

@1@ 得到某个类所有的构造方法：例如：Constructor [] constructors = Class.forName("java.lang.String").getConstructors();

@2@ 得到某一个构造方法：例如：Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);

@3@ 创建实例对象：通常方式：String str=new String(new StringBuffer("abc"));
                            反射方式：String str=(String) constructor.newInstance(new StringBuffer("abc"));

Java反射机制创建对象

package lxf;  
import java.lang.reflect.Constructor;  
import java.lang.reflect.Field;  
import java.lang.reflect.Method;  
  
class Person {  
    private String name;  
    private int age;  
  
    public Person(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    public Person() {  
        // TODO Auto-generated constructor stub  
    }  
  
    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;  
    }  
  
}  
  
/** 
 * 使用反射机制来创建对象 
 *  
 * @author lxf 
 * @time 2014-4-8下午05:08:41 
 *  
 */  
public class CreateObject {  
  
    /** 
     * Java的反射机制是指：反射就是把Java类中的各种成分映射成相应相应的Java类， 然后就可以获取这个类的所有信息 
     *  
     * @throws Exception 
     */  
    public static void createObj1() throws Exception {  
        // 返回与带有给定字符串名的类或接口相关联的 Class 对象。  
        // Class classType = Person.class;  
        Class classType = Class.forName("lxf.Person");  
        Object obj = classType.newInstance();  
        System.out.println("使用反射反射机制创建出来的对象是否是Person类的对象："  
                + (obj instanceof Person));  
    }  
  
    /** 
     * 创建带有构造参数的对象的时候我们需要使用另外一种方式即： 1.先获取操作类的Class对象即字节码文件 
     * 2.使用Class对象的getConstructor 
     * (parameterTypes)方法获取该对象的构造方法的对象，注意括号中可以带不等的可变参数, 
     * 3.使用构造方法对象的newInstance(initargs)方法就可以实例化一个对象 4.注意，使用这些方法都不可以访问被 
     * private修饰的方法，需要设置某些访问权限setAccessable()方法 
     *  
     * @throws Exception 
     */  
    public static void createObj2() throws Exception {  
        @SuppressWarnings("rawtypes")  
        Class classType = Person.class;  
  
        @SuppressWarnings("unchecked")  
        Constructor<Person> con = classType.getConstructor(String.class,  
                int.class);  
        Object obj = con.newInstance("lxf", 23);  
        System.out.println("使用constructor对象的newInstance方法创建对象的信息："  
                + ((Person) obj).getName());  
    }  
  
    /** 
     * 操作方法包括（private方法） 步骤： 1.首先获取要操作类的Class对象 
     * 2.然后通过Class对象的getMethod方法获取要操作的方法的Method对象（两个参数，第一个参数是方法名，第二个参数是参数类型） 
     * 3.调用Method的方法的invoke方法（两个参数，第一个参数是该方法属于的类对象，具体参数） 
     * 4.当方法被private修饰的时候，首先需要调用getDeclaredMethod()方法获取要操作的被private修饰的类。 
     * 在这里要注意这个getDeclaredMethod方法，它既可以用作获取普通方法的对象也可以用来操作private修饰的方法， 
     * 但是操作private修饰的方法的时候，必须使用这个方法，其它方法不可以。普通方法还可以使用getMethod方法， 
     * 且属性操作也是如此。另外，还需要设置访问权限setAccessable(true)才可以 
     *  
     * @throws Exception 
     */  
    public static void methodDo() throws Exception {  
        Person p = new Person();  
        Class classType = Person.class;  
        Method method = classType.getMethod("setName", String.class);  
        method.invoke(p, "ckl");  
        System.out.println("使用反射操作SetName方法后，Person对象的name值是：" + p.getName());  
  
        Method method2 = classType.getDeclaredMethod("test");  
        method2.setAccessible(true);  
        method2.invoke(p);  
    }  
  
    /** 
     * 操作字段 
     *  
     * @throws Exception 
     */  
    public static void FieldDo() throws Exception {  
        Person p = new Person();  
        Class classType = Person.class;  
        Field field = classType.getDeclaredField("name");  
        Field field2 = classType.getDeclaredField("age");  
        field.setAccessible(true);  
        field2.setAccessible(true);  
        field.set(p, "lxf");  
        field2.set(p, 23);  
        System.out.println("使用反射机制操作被private修饰的对象字段后得到的属性值是：" + p.getName());  
        System.out.println("使用反射机制操作被private修饰的对象字段后得到的属性值是：" + p.getAge());  
    }  
  
    public static void main(String[] args) throws Exception {  
        new CreateObject().FieldDo();  
    }  
  
}

根据以上代码：.使用反射机制创建对象的步骤如下：
1、先声明你要创建的对象的类全称；使用Class类的静态方法forName(String.className)加载这个类的字节码（注意，加载字节码不等于实例化对象） ，返回 一个Class对象，这个对象代表的是一个字节码文件。

2、调用这个类对象（字节码）的方法newInstance()方法（注意：这里的这个newInstance方法默认调用默认的构造方法即调用无参的构造方法， 一旦构造方法有参数时，此方法行不通，需要使用构造方法的对象的相关方法来 实例化）实例化类Person，返回的是Object类型
3、强制转换成Person类型即你所需类型
而获得Class对象的方法还有：
Class c = Class.forName("java.lang.String");这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：Class c = int.class; 或者 Class c = Integer.TYPE;它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。
到此反射基本操作就结束了，详细方法可参看API。

参考：http://lavasoft.blog.51cto.com/62575/15433/

     http://blog.csdn.net/smartboy_01/article/details/23201391