this.屬性

大部分時候，普通方法訪問其他方法、成員變數時無須使用 this 字首，但如果方法裡有個區域性變數和成員變數同名，但程式又需要在該方法裡訪問這個被覆蓋的成員變數，則必須使用 this 字首。

假設有一個教師類 Teacher 的定義如下：

1. public class Teacher {
2. private String name; // 教師名稱
3. private double salary; // 工資
4. private int age; // 年齡
5. }

在上述程式碼中 name、salary 和 age 的作用域是 private，因此在類外部無法對它們的值進行設定。為了解決這個問題，可以為 Teacher 類新增一個構造方法，然後在構造方法中傳遞引數進行修改。程式碼如下：

1. // 建立構造方法，為上面的3個屬性賦初始值
2. public Teacher(String name,double salary,int age) {
3. this.name = name; // 設定教師名稱
4. this.salary = salary; // 設定教師工資
5. this.age = age; // 設定教師年齡
6. }

在 Teacher 類的構造方法中使用了 this 關鍵字對屬性 name、salary 和 age 賦值，this 表示當前物件。this.name=name語句表示一個賦值語句，等號左邊的 this.name 是指當前物件具有的變數 name，等號右邊的 name 表示引數傳遞過來的數值。

建立一個 main() 方法對 Teacher 類進行測試，程式碼如下：

1. public static void main(String[] args) {
2. Teacher teacher = new Teacher("王剛",5000.0,45);
3. System.out.println("教師資訊如下：");
4. System.out.println("教師名稱："+teacher.name+"\n教師工資："+teacher.salary+"\n教師年齡："+teacher.age);
5. }

執行該程式，輸出的結果如下所示。

教師資訊如下：
教師名稱：王剛
教師工資：5000.0
教師年齡：45

提示：當一個類的屬性（成員變數）名與訪問該屬性的方法引數名相同時，則需要使用 this 關鍵字來訪問類中的屬性，以區分類的屬性和方法中的引數。

this.方法名

this 關鍵字最大的作用就是讓類中一個方法，訪問該類裡的另一個方法或例項變數。

假設定義了一個 Dog 類，這個 Dog 物件的 run( ) 方法需要呼叫它的 jump( ) 方法，Dog 類的程式碼如下所示：

1. /**
2. * 第一種定義Dog類方法
3. **/
4. public class Dog {
5. // 定義一個jump()方法
6. public void jump() {
7. System.out.println("正在執行jump方法");
8. }
10. // 定義一個run()方法，run()方法需要藉助jump()方法
11. public void run() {
12. Dog d = new Dog();
13. d.jump();
14. System.out.println("正在執行 run 方法");
15. }
16. }

使用這種方式來定義這個 Dog 類，確實可以實現在 run( ) 方法中呼叫 jump( ) 方法。下面再提供一個程式來建立 Dog 物件，並呼叫該物件的 run( ) 方法。

1. public class DogTest {
2. public static void main(String[] args) {
3. // 建立Dog物件
4. Dog dog = new Dog();
5. // 呼叫Dog物件的run()方法
6. dog.run();
7. }
8. }

在上面的程式中，一共產生了兩個 Dog 物件，在 Dog 類的 run( ) 方法中，程式建立了一個 Dog 物件，並使用名為 d 的引用變數來指向該 Dog 物件。在 DogTest 的 main() 方法中，程式再次建立了一個 Dog 物件，並使用名為 dog 的引用變數來指向該 Dog 物件。

下面我們思考兩個問題。

1）在 run( ) 方法中呼叫 jump( ) 方法時是否一定需要一個 Dog 物件？

答案是肯定的，因為沒有使用 static 修飾的成員變數和方法都必須使用物件來呼叫。

2）是否一定需要重新建立一個 Dog 物件？

不一定，因為當程式呼叫 run( ) 方法時，一定會提供一個 Dog 物件，這樣就可以直接使用這個已經存在的 Dog 物件，而無須重新建立新的 Dog 物件了。因此需要在 run() 方法中獲得呼叫該方法的物件，通過 this 關鍵字就可以滿足這個要求。

this 可以代表任何物件，當 this 出現在某個方法體中時，它所代表的物件是不確定的，但它的型別是確定的，它所代表的只能是當前類的例項。只有當這個方法被呼叫時，它所代表的物件才被確定下來，誰在呼叫這個方法，this 就代表誰。

將前面的 Dog 類的 run( ) 方法改為如下形式會更加合適，run( ) 方法程式碼修改如下，其它程式碼不變。

1. /**
2. * 第二種定義Dog類方法
3. **/
5. // 定義一個run()方法，run()方法需要藉助jump()方法
6. public void run() {
7. // 使用this引用呼叫run()方法的物件
8. this.jump();
9. System.out.println("正在執行run方法");
10. }

從第一種 Dog 類定義來看，在 Dog 物件的 run( ) 方法內重新建立了一個新的 Dog 物件，並呼叫它的 jump( ) 方法，這意味著一個 Dog 物件的 run( ) 方法需要依賴於另一個 Dog 物件的 jump( ) 方法，這不符合邏輯。

第二種 Dog 類定義是當一個 Dog 物件呼叫 run( ) 方法時，run( ) 方法需要依賴它自己的 jump( ) 方法，與第一種定義類的方法相比，更符合實際情形。

在現實世界裡，物件的一個方法依賴於另一個方法的情形很常見，例如，吃飯方法依賴於拿筷子方法，寫程式方法依賴於敲鍵盤方法。這種依賴都是同一個物件兩個方法之間的依賴。因此，Java 允許物件的一個成員直接呼叫另一個成員，可以省略 this 字首。也就是說，將上面的 run( ) 方法改為如下形式也完全正確。

1. public void run() {
2. jump();
3. System.out.println("正在執行run方法");
4. }

大部分時候，一個方法訪問該類中定義的其他方法、成員變數時加不加 this 字首的效果是完全一樣的。

注意：對於 static 修飾的方法而言，可以使用類來直接呼叫該方法，如果在 static 修飾的方法中使用 this 關鍵字，則這個關鍵字就無法指向合適的物件。所以，static 修飾的方法中不能使用 this 引用。並且 Java 語法規定，靜態成員不能直接訪問非靜態成員。

省略 this 字首只是一種假象，雖然程式設計師省略了呼叫 jump() 方法之前的 this，但實際上這個 this 依然是存在的。

this() 訪問構造方法

this( ) 用來訪問本類的構造方法（構造方法是類的一種特殊方法，方法名稱和類名相同，沒有返回值。詳細瞭解可參考《Java構造方法》一節），括號中可以有引數，如果有引數就是呼叫指定的有參構造方法。

例3

下面定義一個 Student 類，使用 this( ) 呼叫構造方法給 name 賦值，Student 類的程式碼如下所示：

1. public class Student {
2. String name;
4. // 無參構造方法（沒有引數的構造方法）
5. public Student() {
6. this("張三");
7. }
9. // 有參構造方法
10. public Student(String name) {
11. this.name = name;
12. }
14. // 輸出name和age
15. public void print() {
16. System.out.println("姓名：" + name);
17. }
19. public static void main(String[] args) {
20. Student stu = new Student();
21. stu.print();
22. }
23. }

輸出結果為：

姓名：張三

注意：

• this( ) 不能在普通方法中使用，只能寫在構造方法中。
• 在構造方法中使用時，必須是第一條語句。