深入 Java 腹地（二）：变量、数据类型与类型转换的奥秘-CSDN博客

本文链接：https://blog.csdn.net/dongxiaod1/article/details/147906741

深入 Java 腹地（二）：变量、数据类型与类型转换的奥秘

上次，我们一起了解了 Java 的基础环境和第一个 “Hello World” 程序。今天，我们将深入 Java 的腹地，探索编程中最基本也是最重要的概念之一：变量。它们就像你在程序中用来存放各种信息的“容器”。

变量：程序的“记忆细胞”

想象一下，你的程序需要记住一些数字、文字或者状态。这时候，就需要用到变量。你可以把变量理解成一个贴着标签的“盒子”，你可以把数据放进去，随时取出使用，甚至替换里面的数据。

在 Java 中，使用变量需要经历几个步骤：

声明 (Declaration): 就像你决定要使用一个“盒子”，并给它贴上一个标签（变量名），同时告诉 Java 这个盒子是用来装什么类型的东西的（数据类型）。

变量的声明：需要包含两部分数据类型和变量名

在这里插入图片描述

int age; // 声明一个用来装整数的变量，名字叫做 age
String name; // 声明一个用来装文本的变量，名字叫做 name

注意，同一个名字的变量不能重复声明。

int age;
// int age; // 错误！age 已经被声明过了

初始化 (Initialization): 声明了盒子后，你需要往里面放入第一个东西。这就是初始化，给变量赋一个初始值。
```
int age = 25; // 声明并初始化一个 age 变量，赋值为 25
String name;
name = "张三"; // 先声明，后初始化
```
你也可以随时修改变量里面存放的数据：
```
age = 26; // 把 age 变量的值修改为 26
```

使用 (Usage): 一旦变量被声明和初始化后，你就可以在程序中使用它里面存放的数据了。

int score = 95;
int finalScore = score + 5; // 取出 score 的值 95，加 5 后赋值给 finalScore
System.out.println(finalScore); // 输出 finalScore 的值 100
System.out.println("score"); // 注意区分，这里输出的是文本 "score"，而不是变量 score 的值

重要规则：变量在使用之前，必须先声明并初始化！

// System.out.println(grade); // 错误！grade 未声明
int grade;
// System.out.println(grade); // 错误！grade 未初始化

命名 (Naming): 给你的“盒子”贴标签（变量名）的时候，需要遵循一些规则：
- 只能包含字母、数字、下划线 _ 和美元符号 $。
- 不能以数字开头。
- 严格区分大小写 (age 和 Age 是两个不同的变量)。
- 不能使用 Java 的关键字（比如 class, public, int 等）。
- 允许使用中文命名，但强烈不建议！请务必使用英文，并且做到“见名知意”。
- 建议使用“小驼峰命名法”：第一个单词首字母小写，后面每个单词的首字母大写（例如：myScore, studentName）。这是一种通用的编程习惯，能让你的代码更易读。

总结

变量是存储数据的“盒子”
变量具有复用性：一次定义，多次使用
变量具有可变性：随时随地，依需可变

八仙过海：Java 的基本数据类型

Java 为我们提供了八种“基本数据类型”，它们是 Java 世界中“最基础”的数据类型，就像建造房屋需要砖头、水泥一样。它们用来存放不同种类的数据：

在这里插入图片描述

整型 (Integer Types): 用来存放整数。根据存储范围的大小，有四种：
- byte: 1个字节，范围最小。
- short: 2个字节。
- int: 4个字节，最常用，范围大约正负21亿。整数直接量（你直接在代码里写的整数，比如 25）默认就是 int 类型，但要注意不要超出 int 的范围，否则会编译错误。
```
int num = 25; // 25 默认为 int 类型
// int bigNum = 10000000000; // 错误！100亿超出了 int 的范围
```
  需要注意的是，两个整数相除，结果仍然是整数，小数部分会无条件舍弃，不会四舍五入。
```
System.out.println(5 / 2); // 输出 2
System.out.println(5 / 2.0); // 输出 2.5 (因为 2.0 是小数，结果就是小数)
```
  如果运算结果超出了 int 的范围，会发生溢出。溢出不是错误，但结果会变得不正确，需要避免。
- long: 8个字节，范围非常大（正负900万万亿多）。如果你的整数值很大，超出了 int 的范围，就需要使用 long。如果想表示长整型直接量，需要在数字后面加上 L 或 l。
```
long hugeNum = 10000000000L; // 加上 L 表示这是一个 long 类型的直接量
```
  当进行可能溢出的运算时，建议在第一个参与运算的数字后面加上 L，确保整个运算以 long 类型进行。
```
long result = 1000000000L * 3 * 10; // 确保从一开始就进行 long 类型的运算
```
浮点型 (Floating-Point Types): 用来存放带小数的数字。
- float: 4个字节。
- double: 8个字节，范围更大，精度更高。小数直接量（你直接在代码里写的小数，比如 3.14）默认就是 double 类型。如果想表示 float 类型的直接量，需要在数字后面加上 F 或 f。
```
double pi = 3.14; // 3.14 默认为 double 类型
float radius = 1.5F; // 加上 F 表示这是一个 float 类型的直接量
```
  重要的限制：浮点型不能表示精确的数据，运算时可能会发生舍入误差。 在需要精确计算的场合（比如金融计算），不能直接使用 float 或 double，需要使用特定的类（如 BigDecimal）。
```
double num1 = 3.0;
double num2 = 2.9;
System.out.println(num1 - num2); // 可能会输出 0.10000000000000009
```
布尔型 (Boolean Type): 用来存放表示“真”或“假”的值。
- boolean: 1个字节。只能存储 true 或 false 这两个布尔直接量。
```
boolean isAdult = true;
boolean hasPermission = false;
// boolean isValid = 1; // 错误！boolean 只能是 true 或 false
```
字符型 (Character Type): 用来存放单个字符。
- char: 2个字节。
  - 采用 Unicode 编码格式，这是一种全球通用的字符编码，几乎包含了世界上所有的字符。每个字符都对应一个唯一的数字编码（0到65535之间）。
  - 字符型直接量必须放在单引号 ' ' 中，并且有且仅有一个字符。
```
char gender = '女';
char initial = 'A';
char digit = '5';
char space = ' '; // 空格也是一个字符
// char empty = ''; // 错误！必须有字符
// char twoChars = 'ab'; // 错误！只能有一个字符
```
  - 字符的本质是它对应的 Unicode 编码。你可以把一个整数赋值给 char 类型的变量，只要这个整数在 0 到 65535 之间，它会表示对应编码的字符。同样，你也可以把一个 char 类型的变量赋值给一个整数类型，它会得到这个字符的编码。
```
char letter = 65; // 65 是 'A' 的 Unicode 编码
System.out.println(letter); // 输出 A
int code = 'a'; // 'a' 的 Unicode 编码是 97
System.out.println(code); // 输出 97
```
  - 有些特殊符号需要通过转义字符 \ 来表示，比如 \n 表示换行，\t 表示制表符，\\ 表示反斜杠本身，\' 表示单引号，\" 表示双引号。
```
char backslash = '\\'; // 表示反斜杠 \
System.out.println(backslash);
```

类型转换：让不同类型的盒子互相“装”数据

在 Java 中，不同类型的数据之间有时候需要互相转换。想象你有两个不同大小的盒子，要把一个盒子里的东西放到另一个盒子里。

Java 中有两种类型转换方式：

自动/隐式类型转换 (Automatic/Implicit Conversion): 当你把一个小类型的数据赋值给一个大类型的变量时，Java 会自动帮你完成转换，就像把一个小盒子里的东西放到一个更大的盒子里，完全没有问题。
基本数据类型从小到大的顺序是：
byte -> short -> int -> long -> float -> double
char -> int
```
int numInt = 100;
long numLong = numInt; // int 自动转换为 long
double numDouble = numInt; // int 自动转换为 double
char ch = 'A';
int numFromChar = ch; // char 自动转换为 int (得到 A 的编码 65)
```
需要注意的是，char 虽然只有 2 个字节，但它可以自动转换为 int、long、float、double。
强制类型转换 (Forced/Explicit Conversion): 当你把一个大类型的数据赋值给一个小类型的变量时，Java 不会自动转换，因为这可能会导致数据丢失。你需要明确告诉 Java 你要进行转换，使用语法 (要转换成为的数据类型)变量。这就像把一个大盒子里的东西硬塞进一个小盒子里，可能会丢失一部分东西。
```
long numLong = 1000L;
int numInt = (int)numLong; // 强制将 long 转换为 int
double numDouble = 25.987;
int numIntFromDouble = (int)numDouble; // 强制将 double 转换为 int
System.out.println(numIntFromDouble); // 输出 25，小数部分被舍弃，丢失精度
```
重要警告：强制类型转换有可能会发生溢出（当大类型的值超出小类型的范围时）或丢失精度（当小数转换为整数时）。 使用强制类型转换时务必小心！

两点重要的类型转换规则：

整数直接量可以直接赋值给 byte, short, char 类型，但前提是这个直接量的值在目标类型的范围内。

byte b1 = 10; // 10 在 byte 的范围内，可以直接赋值
// byte b2 = 200; // 错误！200 超出了 byte 的范围
char c1 = 65; // 65 在 char 的范围内，可以直接赋值 (表示 'A')

当 byte, short, char 类型的数据参与运算时，它们会首先自动转换为 int 类型再进行运算。
```
byte b1 = 5;
byte b2 = 6;
// byte b3 = b1 + b2; // 错误！b1 + b2 的结果是 int 类型
byte b3 = (byte)(b1 + b2); // 需要强制转换回 byte
```
这也是为什么 System.out.println(2 + '2'); 的结果是 52，因为 '2' 的 Unicode 编码是 50，运算时 '2' 被转换为 int 类型的 50，所以结果是 2 + 50 = 52。