Java class对象 单例 java类的class对象

|字号 订阅

在java中，每个class都有一个相应的Class对象，当编写好一个类，编译完成后，在生成的.class文件中，就产生一个class对象，用来表示这个类的类型信息。获得Class实例的三中方式：
1.利用对象调用getClass()方法获取该对象的Class实例
2.使用Class的静态方法forName()，用类的名字获取一个Class实例
3.运用.calss的方式获取Class实例，对基本数据类型的封装类，还可以采用.TYPE来获取对应的基本数据类型的Class实例

calss ClassTest
 {
                 public static void main(String[] args)
                 {
                         /*
                         //利用对象调用getClass()方法获取该对象的Class实例
                         Point pt=new Point();                
                         Class c1=pt.getClass();
                        System.out.println(c1.getName());                        //结果:Point
                 
                         //使用Class的静态方法forName()，用类的名字获取一个Class实例
                         try
                         {
                                 Class c2=Class.forName("Point");
                                System.out.println(c2.getName());                //结果:Point
                         }
                         catch(Exception e)
                        {
                                 e.printStackTrace();
                         }                         //运用.calss的方式获取Class实例(类)
                         Class c3=Point.calss;///此时Point是类而Point.class是对象，是实例。
                         System.out.println(c3.getName());                        //结果:Point                         //运用.calss的方式获取Class实例(基本类型)
                         Class c4=int.calss;
                         System.out.println(c4.getName());                        //结果:int                         //运用.calss的方式获取Class实例(基本数据类型的封装类)
                         Class c5=Integer.TYPE;
                         System.out.println(c5.getName());                        //结果:int
                 
                         Class c6=Integer.class;
                         System.out.println(c6.getName());                        //结果:java.lang.Integer
                         */
                 
                         //以下结果是：          before new Point()
                                         loading point
                                         after new Point()
                                         loading Line        
                         //当new Point()的时候加载这个类，用forName构造实例的时候也加载该类。
                         System.out.println("before new Point()");
                         new Point();
                         System.out.println("after new Point()");                         try
                         {
                                 Class.forName("Line");
                         }catch(Exception e)
                         {
                                 e.printStackTrace();
                         }
                 
                 }
 }
 class Point()
 {
                 static
                 {
                         System.out.println("loading point");
                 }
                 int x,y;
 }
 class Line
 {
                 static
                 {
                         System.out.println("loading Line");
                 }
 }

在运行期间，如果我们要产生某个类的对象，java虚拟机会检测该类型的Class对象是否已被加载。如果没有加载，java虚拟机会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已经被加载到内存，就可以用它来产生该类型的所有对象。
newInstance()调用内中缺省的构造方法。

 1、出现的时期不同：Class.forName()在运行时加载；Class.class和getClass()是在编译器加载
2、Class.class只是在编译时用来存放类的相关信息，并没有实例化对象；而getClass()既实例化了对象，又存放了类信息
3、例：

Test t=new Test();
    Class c=t.getClass();
    
    Class c=Class.class;

    Class c=Class.forName("Test");



 package com.hsia.util;

 public class Test {

     Test(){}
     
     private String test;
     
     public String getTest() {
         return test;
     }

     public void setTest(String test) {
         this.test = test;
     }
     
     public static void f(Test t)
     {
         System.out.print(t);
     }

     public static void main(String[] arg) throws Exception
     {    
         System.out.println(Test.class);
         System.out.println(new Test());
         System.out.println(Test.class.newInstance());
   
         Class clas = null;
         try {
           clas = Class.forName("Test");        //此处必须为完整路径  com.hsia.util.Test
           System.out.println(clas);
         } catch (ClassNotFoundException ex) {
           // handle exception case
         }
         System.out.println(clas);
         
         Test t=new Test();
         System.out.println(t.getClass().newInstance());
         System.out.println(t);
         
         f(t);
     }
 }

输出结果：
第一次输出：

class com.hsia.util.Test
 com.hsia.util.Test@1df38fd
 com.hsia.util.Test@16a786
 null
 com.hsia.util.Test@1efb836
 com.hsia.util.Test@126e85f
 com.hsia.util.Test@126e85f

第二次输出：

class com.hsia.util.Test
 com.hsia.util.Test@de6ced
 com.hsia.util.Test@c17164
 null
 com.hsia.util.Test@61de33
 com.hsia.util.Test@14318bb
 com.hsia.util.Test@14318bb

结论：

Test.class：输出类名
 new Test()：输出类实例的内存物理地址
 Test.class.newInstance()：输出类实例的内存物理地址
 t.getClass().newInstance()：输出类实例的内存物理地址
 t：也是类实例内存地址