JAVA反射之Class类的练习

 1 package zhang;
 2 /**
 3  * JAVA反射之CLass类的练习
 4  * 
 5  * 在面向对象的语言里，万事万物皆对象，那么类是谁的对象呢？
 6  * 类的类型是CLass
 7  * 
 8  * */
 9 class Test{
10     void print(){
11         System.out.println("Hello world!");
12     }
13 }//Test是一个类。
14 public class ClassDemo {
15     public static void main(String[] args) {
16         //创建Test对象的方式
17         Test test=new Test();//这样通过new 就创建除了Test的对象
18         //那么类也是一种对象，作为Test类，如何创建出对象为Test的对象呢？
19         /*
20          * 
21          * Constructor. Only the Java Virtual Machine creates Class
22          * objects.
23          * private Class() {}
24          * Class类的构造方法是私有的，所以不能通过new来创建Class 对象。
25          * Class对象只能通过Java虚拟机创建
26          */
27  
28         /**
29          * 有三种方式
30          * */
31         /* 第一种:Class T1=Test.class 这种方式实际上是在告诉我们任何
32          * 一个类都存在一个隐含的静态成员class
33          * 
34          * 通过已知类型来创建
35          */
36         
37         Class T1=Test.class;
38         
39         /*
40          * 第二种
41          * 通过已知类型的对象来创建
42          * */
43         Class T2=test.getClass();
44         
45         System.out.println(T2==T1);
46         
47         /*
48          * 
49          * 第三种
50          * */
51         Class T3=null;
52         try {
53             T3=Class.forName("zhang.Test");
54         } catch (ClassNotFoundException e) {
55             // TODO Auto-generated catch block
56             e.printStackTrace();
57         }
58         
59         System.out.println(T3==T2);
60         //也就是说：不管T1 or T2都代表Test类的类类型，一个类只可能是Class类的一个实例对象。
61         
62         //我们可以通过T1 or T2 or T3来创建Test对象。
63         try {
64             Test test1=(Test) T1.newInstance();//这样就创建出Test的实例了
65             test1.print();
66             
67             
68         } catch (InstantiationException e) {
69             // TODO Auto-generated catch block
70             e.printStackTrace();
71         } catch (IllegalAccessException e) {
72             // TODO Auto-generated catch block
73             e.printStackTrace();
74         }    
75     }
76 }

package zhang;
/**
 * JAVA反射之CLass类的练习
 * 
 * 在面向对象的语言里，万事万物皆对象，那么类是谁的对象呢？
 * 类的类型是CLass
 * 
 * */
class Test{
    void print(){
        System.out.println("Hello world!");
    }
}//Test是一个类。
public class ClassDemo {
    public static void main(String[] args) {
        //创建Test对象的方式
        Test test=new Test();//这样通过new 就创建除了Test的对象
        //那么类也是一种对象，作为Test类，如何创建出对象为Test的对象呢？
        /*
         * 
         * Constructor. Only the Java Virtual Machine creates Class
         * objects.
         * private Class() {}
         * Class类的构造方法是私有的，所以不能通过new来创建Class 对象。
         * Class对象只能通过Java虚拟机创建
         */
 
        /**
         * 有三种方式
         * */
        /* 第一种:Class T1=Test.class 这种方式实际上是在告诉我们任何
         * 一个类都存在一个隐含的静态成员class
         * 
         * 通过已知类型来创建
         */
 
        Class T1=Test.class;
 
        /*
         * 第二种
         * 通过已知类型的对象来创建
         * */
        Class T2=test.getClass();
 
        System.out.println(T2==T1);
 
        /*
         * 
         * 第三种
         * */
        Class T3=null;
        try {
            T3=Class.forName("zhang.Test");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
        System.out.println(T3==T2);
        //也就是说：不管T1 or T2都代表Test类的类类型，一个类只可能是Class类的一个实例对象。
 
        //我们可以通过T1 or T2 or T3来创建Test对象。
        try {
            Test test1=(Test) T1.newInstance();//这样就创建出Test的实例了
            test1.print();
 
 
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }
}