【Java SE】var关键字

var关键字

var是什么？
var的核心特性
var的优势
var的最佳实践
常见陷阱与注意事项
- 原始类型vs包装类型
- 多态场景
- 链式调用中的类型丢失
- lambda表达式
- [Java 11+的增强：var在lambda中的应用](#Java 11+的增强：var在lambda中的应用)

var是什么？

var是Java 10引入的局部变量类型推断关键字。它允许编译器根据初始化表达式自动推断变量的实际类型，从而让开发者省略显式的类型声明。

java 复制代码

// 传统写法
String message = "Hello, Java!";
List<String> list = new ArrayList<>();
Map<String, List<Integer>> complexMap = new HashMap<>();

// 使用var后的写法
var message = "Hello, Java!";        // 推断为String
var list = new ArrayList<String>();  // 推断为ArrayList<String>
var complexMap = new HashMap<String, List<Integer>>();  // 推断为HashMap<String, List<Integer>>

var的核心特性

编译时类型推断

var是编译时特性，而非运行时特性。编译器会在编译阶段根据右侧的初始化表达式推断出确切的类型，生成的字节码与显式声明类型完全相同。

java 复制代码

var num = 42;           // 推断为int
var pi = 3.14159;       // 推断为double
var flag = true;        // 推断为boolean
var name = "Java";      // 推断为String
var numbers = new int[]{1, 2, 3};  // 推断为int[]

必须立即初始化

使用var声明变量时，必须同时进行初始化，否则编译器无法推断类型：

java 复制代码

var x;              // ❌ 编译错误：无法推断类型
var y = 10;         // ✅ 正确
var z;              // ❌ 编译错误
z = 20;

不能用于某些场景

var只能用于局部变量，不能用于以下场景：

场景	是否可用	说明
局部变量	✅	var的主要应用场景
方法参数	❌	必须显式声明类型
返回类型	❌	必须显式声明返回类型
字段/成员变量	❌	类字段不能使用var
catch子句	❌	异常参数必须显式声明
lambda参数	❌	需要显式类型或使用var（Java 11+有限支持）

java 复制代码

public class VarExample {
    // ❌ 字段不能使用var
    // var instanceVar = "test";
    
    // ❌ 方法返回类型不能使用var
    // var getValue() { return 10; }
    
    public void method() {
        // ✅ 局部变量可以使用var
        var localVar = "Hello";
        
        // ❌ 参数不能使用var
        // var parameter -> 不允许
    }
    
    // ❌ catch块不能使用var
    public void exceptionHandling() {
        try {
            // ...
        } catch (Exception e) {  // 不能写成 catch(var e)
            // ...
        }
    }
}

var的优势

减少样板代码

在泛型嵌套复杂的场景中，var的优势尤为明显：

java 复制代码

// 不使用var的写法（冗长）
Map<String, Map<String, List<Customer>>> customerMap = 
    new HashMap<String, Map<String, List<Customer>>>();

// 使用var的写法（简洁）
var customerMap = new HashMap<String, Map<String, List<Customer>>>();

// 或者使用菱形运算符进一步简化
var customerMap = new HashMap<String, Map<String, List<Customer>>>();

提高代码可读性

在某些场景下，去除重复的类型声明可以让代码更聚焦于业务逻辑：

java 复制代码

// 传统写法
ByteArrayInputStream inputStream = new ByteArrayInputStream(data);
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));

// var写法
var inputStream = new ByteArrayInputStream(data);
var reader = new BufferedReader(new InputStreamReader(inputStream));

便于重构

当方法的返回类型发生变化时，使用var的代码无需修改：

java 复制代码

// 假设方法返回类型从ArrayList改为LinkedList
public List<String> getNames() {
    return new ArrayList<>();  // 重构后改为 return new LinkedList<>();
}

// 使用var的调用方无需修改
var names = getNames();  // 类型自动适配为新的返回类型

// 显式声明的调用方需要修改
ArrayList<String> names = getNames();  // 类型不匹配，需要修改

var的最佳实践

保留必要的信息

var不是让你省略所有类型信息，而是让你在不必要的地方省略：

java 复制代码

// ✅ 好的实践：右侧表达式清晰表明类型
var name = "John Doe";                    // String明确
var users = new ArrayList<User>();        // ArrayList<User>明确
var currentTime = System.currentTimeMillis();  // long明确

// ❌ 不好的实践：类型信息丢失，影响可读性
var result = calculate();        // 不知道返回什么类型
var data = getData();            // 类型不明确
var value = map.get(key);        // 无法直观看出类型

结合接口编程

使用var时，编译器推断的是实际类型而非接口类型，这可能带来意外：

java 复制代码

var list = new ArrayList<String>();  // 推断为ArrayList<String>，而非List<String>
list.trimToSize();  // ✅ 可以调用ArrayList特有方法

// 如果需要接口类型，应该显式声明
List<String> list2 = new ArrayList<>();  // 使用接口类型

在流式操作中保持清晰

java 复制代码

// ✅ 清晰：变量名表达了语义
var activeUsers = users.stream()
    .filter(User::isActive)
    .collect(Collectors.toList());

// ✅ 如果类型很重要，可以保留显式声明
List<User> activeUsers = users.stream()
    .filter(User::isActive)
    .collect(Collectors.toList());

常见陷阱与注意事项

原始类型vs包装类型

java 复制代码

var num = 42;        // 推断为int，不是Integer
var value = 3.14;    // 推断为double，不是Double
var flag = true;     // 推断为boolean，不是Boolean

// 如果需要包装类型，需要明确指定
var integerNum = Integer.valueOf(42);  // 推断为Integer

多态场景

java 复制代码

// 假设有这样的类层次
class Animal {}
class Dog extends Animal {}

Animal animal = new Dog();  // 显式声明为Animal类型

var animal2 = new Dog();     // 推断为Dog类型，而非Animal

链式调用中的类型丢失

java 复制代码

// 难以看出类型
var result = service.getUser()
    .getAddress()
    .getCity()
    .toUpperCase();  // result是String吗？可能是其他类型

// 更好的写法
String city = service.getUser()
    .getAddress()
    .getCity()
    .toUpperCase();  // 类型明确

lambda表达式

java 复制代码

// ❌ 无法推断：lambda表达式没有明确的类型
// var func = (x, y) -> x + y;

// ✅ 需要提供目标类型
BiFunction<Integer, Integer, Integer> func = (x, y) -> x + y;

Java 11+的增强：var在lambda中的应用

Java 11允许在lambda参数中使用var，并支持注解：

java 复制代码

// Java 10及之前
list.stream()
    .map((@NotNull String s) -> s.toLowerCase())
    .collect(Collectors.toList());

// Java 11+
list.stream()
    .map((@NotNull var s) -> s.toLowerCase())
    .collect(Collectors.toList());