【Java SE】var关键字

var是什么？

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

// 传统写法Stringmessage="Hello, Java!";List<String>list=newArrayList<>();Map<String,List<Integer>>complexMap=newHashMap<>();// 使用var后的写法varmessage="Hello, Java!";// 推断为Stringvarlist=newArrayList<String>();// 推断为ArrayList<String>varcomplexMap=newHashMap<String,List<Integer>>();// 推断为HashMap<String, List<Integer>>

var的核心特性

编译时类型推断

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

varnum=42;// 推断为intvarpi=3.14159;// 推断为doublevarflag=true;// 推断为booleanvarname="Java";// 推断为Stringvarnumbers=newint[]{1,2,3};// 推断为int[]

必须立即初始化

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

varx;// ❌ 编译错误：无法推断类型vary=10;// ✅ 正确varz;// ❌ 编译错误z=20;

不能用于某些场景

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

publicclassVarExample{// ❌ 字段不能使用var// var instanceVar = "test";// ❌ 方法返回类型不能使用var// var getValue() { return 10; }publicvoidmethod(){// ✅ 局部变量可以使用varvarlocalVar="Hello";// ❌ 参数不能使用var// var parameter -> 不允许}// ❌ catch块不能使用varpublicvoidexceptionHandling(){try{// ...}catch(Exceptione){// 不能写成 catch(var e)// ...}}}

var的优势

减少样板代码

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

// 不使用var的写法（冗长）Map<String,Map<String,List<Customer>>>customerMap=newHashMap<String,Map<String,List<Customer>>>();// 使用var的写法（简洁）varcustomerMap=newHashMap<String,Map<String,List<Customer>>>();// 或者使用菱形运算符进一步简化varcustomerMap=newHashMap<String,Map<String,List<Customer>>>();

提高代码可读性

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

// 传统写法ByteArrayInputStreaminputStream=newByteArrayInputStream(data);BufferedReaderreader=newBufferedReader(newInputStreamReader(inputStream));// var写法varinputStream=newByteArrayInputStream(data);varreader=newBufferedReader(newInputStreamReader(inputStream));

便于重构

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

// 假设方法返回类型从ArrayList改为LinkedListpublicList<String>getNames(){returnnewArrayList<>();// 重构后改为 return new LinkedList<>();}// 使用var的调用方无需修改varnames=getNames();// 类型自动适配为新的返回类型// 显式声明的调用方需要修改ArrayList<String>names=getNames();// 类型不匹配，需要修改

var的最佳实践

保留必要的信息

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

// ✅ 好的实践：右侧表达式清晰表明类型varname="John Doe";// String明确varusers=newArrayList<User>();// ArrayList<User>明确varcurrentTime=System.currentTimeMillis();// long明确// ❌ 不好的实践：类型信息丢失，影响可读性varresult=calculate();// 不知道返回什么类型vardata=getData();// 类型不明确varvalue=map.get(key);// 无法直观看出类型

结合接口编程

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

varlist=newArrayList<String>();// 推断为ArrayList<String>，而非List<String>list.trimToSize();// ✅ 可以调用ArrayList特有方法// 如果需要接口类型，应该显式声明List<String>list2=newArrayList<>();// 使用接口类型

在流式操作中保持清晰

// ✅ 清晰：变量名表达了语义varactiveUsers=users.stream().filter(User::isActive).collect(Collectors.toList());// ✅ 如果类型很重要，可以保留显式声明List<User>activeUsers=users.stream().filter(User::isActive).collect(Collectors.toList());

常见陷阱与注意事项

原始类型vs包装类型

varnum=42;// 推断为int，不是Integervarvalue=3.14;// 推断为double，不是Doublevarflag=true;// 推断为boolean，不是Boolean// 如果需要包装类型，需要明确指定varintegerNum=Integer.valueOf(42);// 推断为Integer

多态场景

// 假设有这样的类层次classAnimal{}classDogextendsAnimal{}Animalanimal=newDog();// 显式声明为Animal类型varanimal2=newDog();// 推断为Dog类型，而非Animal

链式调用中的类型丢失

// 难以看出类型varresult=service.getUser().getAddress().getCity().toUpperCase();// result是String吗？可能是其他类型// 更好的写法Stringcity=service.getUser().getAddress().getCity().toUpperCase();// 类型明确

lambda表达式

// ❌ 无法推断：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 10及之前list.stream().map((@NotNullStrings)->s.toLowerCase()).collect(Collectors.toList());// Java 11+list.stream().map((@NotNullvars)->s.toLowerCase()).collect(Collectors.toList());