一、如何得到Class的对象呢？有三种方法可以的获取：
    1、调用Object类的getClass()方法来得到Class对象，这也是最常见的产生Class对象的方法。例如：
    MyObject x;
    Class c1 = x.getClass();
    2、使用Class类的中静态forName()方法获得与字符串对应的Class对象。例如：
    Class c2=Class.forName("MyObject"),Employee必须是接口或者类的名字。
    3、获取Class类型对象的第三个方法非常简单。如果T是一个Java类型，那么T.class就代表了匹配的类对象。例如
    Class cl1 = Manager.class;
    Class cl2 = int.class;
    Class cl3 = Double[].class;
    注意：Class对象实际上描述的只是类型，而这类型未必是类或者接口。例如上面的int.class是一个Class类型的对象。由于历史原因，数组类型的getName方法会返回奇怪的名字。

二、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)...

1)　autoboxing和unboxing

在Java中，所有要处理的东西几乎都是对象(Object)。然而基本(Primitive)数据类型不是对象，也就是你使用int、double、boolean等定义的变量，以及你在程序中直接写下的字面常量。

使用Java有一段时间的人都知道，有时需要将基本数据类型转换为对象。例如使用Map对象要操作put()方法时，需要传入的参数是对象而不是基本数据类型。

要使用打包类型(Wrapper Types)才能将基本数据类型包装为对象，前一个小节中你已经知道在J2SE 5.0之前，要使用以下语句才能将int包装为一个Integer对象：

Integer integer = new Integer(10);

在 J2SE 5.0之后提供了自动装箱的功能，你可以直接使用以下语句来打包基本数据类型：

Integer integer = 10;

在进行编译时，编译器再自动根据你写下的语句，判断是否进行自动装箱动作。在上例中integer变量参考的会是Integer类的实例。同样的动作可以适用于 boolean、byte、short、char、long、float、double等基本数据类型，分别会使用对应的打包类型(Wrapper Types)Boolean、Byte、Short、Character、Long、Float或Double。

自动装箱运用的方法还可以如下：

int i = 10; Integer integer = i;也可以使用更一般化的java.lang.Number类来自动装箱。例如：

Number number = 3.14f;3.14f会先被自动装箱为Float，然后指定给number。

J2SE 5.0中可以自动装箱，也可以自动拆箱(unboxing)，也就是将对象中的基本数据形态信息从对象中自动取出。例如下面这样写是可以的：

Integer fooInteger = 10;int fooPrimitive = fooInteger;fooInteger变量在自动装箱为Integer的实例后，如果被指定给一个int类型的变量fooPrimitive，则会自动变为int类型再指定给fooPrimitive。在运算时，也可以进行自动装箱与拆箱。例如：

Integer i = 10;System.out.println(i + 10);System.out.println(i++);上例中会显示20与10，编译器会自动进行自动装箱与拆箱，也就是10会先被装箱，然后在i + 10时会先拆箱，进行加法运算；i++该行也是先拆箱再进行递增运算。再来看一个例子：

Boolean boo = true;System.out.println(boo && false);同样的boo原来是Boolean的实例，在进行AND运算时，会先将boo拆箱，再与false进行AND运算，结果会显示false。

2)　小心使用 boxing

自动装箱与拆箱的功能事实上是编译器来帮你的忙，编译器在编译时期依你所编写的语法，决定是否进行装箱或拆箱动作。例如：

Integer i = 100;相当于编译器自动为你作以下的语法编译：

Integer i = new Integer(100);所以自动装箱与拆箱的功能是所谓的“编译器蜜糖”(Compiler Sugar)，虽然使用这个功能很方便，但在程序运行阶段你得了解Java的语义。例如下面的程序是可以通过编译的：

Integer i = null;int j = i;这样的语法在编译时期是合法的，但是在运行时期会有错误，因为这种写法相当于：

Integer i = null;int j = i.intValue();null表示i没有参考至任何的对象实体，它可以合法地指定给对象参考名称。由于实际上i并没有参考至任何的对象，所以也就不可能操作intValue()方法，这样上面的写法在运行时会出现NullPointerException错误。

自动装箱、拆箱的功能提供了方便性，但隐藏了一些细节，所以必须小心。再来看“AutoBoxDemo1.java ”，你认为结果是什么呢？

AutoBoxDemo1.java：

view plaincopy to clipboardprint?
public class AutoBoxDemo1 {  
    public static void main(String[] args) {  
        Integer i1 = 127;  
        Integer i2 = 127;  
        if (i1 == i2)   
            System.out.println("i1 == i2");  
        else   
            System.out.println("i1 != i2");  
    }  
} 
public class AutoBoxDemo1 {
    public static void main(String[] args) {
        Integer i1 = 127;
        Integer i2 = 127;
        if (i1 == i2)
            System.out.println("i1 == i2");
        else
            System.out.println("i1 != i2");
    }
}

从自动装箱与拆箱的机制来看，可能会觉得结果是显示i1 == i2，你是对的。

那么“AutoBoxDemo2.java ”的这个程序，你觉得结果是什么？

AutoBoxDemo2.java：

view plaincopy to clipboardprint?
public class AutoBoxDemo2 {  
    public static void main(String[] args) {  
        Integer i1 = 128;  
        Integer i2 = 128;  
        if (i1 == i2)   
            System.out.println("i1 == i2");  
        else   
            System.out.println("i1 != i2");  
    }  
} 
public class AutoBoxDemo2 {
    public static void main(String[] args) {
        Integer i1 = 128;
        Integer i2 = 128;
        if (i1 == i2)
            System.out.println("i1 == i2");
        else
            System.out.println("i1 != i2");
    }
}

结果是显示i1 != i2，这有些令人惊讶，两个范例语法完全一样，只不过改个数值而已，结果却相反。

其实这与==运算符的比较有关，==是用来比较两个基本数据类型的变量值是否相等，事实上==也用于判断两个对象变量名称是否参考至同一个对象。

在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，所以范例4.6中使用==进行比较时，i1 与 i2实际上参考至同一个对象。如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个Integer对象，所以“AutoBoxDemo2.java”使用==进行比较时，i1与i2参考的是不同的对象。

所以不要过分依赖自动装箱与拆箱，你还是必须知道基本数据类型与对象的差异。最好还是依正规的方式来写，而不是依赖编译器蜜糖(Compiler Sugar)。例如“AutoBoxDemo2.java”必须改写为“AutoBoxDemo3.java ”才是正确的。

AutoBoxDemo3.java：

view plaincopy to clipboardprint?
public class AutoBoxDemo3 {  
    public static void main(String[] args) {  
        Integer i1 = 128;  
        Integer i2 = 128;  
        if (i1.equals(i2))   
            System.out.println("i1 == i2");  
        else   
            System.out.println("i1 != i2");  
    }  
} 
public class AutoBoxDemo3 {
    public static void main(String[] args) {
        Integer i1 = 128;
        Integer i2 = 128;
        if (i1.equals(i2))
            System.out.println("i1 == i2");
        else
            System.out.println("i1 != i2");
    }
}

结果这次是显示i1 == i2。使用这样的写法，相信也会比较放心一些，对于这些方便但隐藏细节的功能到底要不要用呢？基本上只有一个原则：如果你不确定就不要用。

首先你要明白在java里面任何class都要装载在虚拟机上才能运行。这句话就是装载类用的(和new 不一样，要分清楚)。 

至于什么时候用，你可以考虑一下这个问题，给你一个字符串变量，它代表一个类的包名和类名，你怎么实例化它？只有你提到的这个方法了，不过要再加一点。 
A a = (A)Class.forName("pacage.A").newInstance(); 
这和你 
A a = new A()； 
是一样的效果。 

关于补充的问题 
答案是肯定的，jvm会执行静态代码段，你要记住一个概念，静态代码是和class绑定的，class装载成功就表示执行了你的静态代码了。而且以后不会再走这段静态代码了。

Class.forName(xxx.xx.xx) 返回的是一个类 
Class.forName(xxx.xx.xx);的作用是要求JVM查找并加载指定的类，也就是说JVM会执行该类的静态代码段

动态加载和创建Class 对象，比如想根据用户输入的字符串来创建对象 
String str = 用户输入的字符串 
Class t = Class.forName(str); 
t.newInstance();

 在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别？它们的区别在于创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。那么为什么会有两种创建对象方式？这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。 

Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。 例如： 
class c = Class.forName(“Example”); 
factory = (ExampleInterface)c.newInstance(); 

其中ExampleInterface是Example的接口，可以写成如下形式： 
String className = "Example"; 
class c = Class.forName(className); 
factory = (ExampleInterface)c.newInstance(); 

进一步可以写成如下形式： 
String className = readfromXMlConfig;//从xml 配置文件中获得字符串 
class c = Class.forName(className); 
factory = (ExampleInterface)c.newInstance(); 

上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。 

从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：1、这个类已经加载；2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载java API的那个加载器。 

现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。 

最后用最简单的描述来区分new关键字和newInstance()方法的区别： 
newInstance: 弱类型。低效率。只能调用无参构造。 
new: 强类型。相对高效。能调用任何public构造。

class Product implements Runnable
{
 private Person person = null;
 public Product(Person person)
 {
  this.person = person ;
 }
 public void run()
 {
  for(int i= 0;i<100;i++)
  {
   if(i%2==0)
   {
    person.set("conish","英文名");
   }
   else
   {
   
       person.set("风花雪月","作者");
   }
  }
 }
}
class Customer implements Runnable
{
 private Person person = null;
 public Customer(Person person)
 {
  this.person = person ;
 }
 public void run()
 {
  for(int i= 0;i<100;i++)
  {
      System.out.println(person.get());
  }
 }
}
public class ThreadTest11
{
 public static void main(String [ ]argc)
 {
  Person person = new Person();
  Product product = new Product(person);
  Customer customer = new Customer(person);
  new Thread(product).start();
  new Thread(customer).start();
 }
}