類名.class 類名.this 詳解

咱們知道在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 }