Java 变量详解：类型、作用域、var、final 与常见错误

1 1. Java 中的“变量”是什么？
- 1.1 1.1 变量能做什么（存储值并复用）
- 1.2 1.2 Java 变量与“类型”一起使用（类型安全）
  - 1.2.1 “类型安全”到底是什么意思？
  - 1.2.2 注意：即使是“变量”，也分为“值”和“引用”
2 2. 变量基础：声明、赋值和初始化的区别
3 3. 理解变量“类型”（基本类型和引用类型）
4 4. 变量种类（它们所在位置）与作用域（它们的有效范围）
5 5. 正确使用 var（类型推断）于 Java 10 及以上版本
6 6. “我不想改变这个值”——final 与常量的概念
7 7. 初始值、默认值和常见错误（初学者陷阱恢复）
8 8. 总结：Java 变量必须首先掌握的要点

1. Java 中的“变量”是什么？

当你开始学习 Java 时，首先会遇到的一个重要概念是“变量”。
简而言之，变量是 一个容器，用于在程序内部临时存储值（数据），以便你可以根据需要多次复用这些值。

然而，在 Java 中，如果你把变量仅仅记作“盒子”，很快就会卡住。
因为 Java 变量是 与“类型”（数据的种类）一起处理的。

在本节中，我们将为初学者梳理变量的作用以及 Java 特有的思考方式（类型的重要性）。

1.1 变量能做什么（存储值并复用）

有了变量，程序可以从“单次计算”转向“有意义的处理”。

例如，你可以直接写数字，如下所示：

System.out.println(100 + 20);

这样可以运行，但 这些值没有任何意义，以后阅读代码的人（包括未来的你）会感到困惑。
你根本不知道 “100 是什么？” 或者 “20 是什么？”

通过使用变量，你可以为这些值赋予意义。

int price = 100;
int tax = 20;
System.out.println(price + tax);

以这种方式使用变量可以带来以下好处：

更容易理解意图（像 price、tax 这样的名称能传达意义）
可以重复使用值（不必一次又一次写相同的数值）
以后更易修改（如果税率变化，只需修改变量的值）
可以保留中间结果（把复杂逻辑拆分成更小的步骤）

作为初学者，把“变量 = 为值命名”是可以接受的。
但在 Java 中，接下来的概念——“类型”——总是与变量一起出现。

1.2 Java 变量与“类型”一起使用（类型安全）

在 Java 中，变量通常以如下形式创建：

type variableName = value;

示例：

int age = 20;
String name = "Sagawa";

这里的关键点是类型。

int 表示整数（例如 20、100、-5）
String 表示字符串（例如 "Hello"、"Java"）

在 Java 中，创建变量时必须显式声明“该变量能容纳什么类型的值”。
正是由于这种机制，Java 具备了以下优势。

“类型安全”到底是什么意思？

因为你指定了类型，当你尝试把错误类型的值放入变量时，Java 能阻止你。

例如，如果你把字符串放入 int 变量，编译时就会报错。

int age = "20"; // This is an error

这并不是不方便，恰恰相反，它很有帮助。
你可以在“运行程序之前”就“检测到错误”，而不是等到程序运行后才发现问题。

初学者有时会觉得“Java 错误很多”，但如果换个角度看：

Java 提前发现类型不匹配
项目越大，类型的帮助越明显，能减少意外错误

这种“类型与变量一起出现”的理念是 Java 最基本的概念之一。

注意：即使是“变量”，也分为“值”和“引用”

Java 变量大体上有两种处理方式：

基本类型：直接处理值本身（例如 int、double、boolean）
引用类型：处理的不是值本身，而是存放该值的地址（引用），如 String、数组、类等

这里不做深入展开，但这是初学者常见的困惑点，值得提前说明。

例如，String 是引用类型。
看起来像是“存储了一个字符串”，但严格来说，你持有的是“指向字符串对象的引用”。

这种差异也与后面要学习的主题有关，如 “== 与 equals 的区别” 以及 “final 的行为”。

2. 变量基础：声明、赋值和初始化的区别

要正确理解 Java 变量，
必须理清 “声明” 、 “赋值” 与 “初始化” 之间的区别。

初学者经常把这三个词当作同义词使用，
但实际上，它们的作用截然不同。

如果你保持这种模糊，
更容易陷入
“我不知道为什么会报错” 或 “我不知道为什么不能使用它” 的状态。

2.1 声明：准备使用变量

声明意味着告诉 Java：
“我要使用一个叫这个名字的变量”，以及 “它的类型是这个”。

最基本的声明如下所示：

int count;

此时，只发生了以下两件事：

创建了一个名为 count 的变量
决定它的类型是 int（整数）

尚未存入任何值。

这是初学者常见的误解：
仅仅声明一个变量并不会使它“可用”。

2.2 赋值：向变量中放入值

赋值意味着向已经声明的变量中放入一个值。

count = 10;

这个 = 并不是数学中的“等于”。
它的含义是 把右侧的值放入左侧的变量。

于是流程变为：

int count;   // declaration
count = 10;  // assignment

这就是概念所在。

注意：不能给未声明的变量赋值

下面的代码会导致错误：

count = 10; // Error: count has not been declared

在 Java 中，顺序必须是 声明 → 赋值。

2.3 初始化：在声明时同时赋值

初始化 意味着在同一时刻完成声明和赋值。

int count = 10;

这在语义上等同于下面这两行代码：

int count;
count = 10;

在 Java——无论是实际工作还是学习中——
在大多数情况下，假设你使用“初始化”是没有问题的。

因为它带来了以下好处：

变量在创建的瞬间即可使用
防止因未初始化变量导致的错误
代码更易阅读

因此，作为初学者，
建议养成 在声明时就初始化变量 的习惯。

2.4 为什么仅有声明的变量不能使用（局部变量规则）

在 Java 中，对 局部变量（方法内部的变量） 有非常严格的规则。
Java 在这方面尤其严格。

下面的代码会导致编译时错误：

int number;
System.out.println(number); // Error

原因显而易见：

局部变量在未初始化之前不能使用

这条规则确实存在。

Java 将 “我们不知道 number 中到底是什么” 的状态视为
一种危险状态，并在执行前将其视为错误阻止。

这对初学者来说可能感觉过于严格，但在大规模开发中，
它是非常重要的安全机制。

2.5 一次声明多个变量（需谨慎）

在 Java 中，你可以一次声明多个同类型的变量。

int x, y, z;

也可以这样写：

int a = 1, b = 2, c = 3;

这在语法上是正确的，但 可能降低可读性，因此需小心。

尤其是对初学者和团队开发来说，写成下面的形式更安全：

int a = 1;
int b = 2;
int c = 3;

即 每行一个变量。

2.6 本节小结

本节需要记住的要点：

声明：确定变量的名称和类型
赋值：向变量放入一个值
初始化：同时进行声明和赋值
局部变量 未初始化前不能使用
作为初学者，默认使用 “声明 + 初始化”

3. 理解变量“类型”（基本类型和引用类型）

在使用 Java 变量时，你无法回避对类型的理解。
初学者常常困惑的点包括：

为什么类型这么多
为什么数字既有 int 又有 double
String 与数值类型有何不同

在本节中，我们将从两个角度组织 Java 类型：“原始类型”和“引用类型”。

3.1 Java 类型分为两大类

Java 变量类型大致可以分为以下两类：

原始类型
引用类型

一旦你理解了这种分类，后面要学习的主题——比如 “== 与 equals 的区别”、 “final 的行为”、以及 “内存工作方式”——就会容易得多。

3.2 什么是原始类型？（直接保存值本身的类型）

原始类型是直接保存值本身的类型。

让我们来看几个常见的原始类型：

int count = 10;
double price = 19.99;
boolean isActive = true;

这些变量在变量内部存储“值本身”。

常用原始类型

Type	Meaning	Example Use
`int`	Integer	Counts, age, number of times
`long`	Large integer	Amounts of money, IDs
`double`	Decimal	Prices, ratios
`boolean`	True/false	Flag checks
`char`	Single character	Character processing

作为初学者，先掌握 int、double 和 boolean 就足够了。

3.3 原始类型的特性与注意事项

原始类型具有以下特性：

它们保存值本身
处理速度快
不能赋值为 null
大小固定

例如，在下面的代码中，a 和 b 保存的是完全独立的值。

int a = 5;
int b = a;
b = 10;

在这种情况下：

a 仍为 5
b 变为 10

这就是结果。

这是因为 值本身被复制了。

3.4 什么是引用类型？（处理值所在位置的类型）

另一方面，引用类型是处理值本身不是，而是值所在位置（引用）的类型。

典型的引用类型包括：

String name = "Java";
int[] numbers = {1, 2, 3};

String
数组
类
接口
如 List / Map 的集合

以上全部都是引用类型。

通过图片理解引用类型

引用类型的变量保存：

不是实际对象本身，而是
指向实际对象存放位置的“地址”

这就是思维模型。

3.5 给引用类型赋值会发生什么？

看下面的代码：

String a = "Hello";
String b = a;
b = "World";

在这种情况下：

a 为 “Hello”
b 为 “World”

这就是结果。

如果只看这些，你可能会认为，“这和原始类型不是一样吗？”

那么下一个例子呢？

int[] array1 = {1, 2, 3};
int[] array2 = array1;

array2[0] = 100;

结果是：

array1[0] → 100
array2[0] → 100

之所以会这样，是因为 array1 和 array2 引用了同一个数组。

对于引用类型：

给变量赋值可能会使它们“指向同一个实际对象”。
改变内容会影响所有引用它的变量

这就是关键特性。

3.6 常见的初学者困惑点

让我们总结一下常见的卡点：

原始类型 → 值被复制
引用类型 → 引用（位置）被复制

这种差异与以下主题密切相关：

== 与 .equals() 的区别
使用 final 时会发生什么
将值作为方法参数传递时对作用域和行为的影响

目前，只需记住这一点：引用类型有时会共享同一个实际对象。

3.7 本节小结

Java 类型分为 原始类型 和 引用类型
原始类型处理“值本身”。
引用类型处理“值的位置（引用）”。
对引用类型，赋值和修改可能会影响其他变量

4. 变量种类（它们所在位置）与作用域（它们的有效范围）

在 Java 中，变量不仅在“类型”上有所不同。它们的行为还会根据 声明位置（它们所在的地方） 而变化。

如果你不了解这种差异，可能会被以下情况弄糊涂：

“我不能使用之前声明的变量”
“它的名字相同，但值不同”
“我不明白为什么这里不能引用它”

在本节中，我们将为初学者整理
变量种类 和 作用域。

4.1 什么是作用域？（变量可以使用的范围）

作用域 指
变量可以被使用的范围。

在 Java 中，作用域严格由以下因素决定：

变量声明的位置
大括号 { } 的范围

基本规则非常简单：

变量只能在声明它的代码块内部使用

4.2 局部变量（方法内部的变量）

局部变量 是在方法或代码块（如 if、for）内部声明的变量。

public void sample() {
    int x = 10;  // local variable
    System.out.println(x);
}

这个 x 具有以下特性：

仅在 sample 方法内部有效
方法结束时即消失

使用代码块的作用域示例

if (true) {
    int y = 5;
    System.out.println(y);
}

System.out.println(y); // Error

因为 y 在 if 代码块内部声明，所以在块外无法使用它。

局部变量的重要规则

局部变量有严格的规则：

未初始化前不能使用它们

不会自动赋予默认值

int value;
System.out.println(value); // compile-time error

这是 Java 为防止使用“未定义值”而设计的安全机制的一部分。

4.3 字段（实例变量）

字段是在类内部、方法之外声明的变量。

public class Sample {
    int count;  // field (instance variable)

    public void printCount() {
        System.out.println(count);
    }
}

字段与局部变量的特性不同：

类的每个实例都有自己的副本
它们会自动使用默认值进行初始化
可以在类的任何方法中使用它们

字段的默认值

根据类型，以下默认值会自动设置：

int → 0
double → 0.0
boolean → false
引用类型 → null

因此下面的代码不会产生错误：

public class Sample {
    int count;

    public void print() {
        System.out.println(count); // 0
    }
}

然而，过度依赖默认值并不推荐。
显式初始化可以让代码意图更清晰。

4.4 静态变量（类变量）

带有 static 的变量会变成
整个类共享的变量。

public class Counter {
    static int total = 0;
}

这个 total 具有以下特性：

每个类只有一个实例
所有对象共享它

静态变量的思维模型

实例变量 → 每个人的钱包
静态变量 → 公司共享的保险箱

这个模型有助于更容易理解。

静态变量的注意事项

静态变量很有用，但 存储过多状态会导致错误。

难以追踪状态何时被修改
测试变得更困难
在并发处理时更容易出现问题

作为初学者，建议将其使用限制在以下场景：

常量
共享的配置值

以及类似的用途。

4.5 警惕同名变量（遮蔽）

看下面的代码：

public class Sample {
    int value = 10;

    public void test() {
        int value = 5;
        System.out.println(value);
    }
}

在此情况下，输出是 5。

这是因为
局部变量隐藏了字段（产生遮蔽）。

由于这是初学者常见的困惑来源：

避免使用重复的变量名
除非有意，否则不要复用相同的名称

这种规范非常重要。

4.6 本节小结

范围（Scope）指“变量可以被使用的范围”
局部变量只能在代码块内部有效，并且必须进行初始化
成员字段会自动赋予默认值
静态变量在整个类中共享
注意同名变量导致的遮蔽（shadowing）问题

5. 正确使用 `var`（类型推断）于 Java 10 及以上版本

在 Java 10 中引入的 var 是
一种让编译器推断变量类型的方式。

它看起来很方便，但如果使用不当，容易导致“难以阅读的代码”。
因此，了解使用规则以及何时使用它非常重要。

5.1 什么是 `var`？（在不写类型的情况下它是如何工作的）

在普通的 Java 中，你会这样声明变量：

String message = "Hello";

使用 var，你可以这样写：

var message = "Hello";

此时，Java 会查看右侧的 "Hello" 并判断：

该变量的类型是 String

关键点在于 var 并不是动态类型。

类型在编译时确定
运行时类型不会改变

所以可以把 var 看作是“省略类型的简写”。

5.2 `var` 的使用范围与限制

var 只能在严格限定的地方使用。

可以使用 `var` 的位置

仅限局部变量

public void sample() {
    var count = 10;
}

不能使用 `var` 的位置

以下所有用法都会导致错误：

var x;                 // No initialization → error
var y = null;          // Cannot infer the type → error

class Sample {
    var value = 10;    // Cannot be used for fields → error
}

之所以有这些限制，原因很明确：为了避免降低可读性和安全性。

5.3 使用 `var` 的好处

当类型很长时，var 能发挥优势。

ArrayList<String> list = new ArrayList<String>();

使用 var：

var list = new ArrayList<String>();

代码会变得更加简洁。

换句话说，var 在以下情况下很有用：

泛型类型很冗长
类型可以从右侧表达式明显看出

以这种方式使用时，它可以提升可读性。

5.4 `var` 的陷阱（初学者常见错误）

var 很便利，但如果初学者滥用，会出现以下问题。

类型难以辨认

var data = getData();

仅凭这一行，你无法判断：

数据的具体类型是什么
它包含了什么内容

在这种情况下，显式写出类型会更安全。

Data data = getData();

可能得到意外的类型

var number = 10;   // int

初学者常会遇到类似的情况，
“我以为它会是长类型”。

当你不显式写出类型时，你的意图与实际推断出的类型可能不一致，因此需格外小心。

5.5 如何决定是否使用 `var`

如果不确定，可参考以下标准：

类型从右侧表达式可以明显看出 → 可以使用 var
类型本身具有重要意义 → 请显式写出类型
初学者友好 / 学习代码 → 尽可能写出类型
团队开发 → 遵循团队的编码规范

尤其在学习阶段，
显式写出类型有助于加深理解，因此不必强迫自己使用 var。

5.6 本节小结

var 是类型推断的简写
它不是动态类型；类型在编译时已确定
仅适用于局部变量，并且必须进行初始化
需要辨别何时使用能提升可读性，何时会降低可读性

6. “我不想改变这个值”——`final` 与常量的概念

在 Java 中，“一旦值确定，就不允许后续修改”的设计理念非常重要。

实现这一点的工具是 final。

初学者常误以为 “final 只用于常量”，但实际上它的含义更广泛。

6.1 什么是 `final`？（禁止重新赋值）

一个带有 final 的变量 在你赋值一次后不能被重新赋值。

final int maxCount = 10;
maxCount = 20; // compile-time error

规则非常简单：

你可以初始化它
你不能重新赋值它

这就是你需要记住的一切。

6.2 为什么在局部变量上使用 `final`？

在局部变量上添加 final 可以清楚地表明：

这个变量不会中途改变
值是固定的

它有助于 在代码中清楚地表达你的意图。

final int basePrice = 100;
int total = basePrice + 20;

这样写：

有助于防止意外更改
让读者感觉更安全

这些就是好处。

6.3 在字段上使用 `final`

在字段上添加 final 使其成为
该实例的不可变值。

public class User {
    final String name;

    public User(String name) {
        this.name = name;
    }
}

在这种情况下：

name 只能在构造函数中设置一次
之后不能更改

这是 稳定对象状态 的重要设计方法。

6.4 `final` 与引用类型的重要注意事项（常见初学者困惑）

这是一个非常重要的点：

final int[] numbers = {1, 2, 3};
numbers[0] = 100;   // OK
numbers = new int[]{4, 5, 6}; // Error

为什么会这样？

原因是 final 限制了 “引用的重新赋值”。

更改数组的内容 → OK
更改变量引用的数组 → NG

换句话说，final 不会使内容不可变。

如果你不理解这一点，你可能会困惑并认为：

“为什么它是 final 的还能改变？”
“这是个 bug 吗？”

这就是为什么这个区别很重要。

6.5 什么是常量？（`static final`）

在 Java 中，人们通常称为“常量”的东西，按照约定通常使用 static final 定义。

public class Config {
    public static final int MAX_USERS = 100;
}

这种常量具有以下特征：

在整个类中共享
值不能被更改
你可以给它一个有意义的名称

常量的命名约定

常量通常以以下风格书写：

UPPER_SNAKE_CASE

示例：

static final double TAX_RATE = 0.1;

6.6 如何决定何时使用 `final`

作为初学者，以下标准易于使用：

如果值不需要改变 → 添加 final
配置值 / 基线值 → 使用 static final
如果意外更改会有问题 → 添加 final

尤其在实践中，一个常见的思维方式是：

“如果你不确定，就添加 final。”

在许多情况下，这是一个好的平衡。

6.7 章节总结

使用 final，你不能重新赋值变量
你可以用于局部变量和字段
引用类型上的 final 不意味着“不可变内容”
常量使用 static final 定义
final 是编写更安全、更清晰代码的工具

7. 初始值、默认值和常见错误（初学者陷阱恢复）

到目前为止，你已经学习了声明、类型、作用域、var 和 final。
然而，在实践中，有很多情况 “我概念上理解了，但还是会出错。”

在本节中，我们将整理 常见初学者绊脚石 以及原因。

7.1 局部变量没有默认值

首先，一个非常重要的规则：

局部变量不会获得自动默认值

以下代码会导致编译时错误：

public void sample() {
    int x;
    System.out.println(x); // Error
}

原因很简单：Java 不允许“我们不知道 x 里面是什么”的状态。

正确方法

public void sample() {
    int x = 0;
    System.out.println(x);
}

对于局部变量，严格遵守规则：总是自己初始化它们。

7.2 字段会自动获取默认值

另一方面，字段（实例变量和静态变量）
会自动被赋予初始值。

public class Sample {
    int count;
    boolean active;
    String name;
}

默认值如下：

int → 0
double → 0.0
boolean → false
引用类型 → null

因此下面的代码不会产生错误：

public class Sample {
    int count;

    public void print() {
        System.out.println(count); // 0
    }
}

然而，依赖默认值的设计并不推荐。
它们会使意图难以看清，并且很容易成为 bug 的温床。

7.3 `null` 引起的错误（NullPointerException）

引用类型的默认值是 null。

String text;

如果在这种状态下调用方法，你会得到运行时错误：

System.out.println(text.length()); // NullPointerException

这是初学者最常遇到的异常之一。

基本对策

尽可能进行初始化
考虑 null 的可能性
设计时避免无意使用 null
```
String text = "";
```

即使用空字符串进行初始化也能防止许多意外。

7.4 在作用域之外使用变量

下面是另一个常见错误：

if (true) {
    int value = 10;
}

System.out.println(value); // Error

这是一个 作用域外引用 问题。

value 仅在 if 块内部有效
块外不存在

重新确认该规则。

7.5 同名变量导致的混淆（重新审视遮蔽）

public class Sample {
    int value = 10;

    public void test() {
        int value = 5;
        System.out.println(value);
    }
}

这段代码会打印 5。

初学者常误以为：

会使用字段的值

但实际上，
内部作用域优先。

由于遮蔽会导致混淆：

根据角色使用不同的变量名

记住这一点。

7.6 类型不匹配导致的编译时错误

以下赋值是不允许的：

int number = 3.14; // Error

原因如下：

double → int 不会自动转换

这就是规则。

正确做法（当你有意为之时）

int number = (int) 3.14; // 3

但要注意，小数部分会被截断。

7.7 章节小结

局部变量必须初始化
字段会获取默认值，但不要过度依赖
null 常导致运行时错误
不能在作用域之外使用变量
类型不匹配会在编译时报错

8. 总结：Java 变量必须首先掌握的要点

在本文中，我们一步步梳理了“Java 变量”这一主题，
聚焦于初学者常感困惑的要点。

最后，让我们以 既适合学习又适用于实际编码 的形式总结关键要点。

8.1 将 Java 变量视为由 “类型、名称和值” 组成的一组

Java 变量始终包含以下三个要素：

类型：它持有什么类型的值
名称：该值代表什么
值：实际存储的数据
```
int count = 10;
```

这一行代码包含了 Java 变量的全部精髓。

8.2 清晰区分声明、赋值和初始化

初学者常见的陷阱是模糊这三个术语的区别：

声明：准备使用变量
赋值：将值放入变量
初始化：同时进行声明和赋值

尤其是局部变量，记住规则：未初始化前不能使用它们。

8.3 了解基本类型和引用类型的区别

Java 类型大致分为两类：

基本类型：直接处理值本身
引用类型：处理值所在的位置（引用）

牢记这一差异有助于你自然地理解：

值的复制
数组和对象的行为方式
final 真正的含义

8.4 理解作用域可显著减少错误

变量只能在声明它们的地方使用。

局部变量 → 仅在代码块内部有效
字段 → 在整个类中都可使用
静态变量 → 在整个类中共享

如果你曾想过“我不知道为什么不能使用它”，
首先怀疑作用域。

8.5 根据用途使用 `var` 和 `final`

var → 仅在类型明确且可提升可读性时使用
final → 用于明确表达“此值不应改变”的意图

两者都很方便，但要注意不要把“使用它们”本身当作目标。

8.6 初学者安全编写指南

在学习阶段，以下原则可减少错误：

声明变量时立即初始化
尽可能显式写出类型
使用有意义的名称
若不确定，可尝试添加 final

仅此一步就能让你更接近 可读且安全的 Java 代码。

8.7 深入理解的后续学习主题

在掌握变量后，建议继续学习：

条件语句（ if / switch ）
循环（ for / while ）
数组和集合（List / Map）
方法和参数
面向对象基础

变量是 所有 Java 代码的基石。

彻底理解它们后，你后续的学习将会变得更加顺畅。

Prev

2026年1月1日
Java double 详解：范围、精度、常见陷阱及 BigDecimal 替代方案
Next
記事がありません

Java 变量详解：类型、作用域、var、final 与常见错误

1. Java 中的“变量”是什么？

1.1 变量能做什么（存储值并复用）

1.2 Java 变量与“类型”一起使用（类型安全）

“类型安全”到底是什么意思？

注意：即使是“变量”，也分为“值”和“引用”

2. 变量基础：声明、赋值和初始化的区别

2.1 声明：准备使用变量

2.2 赋值：向变量中放入值

注意：不能给未声明的变量赋值

2.3 初始化：在声明时同时赋值

2.4 为什么仅有声明的变量不能使用（局部变量规则）

2.5 一次声明多个变量（需谨慎）

2.6 本节小结

3. 理解变量“类型”（基本类型和引用类型）

3.1 Java 类型分为两大类

3.2 什么是原始类型？（直接保存值本身的类型）

常用原始类型

3.3 原始类型的特性与注意事项

3.4 什么是引用类型？（处理值所在位置的类型）

通过图片理解引用类型

3.5 给引用类型赋值会发生什么？

3.6 常见的初学者困惑点

3.7 本节小结

4. 变量种类（它们所在位置）与作用域（它们的有效范围）

4.1 什么是作用域？（变量可以使用的范围）

4.2 局部变量（方法内部的变量）

使用代码块的作用域示例

局部变量的重要规则

4.3 字段（实例变量）

字段的默认值

4.4 静态变量（类变量）

静态变量的思维模型

静态变量的注意事项

4.5 警惕同名变量（遮蔽）

4.6 本节小结

5. 正确使用 var（类型推断）于 Java 10 及以上版本

5.1 什么是 var？（在不写类型的情况下它是如何工作的）

5.2 var 的使用范围与限制

可以使用 var 的位置

不能使用 var 的位置

5.3 使用 var 的好处

5.4 var 的陷阱（初学者常见错误）

类型难以辨认

可能得到意外的类型

5.5 如何决定是否使用 var

5.6 本节小结

6. “我不想改变这个值”——final 与常量的概念

6.1 什么是 final？（禁止重新赋值）

6.2 为什么在局部变量上使用 final？

6.3 在字段上使用 final

6.4 final 与引用类型的重要注意事项（常见初学者困惑）

6.5 什么是常量？（static final）

常量的命名约定

6.6 如何决定何时使用 final

6.7 章节总结

7. 初始值、默认值和常见错误（初学者陷阱恢复）

7.1 局部变量没有默认值

正确方法

7.2 字段会自动获取默认值

7.3 null 引起的错误（NullPointerException）

基本对策

7.4 在作用域之外使用变量

7.5 同名变量导致的混淆（重新审视遮蔽）

7.6 类型不匹配导致的编译时错误

正确做法（当你有意为之时）

7.7 章节小结

8. 总结：Java 变量必须首先掌握的要点

8.1 将 Java 变量视为由 “类型、名称和值” 组成的一组

8.2 清晰区分声明、赋值和初始化

8.3 了解基本类型和引用类型的区别

8.4 理解作用域可显著减少错误

8.5 根据用途使用 var 和 final

8.6 初学者安全编写指南

8.7 深入理解的后续学习主题

Java double 详解：范围、精度、常见陷阱及 BigDecimal 替代方案

5. 正确使用 `var`（类型推断）于 Java 10 及以上版本

5.1 什么是 `var`？（在不写类型的情况下它是如何工作的）

5.2 `var` 的使用范围与限制

可以使用 `var` 的位置

不能使用 `var` 的位置

5.3 使用 `var` 的好处

5.4 `var` 的陷阱（初学者常见错误）

5.5 如何决定是否使用 `var`

6. “我不想改变这个值”——`final` 与常量的概念

6.1 什么是 `final`？（禁止重新赋值）

6.2 为什么在局部变量上使用 `final`？

6.3 在字段上使用 `final`

6.4 `final` 与引用类型的重要注意事项（常见初学者困惑）

6.5 什么是常量？（`static final`）

6.6 如何决定何时使用 `final`

7.3 `null` 引起的错误（NullPointerException）

8.5 根据用途使用 `var` 和 `final`