Java 方法 · ZetCode 中文系列教程

# Java 方法原文：http://zetcode.com/lang/java/methods/ 在本教程的這一部分中，我們討論 Java 方法。在面向對象的編程中，我們使用對象。對象是程序的基本構建塊。對象由數據和方法組成。方法更改創建的對象的狀態。它們是對象的動態部分。數據是靜態部分。 ## Java 方法定義方法是包含一系列語句的代碼塊。方法必須在類中聲明。好的編程習慣是方法僅執行一項特定任務。方法為程序帶來了模塊化。正確使用方法具有以下優點： * 減少代碼重復 * 將復雜的問題分解成更簡單的部分 * 提高代碼的清晰度 * 重用代碼 * 信息隱藏 ## Java 方法的特點方法的基本特征是： * 訪問權限 * 返回值類型 * 方法名稱 * 方法參數 * 括號 * 語句塊方法的訪問級別由訪問修飾符控制。他們設置方法的可見性。他們確定誰可以調用該方法。方法可以將值返回給調用方。如果我們的方法返回值，則聲明其數據類型。如果不是，則使用`void`關鍵字指示我們的方法不返回任何值。方法參數用括號括起來，并用逗號分隔。空括號表示該方法不需要任何參數。方法塊周圍帶有`{}`字符。該塊包含一個或多個在調用方法時執行的語句。擁有一個空的方法塊是合法的。 ## Java 方法簽名方法簽名是 Java 編譯器方法的唯一標識。簽名包含一個方法名稱，以及每個形式參數的類型和種類（值，引用或輸出）。方法簽名不包括返回類型。 ## Java 方法名稱可以在方法名稱中使用任何合法字符。按照約定，方法名稱以小寫字母開頭。方法名稱是動詞或動詞，后跟形容詞或名詞。隨后的每個單詞都以大寫字母開頭。以下是 Java 中方法的典型名稱： * `excecute` * `findId` * `setName` * `getName` * `checkIfValid` * `testValidity` ## Java 方法示例我們從一個簡單的例子開始。 `ShowInfoMethod.java` ```java package com.zetcode; class Base { public void showInfo() { System.out.println("This is Base class"); } } public class ShowInfoMethod { public static void main(String[] args) { Base bs = new Base(); bs.showInfo(); } } ``` 我們有一個`showInfo()`方法，它打印其類的名稱。 ```java class Base { public void showInfo() { System.out.println("This is Base class"); } } ``` 每個方法必須在一個類中定義。它必須有一個名字。在我們的情況下，名稱為`showInfo`。方法名稱之前的關鍵字是訪問說明符和返回類型。括號跟隨方法的名稱。它們可能包含方法的參數。我們的方法沒有任何參數。 ```java public static void main(String[] args) { ... } ``` 這是`main()`方法。它是每個控制臺或 GUI Java 應用的入口。該方法采用參數的字符串數組。 ```java Base bs = new Base(); bs.showInfo(); ``` 我們創建`Base`類的實例。我們在對象上調用`showInfo()`方法。我們說該方法是一個實例方法，因為它需要調用一個實例。通過指定對象實例，成員訪問運算符（點），方法名稱，來調用該方法。 ## Java 方法參數參數是傳遞給方法的值。方法可以采用一個或多個參數。如果方法使用數據，則必須將數據傳遞給方法。這是通過在括號內指定它們來完成的。在方法定義中，我們必須為每個參數提供名稱和類型。 `Addition.java` ```java package com.zetcode; class AddValues { public int addTwoValues(int x, int y) { return x + y; } public int addThreeValues(int x, int y, int z) { return x + y + z; } } public class Addition { public static void main(String[] args) { AddValues a = new AddValues(); int x = a.addTwoValues(12, 13); int y = a.addThreeValues(12, 13, 14); System.out.println(x); System.out.println(y); } } ``` 在上面的示例中，我們有一個`AddValues`類，它具有兩種方法。其中一個帶有兩個參數，另一個帶有三個參數。 ```java public int addTwoValues(int x, int y) { return x + y; } ``` `addTwoValues()`方法采用兩個參數。這些參數具有`int`類型。該方法還向調用者返回一個整數。我們使用`return`關鍵字從方法中返回一個值。 ```java public int addThreeValues(int x, int y, int z) { return x + y + z; } ``` `addThreeValues()`與先前的方法類似，但是它帶有三個參數。 ```java int x = a.addTwoValues(12, 13); ``` 我們將`AddValues`對象的`addTwoValues()`方法調用。它有兩個值。這些值將傳遞給方法。該方法返回一個分配給`x`變量的值。 ## 可變數量的參數從 Java 5 開始，方法可以采用可變數量的參數。為此，我們使用省略號。 `SumOfValues.java` ```java package com.zetcode; public class SumOfValues { public static int sum(int...vals) { int sum = 0; for (int val : vals) { sum += val; } return sum; } public static void main(String[] args) { int s1 = sum(1, 2, 3); int s2 = sum(1, 2, 3, 4, 5); int s3 = sum(1, 2, 3, 4, 5, 6, 7); System.out.println(s1); System.out.println(s2); System.out.println(s3); } } ``` 我們創建一個`sum()`方法，該方法可以使用可變數量的參數。該方法計算傳遞給該方法的整數之和。 ```java int s1 = sum(1, 2, 3); int s2 = sum(1, 2, 3, 4, 5); int s3 = sum(1, 2, 3, 4, 5, 6, 7); ``` 我們多次調用`sum()`方法。在每種情況下，我們都將不同數量的參數傳遞給該方法。 ```java public static int sum(int...vals) { ... } ``` `sum()`方法可以采用可變數量的整數值。所有值都添加到數組中。 ```java int sum = 0; for (int val : vals) { sum += val; } return sum; ``` 我們計算值的總和，然后返回計算出的總和。 ```java $ java com.zetcode.SumOfValues 6 15 28 ``` 這是`com.zetcode.SumOfValues`示例的輸出。 ## 通過值傳遞參數在 Java 中，參數總是按值傳遞給方法。當我們傳遞原始類型時，值的副本將發送到方法。如果是對象，則將引用的副本交給這些方法。 Java 不支持通過引用傳遞參數，例如 C# 或 C++ 。 `PassByValue.java` ```java package com.zetcode; class Cat {} class Dog {} public class PassByValue { private static void tryChangeInteger(int x) { x = 15; } private static void tryChangeObject(Object o) { Dog d = new Dog(); o = d; } public static void main(String[] args) { int n = 10; tryChangeInteger(n); System.out.println(n); Cat c = new Cat(); tryChangeObject(c); System.out.println(c.getClass()); } } ``` 該示例表明，不可能在方法內部更改基本類型的值和對對象的引用。 ```java private static void tryChangeInteger(int x) { x = 15; } ``` 傳遞的變量的值將復制到局部變量`x`。為`x`變量分配新值不會影響外部變量。 ```java private static void tryChangeObject(Object o) { Dog d = new Dog(); o = d; } ``` 同樣適用于對象。我們正在傳遞方法引用的副本。 `o`是引用`Dog`對象的局部變量。 `tryChangeObject()`外部定義的對象不受影響。 ```java int n = 10; tryChangeInteger(n); System.out.println(n); ``` 我們定義`n`變量并將其傳遞給`tryChangeInteger()`方法。稍后，我們打印它以檢查它是否被修改。 ```java Cat c = new Cat(); tryChangeObject(c); System.out.println(c.getClass()); ``` 我們定義一個`Cat`對象，并將其傳遞給`tryChangeObject()`方法。 ```java $ java com.zetcode.PassByValue 10 class com.zetcode.Cat ``` 從輸出中我們可以看到，原始值和對象都沒有被修改。 ## Java 中的方法重載方法重載允許創建多個名稱相同但輸入類型不同的方法。方法重載有什么好處？ Qt5 庫提供了一個很好的用法示例。 `QPainter`類具有三種繪制矩形的方法。它們的名稱為`drawRect()`，其參數不同。一個引用一個浮點矩形對象，另一個引用一個整數矩形對象，最后一個引用四個參數：`x`，`y`，`width`和`height`。如果開發 Qt 的 C++ 語言沒有方法重載，則庫的創建者必須將其命名為`drawRectRectF()`，`drawRectRect()`和`drawRectXYWH()`之類的方法。方法重載的解決方案更為優雅。 `Overloading.java` ```java package com.zetcode; class Sum { public int getSum() { return 0; } public int getSum(int x) { return x; } public int getSum(int x, int y) { return x + y; } } public class Overloading { public static void main(String[] args) { Sum s = new Sum(); System.out.println(s.getSum()); System.out.println(s.getSum(5)); System.out.println(s.getSum(5, 10)); } } ``` 我們有三種方法`setSum()`。它們的輸入參數不同。 ```java public int getSum(int x) { return x; } ``` 這一個參數。 ```java System.out.println(s.getSum()); System.out.println(s.getSum(5)); System.out.println(s.getSum(5, 10)); ``` 我們調用這三種方法。所有方法都具有相同的名稱。編譯器根據方法輸入知道要調用的方法。 ```java $ java com.zetcode.Overloading 0 5 15 ``` 這就是我們運行示例時得到的。 ## Java 遞歸在數學和計算機科學中，遞歸是一種定義方法的方法，其中所定義的方法在其自己的定義內應用。換句話說，遞歸方法會調用自身來完成其工作。遞歸是解決許多編程任務的一種廣泛使用的方法。使用遞歸解決的每個問題也可以通過迭代解決。一個典型的例子是階乘的計算。 `Recursion.java` ```java package com.zetcode; public class Recursion { static int factorial(int n) { if (n == 0) { return 1; } else { return n * factorial(n - 1); } } public static void main(String[] args) { System.out.println(factorial(6)); System.out.println(factorial(15)); } } ``` 在此代碼示例中，我們計算兩個數字的階乘。 ```java return n * factorial(n - 1); ``` 在階乘方法的主體內部，我們將階乘方法稱為經過修改的參數。該函數調用自身。這是遞歸算法的本質。 ```java $ java com.zetcode.Recursion 720 2004310016 ``` 這些就是結果。 ## Java 方法作用域在方法內部聲明的變量具有方法作用域。名稱的作用域是程序的區域，在該區域中可以引用名稱聲明的實體，而無需使用名稱限定。在方法內部聲明的變量具有方法作用域。它也稱為本地作用域。該變量僅在此特定方法中有效。 `MethodScope.java` ```java package com.zetcode; class Test { int x = 1; public void exec1() { System.out.println(this.x); System.out.println(x); } public void exec2() { int z = 5; System.out.println(x); System.out.println(z); } } public class MethodScope { public static void main(String[] args) { Test ts = new Test(); ts.exec1(); ts.exec2(); } } ``` 在此示例中，我們在實例方法外部定義了`x`變量。該變量具有類作用域。它在`Test`類的定義內的任何地方都有效，例如大括號之間。 ```java public void exec1() { System.out.println(this.x); System.out.println(x); } ``` `x`變量（也稱為`x`字段）是一個實例變量。可通過`this`關鍵字進行訪問。它在`exec1()`方法中也有效，并且可以用其裸名引用。這兩個語句都引用相同的變量。 ```java public void exec2() { int z = 5; System.out.println(x); System.out.println(z); } ``` 也可以在`exec2()`方法中訪問 x 變量。 `z`變量在`exec2()`方法中定義。它具有方法范圍。僅在此方法中有效。 ```java $ java com.zetcode.MethodScope 1 1 1 5 ``` 這是`com.zetcode.MethodScope`程序的輸出。在方法內部定義的變量具有本地/方法范圍。如果局部變量與實例變量具有相同的名稱，則它會遮蓋實例變量。實例變量仍然可以通過`this`在方法內部訪問。 `Shadowing.java` ```java package com.zetcode; class Test { int x = 1; public void exec() { int x = 3; System.out.println(this.x); System.out.println(x); } } public class Shadowing { public static void main(String[] args) { Test t = new Test(); t.exec(); } } ``` 我們聲明一個實例變量`x`。我們在`exec()`方法中聲明了另一個`x`變量。這兩個變量具有相同的名稱，但是它們沒有沖突，因為它們位于不同的作用域中。 ```java System.out.println(this.x); System.out.println(x); ``` 變量的訪問方式不同。在方法內部定義的`x`變量，也稱為局部變量`x`，僅通過其名稱即可訪問。可以使用`this`來引用實例變量。 ```java $ java com.zetcode.Shadowing 1 3 ``` 這是`com.zetcode.Shadowing`示例的輸出。 ## Java 靜態方法在沒有對象實例的情況下調用靜態方法。要調用靜態方法，我們使用類的名稱和點運算符。靜態方法只能使用靜態變量。靜態方法通常用于表示不會隨對象狀態變化的數據或計算。數學庫是一個示例，其中包含用于各種計算的靜態方法。我們使用`static`關鍵字來聲明靜態方法或靜態變量。如果不存在靜態修飾符，則該方法稱為實例方法。我們不能在靜態方法中使用`this`關鍵字；它只能在實例方法中使用。 `StaticMethod.java` ```java package com.zetcode; class Basic { static int id = 2321; public static void showInfo() { System.out.println("This is Basic class"); System.out.format("The Id is: %d%n", id); } } public class StaticMethod { public static void main(String[] args) { Basic.showInfo(); } } ``` 在我們的代碼示例中，我們定義了靜態`ShowInfo()`方法。 ```java static int id = 2321; ``` 靜態方法只能使用靜態變量。靜態變量不適用于實例方法。 ```java public static void showInfo() { System.out.println("This is Basic class"); System.out.format("The Id is: %d%n", id); } ``` 這是我們的靜態`ShowInfo()`方法。它與靜態`id`成員一起使用。 ```java Basic.showInfo(); ``` 要調用靜態方法，我們不需要對象實例。我們通過使用類的名稱和點運算符來調用該方法。 ```java $ java com.zetcode.StaticMethod This is Basic class The Id is: 2321 ``` 這是示例的輸出。 ## Java 隱藏方法如果是靜態方法，則派生類中具有與基類相同簽名的方法會將其隱藏在基類中。在編譯時確定要調用的方法。該過程稱為早期或靜態綁定。 `Hiding.java` ```java package com.zetcode; class Base { public static void showInfo() { System.out.println("This is Base class"); } } class Derived extends Base { public static void showInfo() { System.out.println("This is Derived class"); } } public class Hiding { public static void main(String[] args) { Base.showInfo(); Derived.showInfo(); } } ``` 我們有兩個類：`Derived`和`Base`。 `Derived`類繼承自`Base`類。兩者都有一種稱為`showInfo()`的方法。 ```java class Derived extends Base { public static void showInfo() { System.out.println("This is Derived class"); } } ``` `Derived`類的靜態類方法`showInfo()`隱藏了`Base`類的`showInfo()`方法。 ```java Base.showInfo(); Derived.showInfo(); ``` 我們為這兩個類都調用`showInfo()`方法。每個類都調用自己的方法。 ```java $ java com.zetcode.Hiding This is Base class This is Derived class ``` 這是`com.zetcode.Hiding`示例的輸出。 ## Java 覆蓋方法當我們創建派生類的實例方法具有與基類中的實例方法相同的簽名和返回類型時，將發生覆蓋。在運行時確定要執行的方法。確定將在運行時執行的方法稱為或動態綁定。我們可能想要使用`@Override`注解，該注解指示編譯器我們打算覆蓋超類中的方法。它有助于防止某些編程錯誤。 `Overriding.java` ```java package com.zetcode; class Base { public void showInfo() { System.out.println("This is Base class"); } } class Derived extends Base { @Override public void showInfo() { System.out.println("This is Derived class"); } } public class Overriding { public static void main(String[] args) { Base[] objs = { new Base(), new Derived(), new Base(), new Base(), new Base(), new Derived() }; for (Base obj : objs) { obj.showInfo(); } } } ``` 我們創建`Base`和`Derived`對象的數組。我們遍歷數組并在所有數組上調用`showInfo()`方法。 ```java @Override public void showInfo() { System.out.println("This is Derived class"); } ``` 在這里，我們將覆蓋`Base`類的`showInfo()`方法。 ```java Base[] objs = { new Base(), new Derived(), new Base(), new Base(), new Base(), new Derived() }; ``` 在這里，我們創建`Base`和`Derived`對象的數組。請注意，我們在數組聲明中使用了`Base`類型。 `Derived`類可以轉換為`Base`類，因為它繼承自它。相反的說法是不正確的。在一個數組中具有不同對象的唯一方法是使用所有對象都共享的類型。 ```java for (Base obj : objs) { obj.showInfo(); } ``` 我們遍歷數組，并在數組中的所有對象上調用`showInfo()`。在運行時確定要調用的方法。 ```java $ java com.zetcode.Overriding This is Base class This is Derived class This is Base class This is Base class This is Base class This is Derived class ``` 這是輸出。使用`super`關鍵字，可以調用重寫方法。 `Overriding2.java` ```java package com.zetcode; class Base { public void showInfo() { System.out.println("This is Base class"); } } class Derived extends Base { @Override public void showInfo() { System.out.println("This is Derived class"); } public void showBaseInfo() { super.showInfo(); } } public class Overriding2 { public static void main(String[] args) { Derived d = new Derived(); d.showBaseInfo(); } } ``` 在示例中，我們將`Base`類的`showInfo()`與`super`一起調用。 ```java public void showBaseInfo() { super.showInfo(); } ``` 在這里，我們稱為直接父級的`showInfo()`方法。 ## Java `final`方法 `final`方法不能被派生類覆蓋或隱藏。這用于防止子類的意外行為更改可能對類的功能或一致性至關重要的方法。 `FinalMethods.java` ```java package com.zetcode; class Base { public void f1() { System.out.println("f1 of the Base"); } public final void f2() { System.out.println("f2 of the Base"); } } class Derived extends Base { @Override public void f1() { System.out.println("f1 of the Derived"); } // @Override // public void f2() { // // System.out.println("f2 of the Derived"); // } } public class FinalMethods { public static void main(String[] args) { Base b = new Base(); b.f1(); b.f2(); Derived d = new Derived(); d.f1(); d.f2(); } } ``` 在此示例中，我們在`Base`類中具有最終方法`f2()`。此方法不能被覆蓋。 ```java public final void f2() { System.out.println("f2 of the Base"); } ``` `f2()`方法被聲明為`final`。不可能超載。 ```java @Override public void f1() { System.out.println("f1 of the Derived"); } ``` 在`Derived`類中，我們可以覆蓋`Base`類的`f1()`方法。我們還使用`@Override`注解通知編譯器我們正在重寫方法。 ```java // @Override // public void f2() { // // System.out.println("f2 of the Derived"); // } ``` 這些行帶有注釋，因為否則代碼示例將無法編譯。編譯器將給出以下錯誤：線程`main`中的異常`java.lang.VerifyError`：`com.zetcode.Derived`類將覆蓋最終方法`f2`。 ```java d.f2(); ``` 由于不可能覆蓋最終方法，因此以上行將調用`Base`類的`f2()`方法。 ```java $ java com.zetcode.FinalMethods f1 of the Base f2 of the Base f1 of the Derived f2 of the Base ``` 這是輸出。在 Java 教程的這一部分中，我們介紹了方法。