Java 7 to 17 Local Variable Type Inference(var)

一、前言

返回目錄

Java 語言一直以來以其強型別著稱，這代表著在編譯時必須明確指定變數的類型。在 Java 10 之前，我們需要冗長地重複宣告變數類型，尤其是在複雜的泛型程式碼中。例如：

List<Map<String, Integer>> myData = new ArrayList<>();

xxxxxxxxxx

 

1

List<Map<String, Integer>> myData = new ArrayList<>();

2

​

這樣的宣告不僅重複，也降低了程式碼的可讀性。為了簡化程式碼並提高開發效率，Java 10 引入了局部變數類型推斷 ( var )，這個特性允許編譯器根據變數的初始化值來自動推斷變數的類型，大大簡化了程式碼的撰寫。 值得注意的是， var 是一個編譯時的特性，編譯器會在編譯階段推斷出變數的具體類型，而不是在程式碼運行時。 本篇文章將整理 Java 7 至 17 中 var 類型推斷相關的新特性，並分析其使用場景與注意事項。

目錄

• 一、前言
  • 目錄
• 二、Java 7 ~ Java 9：類型宣告的傳統模式
• 三、Java 10：局部變數類型推斷 var 的引入
• 四、Java 11 ~ Java 17： var 的使用場景與最佳實踐
• 五、總結

二、Java 7 ~ Java 9：類型宣告的傳統模式

返回目錄

在 Java 7 到 Java 9 中，我們必須顯式宣告所有變數的類型。這在某種程度上提供了程式碼的明確性，但同時也帶來了一些缺點：

• 程式碼冗長： 特別是使用泛型類別時，重複的類型宣告使程式碼顯得冗長且不易讀。
• 維護困難： 當類型需要修改時，需要在多處進行更改，容易造成錯誤。
• 降低開發效率： 需要花費額外的時間去宣告變數類型，降低了開發效率。

範例：

// Java 7 - Java 9 宣告變數方式 String name = "John Doe"; int age = 30; List<String> names = new ArrayList<>(); Map<String, List<Integer>> dataMap = new HashMap<>();

xxxxxxxxxx

 

1

// Java 7 - Java 9 宣告變數方式

2

String name = "John Doe";

3

int age = 30;

4

List<String> names = new ArrayList<>();

5

Map<String, List<Integer>> dataMap = new HashMap<>();

6

​

在這些版本中，編譯器無法自動推斷變數類型，必須明確宣告。

三、Java 10：局部變數類型推斷 var 的引入

返回目錄

Java 10 最大的變化之一就是引入了局部變數類型推斷( var )。 var 關鍵字可以用於聲明局部變數，讓編譯器根據變數的初始化值來推斷其類型。這個特性主要針對以下目標：

• 簡化程式碼： 減少冗餘的類型宣告，讓程式碼更加簡潔易讀。
• 提升開發效率： 省去宣告變數類型所需的時間，加速程式碼開發。
• 減少錯誤： 減少因類型宣告錯誤而導致的編譯錯誤。

var 的限制：

• 只能用於 局部變數 ，不能用於方法參數、欄位或類別級別的變數。
• 變數必須 直接初始化 ，編譯器需要根據初始化值來推斷類型。
• 當匿名類別實作了具有明確介面或繼承了明確父類別時， var 可以推斷為該介面或父類別的類型。

範例：

public interface MyInterface { void abstractMethod(); // 抽象方法 default void defaultMethod() { // 預設方法 System.out.println("Default implementation"); } }

xxxxxxxxxx

 

1

public interface MyInterface {

2

    void abstractMethod(); // 抽象方法

3

​

4

    default void defaultMethod() {  // 預設方法

5

        System.out.println("Default implementation");

6

    }

7

}

8

​

public class VarExample { public static void main(String[] args) { // 合法使用 var validVarUsage(); // 不合法使用 var invalidVarUsage(); } // 合法使用範例 public static void validVarUsage() { // 1. 簡單類型推斷 var name = "John Doe"; // name 被推斷為 String var age = 30; // age 被推斷為 int System.out.println("Name: " + name + ", Age: " + age); // 2. 泛型集合的推斷 var names = new java.util.ArrayList<String>(); // names 推斷為 ArrayList<String> names.add("Alice"); names.add("Bob"); System.out.println("Names: " + names); var dataMap = new java.util.HashMap<String, java.util.List<Integer>>(); // dataMap 推斷為 HashMap<String, List<Integer>> dataMap.put("scores", new java.util.ArrayList<>(java.util.Arrays.asList(90, 85, 95))); System.out.println("Data Map: " + dataMap); // 3. 迴圈中的使用 var list = java.util.Arrays.asList("apple", "banana", "cherry"); for (var item : list) { // item 推斷為 String System.out.println("Item: " + item); } // 4. try-with-resources try (var reader = new java.io.BufferedReader(new java.io.FileReader("VarExample.java"))) { // reader 推斷為 BufferedReader String line = reader.readLine(); if (line != null) { System.out.println("First Line: " + line); } } catch (java.io.IOException e) { System.out.println("IO Exception: " + e.getMessage()); } // 5. 方法鏈式呼叫 var result = new SomeObject().getFirst().getSecond().getThird(); System.out.println("Result from method chain: " + result); // result 推斷為 String // 6. 匿名類別的宣告 var myInterface = new MyInterface() { // myInterface 推斷為 MyInterface 類型 @Override public void abstractMethod() { System.out.println("Override abstractMethod()."); } }; myInterface.abstractMethod(); myInterface.defaultMethod(); var runnableVar = new Runnable() { // runnableVar 推斷為 Runnable 類型 @Override public void run() { System.out.println("Running"); } }; runnableVar.run(); } static class SomeObject { public First getFirst() { return new First(); } } static class First { public Second getSecond() { return new Second(); } } static class Second { public String getThird() { return "Method Chain Result"; } } // 不合法使用範例 public static void invalidVarUsage() { // 1. 未初始化的 var // var message; // 編譯錯誤：必須初始化 var message = "this is message"; // 正確範例 // 2. var 用於不正確的修飾子 // private var myVar = "a"; //編譯錯誤: 只能使用 default, final final var myVar = "a"; // 正確範例 // 3. var 用於 null 初始化 // var nullVar = null; // 編譯錯誤：無法推斷 null 的類型 (需要顯式轉型) String nullVar = null; // 正確範例 // 4. 多次賦值不同類型 var typeFixed = 10; // typeFixed 推斷為 int // typeFixed = "test"; // 編譯錯誤：變數類型一旦推斷就不可變 System.out.println("Illegal Var example completed"); } // 5. var 用於方法參數 // public void myMethod(var parameter){} //編譯錯誤：不能用於方法參數 // 6. var 用於 instance field // private var myVar = "a"; //編譯錯誤: 不能用於 instance field (類別級別變數) }

xxxxxxxxxx

 

1

public class VarExample {

2

    public static void main(String[] args) {

3

        // 合法使用 var

4

        validVarUsage();

5

​

6

        // 不合法使用 var

7

        invalidVarUsage();

8

    }

9

​

10

    // 合法使用範例

11

    public static void validVarUsage() {

12

        // 1. 簡單類型推斷

13

        var name = "John Doe"; // name 被推斷為 String

14

        var age = 30; // age 被推斷為 int

15

        System.out.println("Name: " + name + ", Age: " + age);

16

​

17

        // 2. 泛型集合的推斷

18

        var names = new java.util.ArrayList<String>(); // names 推斷為 ArrayList<String>

19

        names.add("Alice");

20

        names.add("Bob");

21

        System.out.println("Names: " + names);

22

​

23

        var dataMap = new java.util.HashMap<String, java.util.List<Integer>>(); // dataMap 推斷為 HashMap<String, List<Integer>>

24

        dataMap.put("scores", new java.util.ArrayList<>(java.util.Arrays.asList(90, 85, 95)));

25

        System.out.println("Data Map: " + dataMap);

26

​

27

        // 3. 迴圈中的使用

28

        var list = java.util.Arrays.asList("apple", "banana", "cherry");

29

        for (var item : list) { // item 推斷為 String

30

            System.out.println("Item: " + item);

31

        }

32

​

33

        // 4. try-with-resources

34

        try (var reader = new java.io.BufferedReader(new java.io.FileReader("VarExample.java"))) { // reader 推斷為 BufferedReader

35

            String line = reader.readLine();

36

            if (line != null) {

37

                System.out.println("First Line: " + line);

38

            }

39

        } catch (java.io.IOException e) {

40

            System.out.println("IO Exception: " + e.getMessage());

41

        }

42

​

43

        // 5. 方法鏈式呼叫

44

        var result = new SomeObject().getFirst().getSecond().getThird();

45

        System.out.println("Result from method chain: " + result); // result 推斷為 String

46

​

47

        // 6. 匿名類別的宣告

48

        var myInterface = new MyInterface() { // myInterface 推斷為 MyInterface 類型

49

            @Override

50

            public void abstractMethod() {

51

                System.out.println("Override abstractMethod().");

52

            }

53

        };

54

        myInterface.abstractMethod();

55

        myInterface.defaultMethod();

56

        var runnableVar = new Runnable() { // runnableVar 推斷為 Runnable 類型

57

            @Override

58

            public void run() {

59

                System.out.println("Running");

60

            }

61

        };

62

        runnableVar.run();

63

    }

64

​

65

    static class SomeObject {

66

        public First getFirst() {

67

            return new First();

68

        }

69

    }

70

​

71

    static class First {

72

        public Second getSecond() {

73

            return new Second();

74

        }

75

    }

76

​

77

    static class Second {

78

        public String getThird() {

79

            return "Method Chain Result";

80

        }

81

    }

82

​

83

    // 不合法使用範例

84

    public static void invalidVarUsage() {

85

        // 1. 未初始化的 var

86

        // var message; // 編譯錯誤：必須初始化

87

        var message = "this is message"; // 正確範例

88

​

89

        // 2. var 用於不正確的修飾子

90

        // private var myVar = "a"; //編譯錯誤: 只能使用 default, final

91

        final var myVar = "a"; // 正確範例

92

​

93

        // 3. var 用於 null 初始化

94

        // var nullVar = null; // 編譯錯誤：無法推斷 null 的類型 (需要顯式轉型)

95

        String nullVar = null; // 正確範例

96

​

97

        // 4. 多次賦值不同類型

98

        var typeFixed = 10; // typeFixed 推斷為 int

99

        // typeFixed = "test"; // 編譯錯誤：變數類型一旦推斷就不可變

100

​

101

        System.out.println("Illegal Var example completed");

102

​

103

    }

104

​

105

    // 5. var 用於方法參數

106

    // public void myMethod(var parameter){} //編譯錯誤：不能用於方法參數

107

​

108

    // 6. var 用於 instance field

109

    // private var myVar = "a"; //編譯錯誤: 不能用於 instance field (類別級別變數)

110

}

111

​

執行結果：

$ javac -encoding utf-8 MyInterface.java $ java VarExample.java Name: John Doe, Age: 30 Names: [Alice, Bob] Data Map: {scores=[90, 85, 95]} Item: apple Item: banana Item: cherry First Line: public class VarExample { Result from method chain: Method Chain Result Override abstractMethod(). Default implementation Running Illegal Var example completed

xxxxxxxxxx

 

1

$ javac -encoding utf-8 MyInterface.java

2

$ java VarExample.java

3

Name: John Doe, Age: 30

4

Names: [Alice, Bob]

5

Data Map: {scores=[90, 85, 95]}

6

Item: apple

7

Item: banana

8

Item: cherry

9

First Line: public class VarExample {

10

Result from method chain: Method Chain Result

11

Override abstractMethod().

12

Default implementation

13

Running

14

Illegal Var example completed

15

​

不合法使用範例：

1. 未初始化的 var
   

   

2. var 用於不正確的修飾子
   

   

3. var 用於 null 初始化
   

   

4. var 多次賦值不同類型
   

   

5. var 用於方法參數
   

   

6. var 用於 instance field
   

   

架構分析：

var 的引入並非改變 Java 的強型別特性，編譯器會在編譯期間根據初始化值推斷出變數的具體類型，並將其儲存在 .class 檔中，所以程式運行時變數依舊是強型別的。這意味著 var 本質上是一種語法糖，讓開發人員可以少寫一些程式碼，但底層的類型檢查機制依舊存在。

四、Java 11 ~ Java 17： var 的使用場景與最佳實踐

返回目錄

Java 10 引入 var 後，在後續版本中，並沒有對 var 進行重大修改，而是更強調 var 的使用場景與最佳實踐：

• 迴圈： var 在迴圈中使用時能更簡潔：
  List<String> list = Arrays.asList("apple", "banana", "cherry"); for (var item : list) { System.out.println(item); }

  xxxxxxxxxx

   

  1

  List<String> list = Arrays.asList("apple", "banana", "cherry");

  2

  for (var item : list) {

  3

    System.out.println(item);

  4

  }

  5

  ​
• try-with-resources： 在 try-with-resources 語句中使用 var 可以簡化資源宣告：
  try (var reader = new BufferedReader(new FileReader("file.txt"))) { String line = reader.readLine(); // ... }

  xxxxxxxxxx

   

  1

  try (var reader = new BufferedReader(new FileReader("file.txt"))) {

  2

     String line = reader.readLine();

  3

     // ...

  4

  }

  5

  ​
• 方法鏈式呼叫： 當使用方法鏈式呼叫，且類型較長時，使用 var 可提高可讀性：

var result = someObject.getFirst().getSecond().getThird();

xxxxxxxxxx

 

1

var result =  someObject.getFirst().getSecond().getThird();

2

​

最佳實踐：

• 可讀性優先： 當類型明顯或能夠輕易從初始化值推斷時，使用 var 會提高程式碼的可讀性。以下是一些「類型明顯或容易推斷」的例子：
  • 基礎型別： 當初始化值是字串字面值 (String)，整數 (int, long, short)，浮點數 (double, float)，布林值 (boolean) 等時，類型非常明顯。
    var name = "John Doe"; // name 推斷為 String var age = 30; // age 推斷為 int var price = 99.99; // price 推斷為 double var isValid = true; // isValid 推斷為 boolean

    xxxxxxxxxx

     

    1

    var name = "John Doe"; // name 推斷為 String

    2

    var age = 30;           // age 推斷為 int

    3

    var price = 99.99;       // price 推斷為 double

    4

    var isValid = true;   // isValid 推斷為 boolean

    5

    ​
  • 泛型類別： 當初始化值是使用 new 關鍵字建立的泛型類別實例時，類型也比較容易推斷。
    var names = new ArrayList<String>(); // names 推斷為 ArrayList<String> var dataMap = new HashMap<String, Integer>(); // dataMap 推斷為 HashMap<String, Integer>

    xxxxxxxxxx

     

    1

    var names = new ArrayList<String>(); // names 推斷為 ArrayList<String>

    2

    var dataMap = new HashMap<String, Integer>(); // dataMap 推斷為 HashMap<String, Integer>

    3

    ​
  • 透過方法呼叫返回的類型： 當方法返回值類型明確時，使用 var 可以簡化程式碼。
    String getMessage(){ return "Hello"; } var message = getMessage(); // message 推斷為 String

    xxxxxxxxxx

     

    1

     String getMessage(){

    2

         return "Hello";

    3

    }

    4

    var message = getMessage(); // message 推斷為 String

    5

    ​
  • 常數宣告: 如果是使用 static final 修飾的常數，類型非常明確。
    static final int MAX_VALUE = 100; var max = MAX_VALUE; // max 推斷為 int

    xxxxxxxxxx

     

    1

     static final int MAX_VALUE = 100;

    2

     var max = MAX_VALUE; // max 推斷為 int

    3

    ​
• 避免濫用： 不要為了 var 而 var ，如果變數類型本身就不易推斷，或者程式碼需要很明確的類型，則應當避免使用。
• 搭配明確命名： 好的變數名稱可以幫助理解程式碼的意圖，即使使用了 var ，也要命名具有意義的變數名稱。

工具與 IDE：

大多數主流的 Java IDE (IntelliJ IDEA, Eclipse, VS Code) 都支持 var 的語法高亮、類型推斷和程式碼重構等功能，這些工具可以幫助開發人員更有效地使用 var 。

五、總結

返回目錄

var 類型推斷是 Java 語言的一個重大改進，它通過簡化程式碼、提升開發效率，使得 Java 程式碼更加簡潔易讀。然而， var 並非萬能，合理使用 var ，遵循最佳實踐，才能更好地發揮它的優勢。Java 7 到 Java 9 的傳統型別宣告模式，在需要更明確的變數型別時仍有其必要性。Java 10 引入 var ，使得開發者有了更靈活的選擇，可以根據實際場景來選擇使用明確的型別宣告或是 var 。在 Java 11 至 Java 17 中， var 的應用場景更加明確，最佳實踐也被廣泛討論，強調了在簡化程式碼的同時，需要確保程式碼的可讀性和可維護性。 總而言之， var 不是為了取代明確的類型宣告，而是在適當的場景下，讓程式碼更簡潔易讀。開發者應該根據程式碼的複雜度，可讀性以及可維護性，選擇使用 var 或是明確的類型宣告。 var 不僅僅是一個語法糖，更是 Java 語言在提高開發效率上邁出的重要一步。