类名.class 类名.this 详解

Posted 2020-10-14

我们知道在java中，一个类在被加载的时候虚拟机就会自动的生成一个这个类的一个Class类型的“类对象”，每个类都对应着一个这样的类对象，通过这个Class类型的类对象，我们就能够使用“内省与反射”机制，访问一个类的信息，比如：对应类中的方法有哪些，成员域有哪些等等；获取一个类的“类对象”的方法之一就是通过使用   类名.class  这个方式返回一个Class类型的对象，其他的获取这个Class对象的方法如下：

1). 利用对象调用getClass()方法获取该对象的Class实例
2). 使用Class的静态方法forName()，用类的名字获取一个Class实例
3). 运用.calss的方式获取Class实例，对基本数据类型的封装类，还可以采用.TYPE来获取对应的基本数据类型的Class实例。

以下是TestClass.java代码：

 1 public class TestClass {   
 2     public static void main(String[] args) {   
 3         // 在运行期间，如果我们要产生某个类的对象，java虚拟机会检测该类型的Class对象是否已被加载。如果没有加载，java虚拟机会根据类的名称找到.class文件并加载它。   
 4         //当new Point()的时候加载这个类，用forName构造实例的时候也加载该类。 只加载一次   
 5         System.out.println("before new Point()");   
 6         new Point();   
 7         System.out.println("after new Point()");   
 8         try {   
 9             Class.forName("Line");   
10         } catch (Exception e) {   
11             e.printStackTrace();   
12         }   
13    
14         // 利用对象调用getClass()方法获取该对象的Class实例   
15         Point pt = new Point();   
16         Class c1 = pt.getClass();   
17         System.out.println(c1.getName()); // 结果:Point   
18    
19         // 使用Class的静态方法forName()，用类的名字获取一个Class实例   
20         try {   
21             Class c2 = Class.forName("Point");   
22             System.out.println(c2.getName()); // 结果:Point   
23             Point pp = (Point) c2.newInstance(); //一旦某个类型的Class对象已经被加载到内存，就可以用它来产生该类型的所有对象。   
24                                         //newInstance()调用类中缺省的构造方法。   
25             pp.output();   
26         } catch (Exception e) {   
27             e.printStackTrace();   
28         }   
29    
30         // 运用.class的方式获取Class实例(类)   
31         Class c3 = Point.class;   
32         System.out.println(c3.getName()); // 结果:Point   
33    
34         // 运用.calss的方式获取Class实例(基本类型)   
35         Class c4 = int.class;   
36         System.out.println(c4.getName()); // 结果:int   
37    
38         // 运用.class的方式获取Class实例(基本数据类型的封装类)   
39         Class c5 = Integer.TYPE;   
40         System.out.println(c5.getName()); // 结果:int   
41         Class c6 = Integer.class;   
42         System.out.println(c6.getName()); // 结果:java.lang.Integer   
43     }   
44 }   
45    
46 class Point {   
47     static {   
48         System.out.println("loading point");   
49     }   
50    
51     void output() {   
52         System.out.println("x=" + x + ",y=" + y);   
53     }   
54     int x, y;   
55 }   
56    
57 class Line {   
58     static {   
59         System.out.println("loading Line");   
60     }   
61 }

 

 

类名.this 

  这个语法的应用主要有两个方面：

①当在一个类的内部类中，如果需要访问外部类的方法或者成员域的时候，如果使用  this.成员域(与 内部类.this.成员域 没有分别) 调用的显然是内部类的域 ， 如果我们想要访问外部类的域的时候，就要必须使用  外部类.this.成员域

 1 public class TestA 
 2 {    
 3     public void tn()
 4     {          
 5         System.out.println("外部类tn");         
 6     }  
 7     Thread thread = new Thread(){     
 8           public void tn(){System.out.println("inner tn");}        
 9           public void run(){           
10                  System.out.println("内部类run");        
11                  TestA.this.tn();//调用外部类的tn方法。          
12                  this.tn();//调用内部类的tn方法           
13              }    
14      };          
15      public static void main(String aaa[])
16      {new TestA().thread.start();}
17 }

②还有一个使用情况，那就是在是使用意图更加的清楚，在android开发中我们经常要在一些地方使用 Context 类型的参数， 而这个参数我们往往使用this, 
其实这里面其实有一种隐含的逻辑，比如我们定义一个Intent 或者一个TextView 

 1 public class MainActivity extends Activity {  
 2   
 3                      @Override     
 4   
 5                       protected void onCreate(Bundle savedInstanceState) {      
 6   
 7                             super.onCreate(savedInstanceState);      
 8   
 9                             setContentView(R.layout.activity_main);      
10   
11                             Intent intent = new Intent(MainActivity.this , OtherActivity.class) ;    
12   
13                   }  
14   
15 } 

 

 

这说明我们创建的Intent 对象是与MainActivity这个类型的对象是有关联的，也就是说这个Intent是由MainActivity对象发出的，

好了，  这说明有些情况下虽然使用 类名.this  和 直接使用this 没有分别，但是使用  类名.this  却能够清楚的显示出一种关联性，因此值得提倡

与此同时如果我们创建的Intent在一个匿名内部类中创建的话，但是我们想让这个在Intent对象在逻辑上和外部类对象关联起来的话，我们就必须使用  外部类名.this  了

 

 1 public class MainActivity extends Activity {  
 2   
 3     private Button button;  
 4   
 5     @Override       
 6   
 7      public void onCreate(Bundle savedInstanceState) {           
 8   
 9           super.onCreate(savedInstanceState);           
10   
11           setContentView(R.layout.main);  
12   
13         this.button = (Button) this.findViewById(R.id.Button01);           
14   
15         this.button.setOnClickListener(new OnClickListener() {               
16   
17             @Override               
18   
19             public void onClick(View v) {                   
20   
21                       Intent intent = new Intent();                   
22   
23                       intent.setClass(MainActivity.this, NextActivity.class);                   
24   
25                      startActivity(intent);               
26   
27                }           
28   
29        });       
30   
31    }   
32   
33 }