Class 类

注意，这里的Class是大写的C。所以这里的Class是个特殊的类，而不是定义类的关键词class。

 

在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。

 

构造Class实例的是三种方法：

1.       getClass（）方法，必须生成目标类的是对象。

2.       forName（），会抛出异常，必须捕获。会运行目标类当中的静态代码段。

3.       .class属性来获取Class实例，应该是最简单的一种方式了。

对于基本数据类型的封装类，如果需要得到其封装的基本数据类型，还可以用.TYPE来获取相对应的基本数据类型的Class实例。

对于基本数据类型的封装类，如果不需要得到其封装的基本数据类型，而是需要获得封装类的Class类的实例，采用类名的.class的方式来获取Class实例。

 

publicclass ClassTest {
   publicstaticvoid main(String[] args){
 
      Point pt = new Point();
 
 
      Class c1 = pt.getClass();
      System.out.println("c1:"+ c1.getName());
   // c1:Point使用的是对象的.getClass（）方法
 
      Class c2;
      try {
        c2 = Class.forName("Point");
        System.out.println("c2:"+ c2.getName());
// c2:Point使用的是Class类的静态方法，不需要生成类的实例。但是要注意的时候，这个方法会抛出一个ClassNotFoundException，需要用try catch捕获。
      } catch (ClassNotFoundException e) {
        //TODO Auto-generated catch block
        e.printStackTrace();
      }
      
      Class c3 = Point.class;
      System.out.println("c3:"+ c3.getName());
// c3:Point直接使用类名的.class属性获得Class对象。以上为Point类。在这种方法中，就不需要生成类的实例了。
 
      
      Class  c4 = int.class;
      System.out.println("c4:"+c4.getName());
// c4:int这个测试的实质和c3一致，只是类换成了int.
 
 
      Class c5 = Integer.TYPE;
      System.out.println("c5:"+ c5.getName());
//C5:int 这里需要注意，因为使用的是Integer的特殊用法，所以是用.TYPE来获取相对应的基本数据类型的Class实例。所以程序输出是int。如果需要得到Integer类的实例，参考c6
 
      Class c6 = Integer.class;
      System.out.println("c6:"+ c6.getName());
   }
}
//c6: java.lang.Integer 把integer当成一个普通的类来看待，不使用.TYPE属性，其实质和c3是一样的。
 
class Point{
   intx,y;
}
 
 
运行结果为：
c1:Point
c2:Point
c3:Point
c4:int
c5:int
c6:java.lang.Integer
 
在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载（ClassLoader）。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象。
 
class ClassTest2
{
   publicstaticvoid main(String[] args)
   {  
      System.out.println("before new Point()");
      newPoint1();
      System.out.println("after new Point()");
      
      try
      {
        Class.forName("Line");
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
   
}
}
   
classPoint1
{
   static
   {
      System.out.println("Loading Point1");
   }
}
 
class Line
{
   static
   {
      System.out.println("Loading Line");
   }
}
 
运行结果为：
before new Point()
Loading Point1
after new Point()
Loading Line

 

考虑静态的代码段在什么时候执行，如果在main（）方法当中，所有的类都被要加载，那么在new构造对象之前，Loading Point1和Loading Line都必须执行。结论是，在产生一个类的对象的时候，类才会被加载。或者说用Class.forName()去构造Class这个类的实例的时候，类才会被加载。

 

对Class类来说，可以使用newInstance()去动态创建目标类的实例。好处（用法）：在不知道一个类的名字的时候，来创建一个类的实例。动态的去创建了一个类的实例，在创建的时候是不知道是哪个类的对象。

 

class ClassTest
{
   publicstaticvoid main(String[] args)
   {
        
      if(args.length!=1)
      {
        System.out.println("必须输入一个arg");
        return;
      }
      try
      {
        Class c=Class.forName(args[0]);  //通过命令行的参数，输入一个类（类名），那么c得到的是一个Class这个类的实例。
        Point pt = (Point)c.newInstance();通过c.newInstance()去创建一个Point类的实例（其实是object类型），并强制转换为Point类型。
        pt.output(); //然后就可以用pt作为普通的对象应用去使用了，和new出来的一样用。
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
   }
}
 
class Point
{
   static
   {
      System.out.println("Loading Point");
   }
   intx,y;
   void output()
   {
      System.out.println("x="+x+","+"y="+y);
   }
   /*Point(int x,int y)
   {
      this.x=x;
      this.y=y;
   }*/
}

要注意的是newInstance（）只能使用目标类当中缺省的构造方法（不带任何参数的）。如果我们在目标类当中重写了各种构造方法，会抛出异常。

为了解决这个问题，为去了去使用带参数的构造方法，java提供了反射机制。