字面量、变量与数据类型

一、学习目标

完成本章后，你应该能够：

能够解释字面量（Literal）是什么，并正确书写整数、浮点数、字符、字符串、布尔值与 null。
能够正确区分 '0'、"0" 和 0。
能够使用常见转义序列表示换行、制表符、引号和反斜杠。
能够解释变量（Variable）的定义、声明、初始化、赋值与重新赋值。
能够解释变量为什么必须具有类型，以及 Java 静态类型系统带来的基本约束。
能够区分基本数据类型（Primitive Type）和引用数据类型（Reference Type）。
能够完整列出 Java 的 8 种基本数据类型并说明各自用途。
能够正确处理 long、float 字面量后缀以及常见数据范围问题。
能够解释为什么局部变量在使用之前必须初始化。
能够识别基本类型声明中的常见编译错误。

二、核心知识

2.1 什么是字面量

字面量（Literal）是：

直接出现在 Java 源代码中，用来表示某个固定值的语法形式。

例如：

表示一个整数值。

3.14

表示一个浮点数值。

'A'

表示一个字符值。

"Hello Java"

表示一个字符串。

true

表示一个布尔值。

因此学习字面量真正需要掌握的是：

不同种类的数据在 Java 源代码中应该怎样正确书写。

2.2 常见字面量总览

| 数据 | Java 写法 | 说明 | | ------ | --------------- | ------------ | | 整数 | 10 | 整数字面量 | | 小数 | 13.14 | 浮点数字面量 | | 字符 | 'A' | 字符字面量 | | 字符串 | "Hello" | 字符串字面量 | | 布尔 | true、false | 布尔字面量 | | 空引用 | null | null 字面量 |

此外还有：

二进制
八进制
十六进制
科学计数法
Text Block

等更丰富的书写形式。

进制将在下一章专门展开。

2.3 整数字面量

最常见：

默认情况下，没有类型后缀的普通整数字面量通常属于：

int

例如：

int age = 18;

其中：

默认是：

int literal

2.4 long 字面量

如果需要明确表示：

long

字面量，可以使用：

或者：

例如：

long population = 8_000_000_000L;

2.5 数字中的下划线

Java 允许在数值字面量的部分数字之间加入：

提高可读性。

例如：

long population = 8_000_000_000L;

与：

long population = 8000000000L;

表达相同数值。

对于很长的数字：

1_000_000

通常比：

更容易阅读。

2.6 负数是不是一个完整的整数字面量

教学中通常会直接把：

-88

称为“负整数字面量”。

这种说法方便初学。

但如果严格按照 Java 词法语法：

属于运算符。

而：

才是 Integer Literal。

也就是说：

-88

可以从语法结构上理解为：

一元负号 -
+
整数字面量 88

当前阶段只需要认识这个规范细节。

运算符将在后续章节系统学习。

2.7 浮点数字面量

例如：

3.14
99.5
0.5

普通浮点数字面量默认属于：

double

例如：

double price = 99.9;

没有问题。

2.8 float 字面量

如果希望一个浮点数字面量本身属于：

float

需要添加：

或者：

例如：

float score = 99.5F;

也可以：

float score = 99.5f;

通常建议统一风格。

例如：

3.14F

2.9 为什么 `float f = 3.14;` 会有问题

因为：

3.14

默认是：

double

而变量：

声明为：

float

这涉及从更宽的浮点类型到更窄类型的转换。

Java 不会在普通赋值中无条件自动完成这种可能损失信息的转换。

所以通常写：

float f = 3.14F;

类型转换将在：

01-08 · 类型转换与表达式类型提升

详细学习。

2.10 字符字面量

字符类型：

char

常见字面量使用：

单引号

例如：

'A'

'0'

'中'

变量：

char grade = 'A';

需要注意：

'A'

和：

"A"

完全不同。

2.11 字符与字符串的区别

字符：

'A'

使用：

单引号

类型是：

char

字符串：

"A"

使用：

双引号

类型是：

String

因此：

char c = 'A';

和：

String s = "A";

不是一回事。

2.12 一个 char 能不能写两个普通字符

例如：

char value = 'AB';

不能作为普通合法字符字面量。

char 字面量表达一个：

char value

不能在一对普通单引号中直接塞入多个普通字符。

如果需要：

AB

应该使用：

String value = "AB";

2.13 空字符和空字符串

字符串可以为空：

String text = "";

这是：

空字符串（Empty String）

其中包含：

0 个字符内容

但是：

char value = '';

不是合法的普通 char 字面量。

因为一对字符单引号中必须能够形成合法的字符字面量内容。

2.14 空字符串和空格字符串不同

下面两个字符串完全不同：

""

和：

" "

第一个：

空字符串

第二个：

包含一个空格字符的字符串

肉眼看起来可能很像，但程序中的数据不同。

2.15 `'0'`、`"0"` 和 `0`

这是必须彻底区分的一组数据。

'0'

是：

char

表示字符：

"0"

是：

String

表示包含字符 0 的字符串。

是：

int

整数字面量。

所以：

'0'
"0"
0

虽然显示时可能都能看到：

但类型完全不同。

2.16 字符串字面量

字符串使用：

双引号

例如：

"Hello Java"

"星雨笔录"

"123"

""

它们都是 String Literal。

例如：

String name = "LingXi";

这里：

LingXi

对应一个字符串字面量。

2.17 String 不是基本数据类型

虽然：

String

使用频率极高，而且写起来像：

int
double
boolean

一样自然，但：

String

不是 Java 的 8 种 Primitive Type 之一。

它属于：

引用类型（Reference Type）

具体的 String 对象、字符串常量池、不可变性等内容，会在后面的：

03-01 · String 与字符串常量池

专门展开。

当前只需要记住：

String ≠ primitive type

2.18 布尔字面量

Java 布尔类型：

boolean

只有两个逻辑值：

true
false

例如：

boolean isLogin = true;

boolean hasPermission = false;

不要写成：

"true"

因为：

"true"

是：

String

而：

true

才是：

boolean literal

2.19 null 字面量

Java 中还有一个特殊字面量：

null

它表示：

null reference。

例如：

String userName = null;

表示：

userName 当前没有引用一个 String 对象

需要注意：

null

具有一个特殊的：

null type

这个类型本身没有可以直接写出的类型名称。

它可以用于很多引用类型场景。

2.20 基本类型不能直接保存 null

例如：

int age = null;

不合法。

因为：

int

属于 Primitive Type。

而 null 对应的是引用体系中的特殊空引用值。

例如：

String name = null;

则属于引用类型场景。

2.21 什么是转义序列

有些字符很难直接写在普通字符串或字符字面量中。

例如想表示：

换行

可以写：

"\n"

这类形式称为：

转义序列（Escape Sequence）

2.22 常见转义序列

| 写法 | 含义 | | ---- | -------- | | \n | 换行 | | \t | 水平制表 | | \r | 回车 | | \b | 退格 | | \f | 换页 | | \\ | 反斜杠 | | \" | 双引号 | | \' | 单引号 |

例如：

System.out.println("Hello\nJava");

会在字符串内容中加入换行。

2.23 为什么 Windows 路径经常写双反斜杠

真实路径可能是：

C:\Java\jdk-21

如果直接写：

String path = "C:\Java\jdk-21";

反斜杠：

在字符串中可能被当作转义序列的开始。

所以常见写法：

String path = "C:\\Java\\jdk-21";

其中：

\\

表示字符串中的一个普通：

字符。

2.24 普通字符串不能直接跨源代码行

例如这种写法：

String text = "Hello
Java";

普通 String Literal 中不能直接出现这样的源码换行。

如果只是需要字符串内容换行，可以使用：

String text = "Hello\nJava";

Java 还提供：

Text Block

解决多行文本书写问题。

2.25 JDK 21 中的 Text Block

这是原始课程没有展开，但 JDK 21 已经正式支持的一个字面量能力。

例如：

String html = """
        <html>
            <body>
                Hello Java
            </body>
        </html>
        """;

这种形式称为：

文本块（Text Block）

它适合：

多行 JSON；
HTML；
SQL；
大段文本。

例如：

String json = """
        {
          "name": "LingXi",
          "age": 18
        }
        """;

不过当前阶段的学习主线仍然以：

"普通字符串"

为主。

Text Block 先建立认识即可。

2.26 什么是变量

变量（Variable）不是简单等于：

“一个可以变化的数字”。

Java Language Specification 更严格地描述：

Variable 是一个具有类型的存储位置。

例如：

int age = 18;

这里定义：

变量名：age

类型：int

当前值：18

可以把变量暂时类比成：

一个有类型限制的数据盒子。

但是要知道：

“盒子”只是教学类比，Variable 在规范层面是一个带类型的 storage location。

2.27 为什么需要变量

如果程序只有固定数据：

System.out.println(18);
System.out.println(18 + 1);
System.out.println(18 + 2);

数据难以统一管理。

使用变量：

int age = 18;

System.out.println(age);

age = age + 1;

System.out.println(age);

程序可以围绕一个具有明确语义的数据进行处理。

变量带来：

可维护性；
可复用性；
可读性；
数据动态变化能力。

2.28 变量的完整定义格式

基本格式：

数据类型 变量名 = 初始值;

例如：

int age = 18;

其中：

int

是数据类型。

age

是变量名称。

是初始值。

2.29 声明变量

可以先只声明：

int age;

这一步建立了变量：

age

并指定：

类型为 int

对于局部变量，这时并不意味着你已经可以随意读取它。

2.30 初始化变量

声明时第一次提供值：

int age = 18;

可以理解为：

初始化（Initialization）

也可以拆开理解：

int age;
age = 18;

其中第二行使局部变量获得可用值。

2.31 赋值

例如：

age = 20;

表示将：

赋给：

age

注意：

在 Java 中这里表示：

赋值

不是数学意义上的：

恒等

2.32 重新赋值

变量的一个重要特征是：

在规则允许的情况下，它保存的值可以变化。

例如：

int age = 18;

age = 19;

age = 20;

最后：

age

中保存的是新的值。

2.33 `age = age + 1` 为什么不是数学矛盾

数学里：

age = age + 1

似乎不可能成立。

但 Java 中：

是赋值运算。

可以按执行步骤理解：

age = age + 1;

先计算右侧：

age + 1

假设：

age 当前是 18

得到：

再把：

赋给左侧变量：

age

所以执行后：

age = 19

没有数学矛盾。

2.34 局部变量使用前必须初始化

例如：

public class VariableDemo {

    public static void main(String[] args) {

        int age;

        System.out.println(age);
    }
}

这里：

age

是局部变量。

Java 编译器会进行：

Definite Assignment

检查。

局部变量在读取之前必须能够确定已经被赋值。

因此：

局部变量不会因为你声明成 int 就自动获得一个可以随便读取的 0。

正确：

int age = 18;

System.out.println(age);

2.35 什么是变量作用域

变量只能在自己的有效范围内使用。

例如：

public class ScopeDemo {

    public static void main(String[] args) {

        int age = 18;

        {
            int score = 100;

            System.out.println(age);
            System.out.println(score);
        }

        System.out.println(age);
    }
}

变量：

score

属于内部代码块中的局部变量。

当离开对应作用域后，就不能继续像仍然存在于当前作用域一样直接使用。

因此学习变量不能只记：

数据类型 变量名 = 数据;

还要逐渐建立：

变量在哪里有效？

这个意识。

2.36 为什么变量必须有类型

Java 是：

静态类型语言（Statically Typed Language）

意味着：

每个变量和表达式都有编译期已知的类型。

例如：

int age = 18;

变量：

age

被限制为：

int

2.37 Java 数据类型分为哪两大类

Java 类型主要分为：

Primitive Type

和：

Reference Type

也就是：

基本数据类型
+
引用数据类型

2.38 Java 的 8 种基本数据类型

Java 共有：

8 种 Primitive Type

可以按照四类教学记忆：

整数
浮点
字符
布尔

完整如下：

| 分类 | 类型 | 语言层面的位宽 / 含义 | | ---- | --------- | ---------------------------- | | 整数 | byte | 8 位有符号整数 | | 整数 | short | 16 位有符号整数 | | 整数 | int | 32 位有符号整数 | | 整数 | long | 64 位有符号整数 | | 浮点 | float | IEEE 754 binary32 | | 浮点 | double | IEEE 754 binary64 | | 字符 | char | 16 位无符号 UTF-16 code unit | | 布尔 | boolean | true / false |

2.39 byte

byte

是 8 位有符号整数。

范围：

-128 ~ 127

例如：

byte age = 18;

但是：

byte value = 128;

超出了：

byte

的取值范围。

2.40 short

short

是 16 位有符号整数。

范围：

-32768 ~ 32767

例如：

short year = 2026;

2.41 int

int

是 Java 中最常用的整数类型。

使用 32 位有符号二进制整数表示。

范围：

-2147483648
~
2147483647

例如：

int studentCount = 2000;

普通整数计算中通常优先使用：

int

2.42 long

long

是 64 位有符号整数。

适合表示更大整数。

例如：

long worldPopulation = 8_000_000_000L;

需要注意普通整数字面量默认通常是：

int

因此超出 int 字面量范围的场景需要正确使用：

后缀。

2.43 float

float

对应：

IEEE 754 binary32

浮点类型。

例如：

float score = 98.5F;

2.44 double

double

对应：

IEEE 754 binary64

普通小数字面量默认通常是：

double

例如：

double price = 99.9;

因此 Java 中普通小数计算更常见的是：

double

而不是：

float

2.45 浮点数不是“任意精确小数”

例如：

double money = 0.1;

不要直接理解为：

Java 可以用二进制浮点数精确表示所有十进制小数。

float 和 double 基于 IEEE 754 二进制浮点格式。

有些十进制小数无法被有限二进制位精确表示。

所以以后涉及：

金额

等要求精确十进制计算的场景，会学习：

BigDecimal

当前只需要先建立：

float / double 是浮点近似表示，不适合直接想象成“无限精确小数”。

2.46 char

char

是 Java 的 16 位无符号整数类型之一，用于表示：

UTF-16 code unit

范围：

0 ~ 65535

例如：

char letter = 'A';

char digit = '0';

char chinese = '中';

字符编码和 Unicode 会在：

01-07 · 进制、数据存储与字符编码基础

进一步学习。

2.47 boolean

boolean

表示逻辑值。

只有：

true
false

例如：

boolean isLogin = true;

2.48 boolean 到底占几个字节

很多 Java 入门资料会直接写：

boolean = 1 byte

这种说法不适合作为 Java Language Specification 的语言规则背诵。

JLS 规定的是：

boolean 有 true 和 false 两个值

但没有像：

byte = 8 bit
short = 16 bit
int = 32 bit
long = 64 bit

这样规定一个统一的：

boolean 变量必须占 N 个字节

存储实现可能涉及：

JVM；
对象布局；
数组表示；
实现细节。

因此在 JavaSE 语言学习阶段应记：

boolean
→ true / false

而不是把：

1 byte

当成语言规范保证。

2.49 引用类型

除了 Primitive Type，Java 还有：

Reference Type

包括：

class type；
interface type；
array type。

当前已经见过的：

String name = "LingXi";

其中：

String

属于 class type。

后面还会学习：

数组
类与对象
接口
集合

这些都会大量涉及引用类型。

2.50 基本类型变量和引用类型变量的核心区别

初学阶段可以先这样建立模型。

基本类型变量：

int age = 18;

变量直接保存符合该 primitive type 的值。

引用类型变量：

String name = "LingXi";

变量保存的是：

reference value。

它可能引用某个对象，也可能保存：

null

不要过早把 reference 简单等同于：

“一个裸内存地址”

Java 语言层面描述的是：

reference。

对象和引用的完整关系会在面向对象阶段深入学习。

三、使用方法

3.1 定义常见基本类型变量

public class DataTypeDemo {

    public static void main(String[] args) {

        byte smallNumber = 100;

        short year = 2026;

        int age = 18;

        long population = 8_000_000_000L;

        float score = 98.5F;

        double price = 99.9;

        char grade = 'A';

        boolean passed = true;

        System.out.println(age);
        System.out.println(price);
        System.out.println(grade);
        System.out.println(passed);
    }
}

3.2 定义引用类型变量

例如：

String userName = "LingXi";

这里：

String

不是 Primitive Type。

它属于：

Reference Type

3.3 变量重新赋值

int age = 18;

System.out.println(age);

age = 19;

System.out.println(age);

变量：

age

的类型仍然是：

int

只是它当前保存的值发生变化。

3.4 微信钱包示例

public class WalletDemo {

    public static void main(String[] args) {

        double money = 9.9;

        System.out.println(money);

        money = money - 5;

        System.out.println(money);

        money = money + 6;

        System.out.println(money);
    }
}

这个案例展示：

变量可以记录程序运行过程中不断变化的数据。

这里暂时用于语法训练。

真实金额计算不应简单依赖二进制浮点数完成高精度金融计算，后续会学习：

BigDecimal

3.5 学生信息示例

public class StudentInfoDemo {

    public static void main(String[] args) {

        String studentId = "A20330303";

        String studentName = "LingXi";

        int age = 22;

        double height = 173.5;

        String city = "Taiyuan";

        System.out.println(studentId);
        System.out.println(studentName);
        System.out.println(age);
        System.out.println(height);
        System.out.println(city);
    }
}

这个例子体现：

不同业务数据需要选择适合的数据类型。

例如：

学号

即使里面有数字，也不一定适合：

int

因为它可能：

包含字母；
包含前导零；
不参与数学计算。

所以数据类型选择不能只看：

“长得像不像数字”。

还要看：

“这个数据在业务中代表什么”。

四、原理与进阶

4.1 Java 为什么是静态类型语言

例如：

int age = 18;

编译器在程序运行之前就知道：

age 的类型是 int

所以当写：

age = "hello";

编译器就可以在运行前发现明显类型不兼容。

这就是静态类型带来的重要价值之一：

尽量提前发现错误。

4.2 类型不仅限制“能存什么”

类型还会影响：

可以执行什么操作；
表达式结果是什么；
方法能够接收什么参数；
方法返回什么；
哪些赋值合法。

例如：

int

和：

String

不仅存储内容不同，它们允许的操作体系也完全不同。

所以数据类型是 Java 整个语言系统的核心之一。

4.3 变量和对象不是一回事

例如：

String name = "LingXi";

不要简单认为：

变量 name
=
String 对象本身

更准确的初步模型是：

name
│
│ reference
▼
String object

变量和对象是不同概念。

这将在：

02 · Java面向对象

进一步展开。

4.4 为什么局部变量没有默认值

Java 会要求局部变量在使用之前满足：

Definitely Assigned

例如：

int age;

System.out.println(age);

编译器不能确认：

age

已经有合法值。

于是直接阻止。

这种设计能够避免大量：

读取未初始化局部数据

的问题。

4.5 boolean 与机器存储布局不要混为一谈

Java 语言规范定义：

boolean
→ true / false

JVM 最终如何把某个 boolean：

放入栈；
放入对象；
放入数组；
对齐存储；

属于更底层的实现问题。

因此学习语言时要注意：

语言语义 ≠ JVM 内存布局 ≠ CPU 实际存储细节。

五、实践应用

5.1 年龄为什么通常用 int

例如：

int age = 22;

年龄通常：

是整数；
范围很小；
会参与比较和计算。

所以：

int

足够自然。

没必要为了“省内存”强行写：

byte age = 22;

真实工程中类型选择还需要考虑：

API 一致性；
数据库映射；
运算规则；
可维护性。

5.2 学号为什么通常使用 String

例如：

00123456

如果用：

int studentId = 00123456;

不仅语义不合适，还会面临：

前导零；
字母；
编码规则；
不参与数学计算；

等问题。

更自然：

String studentId = "00123456";

所以：

数据类型应该根据业务语义选择。

5.3 金额为什么后面要学 BigDecimal

如果：

double price = 0.1;

它属于二进制浮点数。

某些十进制金额运算可能产生肉眼不期望的结果。

因此企业开发中精确金额通常会考虑：

BigDecimal

后续：

03-06 · BigDecimal 与精确小数运算

会专门学习。

当前不要把：

double

理解为所有小数业务的万能类型。

5.4 boolean 应该用有意义的变量名

例如：

boolean flag = true;

虽然合法，但：

flag

没有表达业务语义。

更好的例子：

boolean isLogin = true;

boolean hasPermission = false;

boolean orderPaid = true;

变量名应该让开发者不用追踪十几行代码就能理解：

true 到底表示什么。

六、常见问题

6.1 `10` 默认是什么类型？

普通没有 L/l 后缀的整数字面量默认通常是：

int

使用：

可以表示：

long

字面量。

6.2 `3.14` 默认是什么类型？

默认是：

double

如果需要：

float

字面量，通常写：

3.14F

6.3 `'A'` 和 `"A"` 有什么区别？

'A'

是：

char

"A"

是：

String

两者类型完全不同。

6.4 `'0'` 和 `0` 是不是一样？

不是。

'0'

是字符。

是整数。

显示效果相似不代表数据类型相同。

6.5 `true` 和 `"true"` 一样吗？

不一样。

true

是：

boolean literal

"true"

是：

String literal

6.6 String 为什么不是 8 种基本数据类型

因为 Java 规范中的 Primitive Type 只有：

byte
short
int
long
float
double
char
boolean

而：

String

属于：

class type

也就是引用类型。

6.7 为什么 byte 不能保存 128

因为：

byte

范围：

-128 ~ 127

而：

超过其合法范围。

6.8 boolean 是不是一定占 1 个字节

不要把这句话当作 Java Language Specification 的规则。

Java 语言规范保证：

boolean

具有：

true
false

两个值。

但没有简单规定：

任意 boolean 变量的存储大小一定等于 1 byte。

6.9 局部变量为什么不能不赋值就使用

因为 Java 编译器会进行：

Definite Assignment

检查。

局部变量使用前必须能够确认已经拥有合法值。

6.10 `String name = null` 和 `String name = ""` 一样吗

不一样。

String name = null;

表示：

没有引用一个 String 对象

而：

String name = "";

表示：

引用一个内容为空的 String

这两者具有完全不同的语义。

6.11 变量名相同就一定是同一个变量吗

还需要看：

作用域。

不同作用域中的声明可能对应不同变量。

变量不仅有：

名称；
类型；
值；

还具有自己的：

声明位置；
作用域。

后续随着代码结构复杂，这一点会越来越重要。

七、练习与验收

7.1 知识问答

什么是 Literal？
Java 中常见字面量有哪些类型？
普通整数字面量默认是什么类型？
L 后缀解决什么问题？
普通小数字面量默认是什么类型？
float 字面量通常如何书写？
字符与字符串分别使用什么引号？
"" 和 " " 有什么区别？
'0'、"0"、0 分别属于什么类型？
true 与 "true" 有什么区别？
null 表示什么？
哪类变量可以保存 null？
\n 与 \t 分别表示什么？
为什么 Windows 路径字符串经常需要 \\？
什么是 Variable？
声明、初始化、赋值、重新赋值分别是什么意思？
为什么程序需要变量？
为什么局部变量使用前必须初始化？
Java 类型主要分成哪两大类？
Java 8 种 Primitive Type 分别是什么？
String 为什么不是 Primitive Type？
为什么不应该把 boolean = 1 byte 当作 Java 语言规范规则？

7.2 代码阅读

代码一

不要运行：

public class LiteralRead01 {

    public static void main(String[] args) {

        System.out.println('A');
        System.out.println("A");

        System.out.println('0');
        System.out.println(0);

        System.out.println(true);
        System.out.println("true");

        System.out.println("hello\nworld");
    }
}

要求：

预测每一行显示结果。
写出每个字面量的类型。
解释显示内容相似为什么不代表类型相同。

代码二

public class VariableRead01 {

    public static void main(String[] args) {

        int age = 18;

        age = 19;

        age = age + 1;

        int backup = age;

        age = age + 5;

        System.out.println(age);
        System.out.println(backup);
    }
}

不要运行。

要求：

逐行跟踪 age 的变化。
预测最终两个输出。
判断 backup 保存的是什么。
解释 age = age + 1 的执行顺序。

7.3 手写代码

任务一：字面量

从零创建：

LiteralDemo

要求输出：

整数字面量；
long 字面量；
double 字面量；
float 字面量；
字符；
字符串；
boolean；
至少两个转义序列。

不能复制现成代码。

任务二：微信零钱

初始余额：

9.9

支出：

随后收入：

要求：

使用一个表示余额的变量；
每一步都输出余额；
解释为什么这个案例体现了变量的“可重新赋值”。

任务三：学生信息

保存：

学号
姓名
年龄
身高
城市

要求：

为每条数据选择合适类型。
使用有意义的变量名。
输出全部信息。
说明为什么学号不一定适合使用整数。

7.4 Debug

不要直接修改代码，先逐行分析：

public class TypeDebug01 {

    public static void main(String[] args) {

        byte b = 128;

        float f = 3.14;

        long total = 99999999999;

        char c = "A";
    }
}

要求：

判断每一行是否存在编译问题。
如果有问题，说明属于：
- 数据范围；
- 字面量默认类型；
- 字符与字符串；
- 其他类型规则；
最后再逐行修复。
修复时不能改变变量原本想表达的数据含义。

7.5 综合训练

设计一个控制台“商品信息卡”。

需要保存：

商品编号
商品名称
单价
库存数量
是否上架
商品等级

要求：

自己选择每个变量的数据类型。
为每个变量设计符合规范的名称。
至少包含：
- 一个 String；
- 一个整数基本类型；
- 一个浮点基本类型；
- 一个 boolean；
- 一个 char。
输出商品信息。
修改库存数量并再次输出。
修改上架状态并再次输出。
最后解释：
- 哪些是 Literal；
- 哪些是 Variable；
- 哪些是 Primitive Type；
- 哪些是 Reference Type。

7.6 本章验收

不查看教程完成：

[ ] 能正确书写整数、浮点、字符、字符串、boolean、null。
[ ] 能解释 int / long 字面量后缀规则。
[ ] 能解释 float / double 字面量默认规则。
[ ] 能区分 '0'、"0" 与 0。
[ ] 能正确使用至少 5 个常见转义序列。
[ ] 能解释普通字符串与 Text Block 的基本区别。
[ ] 能从零定义、初始化并修改变量。
[ ] 能解释 age = age + 1。
[ ] 能解释局部变量为什么必须先赋值再读取。
[ ] 能完整列出 Java 8 种 Primitive Type。
[ ] 能说出 byte、short、int、long 的位宽与范围。
[ ] 能解释 char 是 16 位 UTF-16 code unit。
[ ] 知道 boolean 的语言规范没有定义统一“1 字节”规则。
[ ] 能解释 Primitive Type 与 Reference Type 的基础区别。
[ ] 能根据简单业务语义选择合理的数据类型。

一、学习目标

二、核心知识

2.1 什么是字面量

2.2 常见字面量总览

2.3 整数字面量

2.4 long 字面量

2.5 数字中的下划线

2.6 负数是不是一个完整的整数字面量

2.7 浮点数字面量

2.8 float 字面量

2.9 为什么 float f = 3.14; 会有问题

2.10 字符字面量

2.11 字符与字符串的区别

2.12 一个 char 能不能写两个普通字符

2.13 空字符和空字符串

2.14 空字符串和空格字符串不同

2.15 '0'、"0" 和 0

2.16 字符串字面量

2.17 String 不是基本数据类型

2.18 布尔字面量

2.19 null 字面量

2.20 基本类型不能直接保存 null

2.21 什么是转义序列

2.22 常见转义序列

2.23 为什么 Windows 路径经常写双反斜杠

2.24 普通字符串不能直接跨源代码行

2.25 JDK 21 中的 Text Block

2.26 什么是变量

2.27 为什么需要变量

2.28 变量的完整定义格式

2.29 声明变量

2.30 初始化变量

2.31 赋值

2.32 重新赋值

2.33 age = age + 1 为什么不是数学矛盾

2.34 局部变量使用前必须初始化

2.35 什么是变量作用域

2.36 为什么变量必须有类型

2.37 Java 数据类型分为哪两大类

2.38 Java 的 8 种基本数据类型

2.39 byte

2.40 short

2.41 int

2.42 long

2.43 float

2.44 double

2.45 浮点数不是“任意精确小数”

2.46 char

2.47 boolean

2.48 boolean 到底占几个字节

2.49 引用类型

2.50 基本类型变量和引用类型变量的核心区别

三、使用方法

3.1 定义常见基本类型变量

3.2 定义引用类型变量

3.3 变量重新赋值

3.4 微信钱包示例

3.5 学生信息示例

四、原理与进阶

4.1 Java 为什么是静态类型语言

4.2 类型不仅限制“能存什么”

4.3 变量和对象不是一回事

4.4 为什么局部变量没有默认值

4.5 boolean 与机器存储布局不要混为一谈

五、实践应用

5.1 年龄为什么通常用 int

5.2 学号为什么通常使用 String

5.3 金额为什么后面要学 BigDecimal

5.4 boolean 应该用有意义的变量名

六、常见问题

6.1 10 默认是什么类型？

6.2 3.14 默认是什么类型？

6.3 'A' 和 "A" 有什么区别？

6.4 '0' 和 0 是不是一样？

6.5 true 和 "true" 一样吗？

6.6 String 为什么不是 8 种基本数据类型

6.7 为什么 byte 不能保存 128

6.8 boolean 是不是一定占 1 个字节

6.9 局部变量为什么不能不赋值就使用

6.10 String name = null 和 String name = "" 一样吗

2.9 为什么 `float f = 3.14;` 会有问题

2.15 `'0'`、`"0"` 和 `0`

2.33 `age = age + 1` 为什么不是数学矛盾

6.1 `10` 默认是什么类型？

6.2 `3.14` 默认是什么类型？

6.3 `'A'` 和 `"A"` 有什么区别？

6.4 `'0'` 和 `0` 是不是一样？

6.5 `true` 和 `"true"` 一样吗？

6.10 `String name = null` 和 `String name = ""` 一样吗