对于来自 JavaScript 的开发者，学习 Java 最大的认知变化就是：
Java 是强类型（Strong Typed）+ 静态类型（Static Typed）语言，而 JavaScript 是弱类型 + 动态类型语言。
在 JS 中，变量的类型由运行时决定；在 Java 中，变量类型必须在编译时就确定，否则无法通过编译。
本文将从 JS 开发者的视角出发，把 Java 的 8 种基本类型 用“前端友好的方式”讲清楚，并对比 JS 的相同概念，帮助建立强类型思维。
1. Java 的 8 种基本类型总览
Java 的基本类型（primitive types）只有 8 种，是最底层的数据类型，不是对象，也不会有方法。
| 分类 | Java 类型 | 位数 | 典型范围 | 对应的 JS 概念 |
|---|---|---|---|---|
| 整数类型 | byte | 8 bit | -128 ~ 127 | Number（整数） |
short | 16 bit | -32768 ~ 32767 | Number（整数） | |
int | 32 bit | -21亿 ~ 21亿 | Number（整数） | |
long | 64 bit | 非常大 | BigInt（最接近，但不完全一致） | |
| 浮点类型 | float | 32 bit | 约 7 位有效数字 | Number（浮点） |
double | 64 bit | 约 15 位有效数字 | Number（浮点） | |
| 字符类型 | char | 16 bit | 单个 UTF-16 字符 | JS 没有 char，字符串代替 |
| 布尔类型 | boolean | 1 bit（逻辑） | true/false | boolean |
重点：Java 的基本类型都是值类型（value type）且不是对象，不具备方法。
JS 则是一切皆对象，Number/String/Boolean 都能调用方法。
2. Java 的数值类型详解（与 JS Number 的根本差异）
在 JavaScript 中：
- 所有数字（整数、小数、NaN、Infinity）都是
Number（IEEE 754 双精度浮点） - 并且只有一个数值类型
而 Java 将数值拆分为多个类型：
严格、固定大小、不能随意溢出、不能隐式跨类型转换。
2.1 Java 整数类型：byte / short / int / long
2.1.1 为什么 Java 要分这么细？
为了：
- 控制内存大小
- 提高性能
- 让类型更加明确，避免 JS 那种“数字太大不安全”的问题（如 2^53 的限制）
2.1.2 四种整数类型对比
| 类型 | 例子 | 内存 | 范围 |
|---|---|---|---|
byte | byte a = 10; | 1 字节 | -128 ~ 127 |
short | short s = 1000; | 2 字节 | -32768 ~ 32767 |
int | int x = 100000; | 4 字节 | -21亿 ~ 21亿 |
long | long l = 10000000000L; | 8 字节 | 很大 |
注意事项（前端非常容易踩坑）
① long 字面量必须加后缀 L
long count = 10000000000L;
不加 L 会当成 int 处理，从而编译报错（因为值超范围）。
② Java 整数不会自动从小类型提升到大类型？
会提升，但不会自动下降（narrowing）。
int a = 10;
long b = a; // OK，自动提升（int → long）
long c = 10L;
int d = c; // ❌ 错误，必须强制转换（可能丢失数据）
2.2 Java 浮点类型：float / double
JavaScript 中只有一个浮点类型（Number），默认是双精度。但 Java 有两个：
| 类型 | 内存 | 说明 |
|---|---|---|
float | 4 字节 | 单精度，精度较低 |
double | 8 字节 | 双精度，Java 默认浮点字面量类型 |
字面量规则（与 JS 完全不同）
float a = 3.14f; // 必须加 f
double b = 3.14; // 默认 double
JS 不存在 float/double 的区别，永远是 Number。
精度问题：Java 和 JS 一样，浮点运算仍会出现误差
JS：
0.1 + 0.2 // 0.30000000000000004
Java：
0.1 + 0.2 // 0.30000000000000004
3. boolean：Java 没有 JS 的 truthy/falsy
JS 中：
if ("hello") console.log("true"); // true
if (1) console.log("true"); // true
if (0) console.log("false"); // not printed
Java 中只能写：
boolean ok = true;
if (ok) {
System.out.println("true");
}
以下写法一律报错：
if (1) {} // ❌
if ("hello") {} // ❌
if (null) {} // ❌
Java 的判断条件必须严格是 boolean 类型。
4. char 类型：JS 没有这个概念
JS 不存在 char，'a' 和 "a" 都是 string。
Java 有真正的字符类型：
char c = 'A';
char emoji = '😊'; // 支持 UTF-16 范围内的字符
特点：
- 必须使用单引号
'a' - 只能存一个字符
- 底层是 UTF-16 code unit（与 JS 类似）
注：超出 UTF-16 的字符需要使用代理对（surrogate pairs），高级内容可以再展开。
5. String 不是基本类型，但对前端很重要
Java 的 String 是对象（引用类型），不是 primitive。
JS：
let s = "hello";
Java：
String s = "hello";
虽然看起来一样，但 Java 字符串：
- 是不可变对象（immutable object）
- 在编译与运行时都会被字符串常量池优化
6. Java 的类型转换规则（与 JS 完全不同）
JS 的隐式转换非常激进：
"1" + 2 // "12"
"1" * 2 // 2
Java 则非常严格：
6.1 不同基本类型之间不会“自动混淆”
int a = 10;
long b = 20L;
int c = a + b; // ❌ 不允许，结果是 long
int c = (int)(a + b); // ✔
6.2 字符和数字可以互转（因为 char 是 UTF-16 码位）
char c = 'A';
int code = c; // 65
char c = (char) 65; // 'A'
7. 自动装箱 / 拆箱（Autoboxing / Unboxing）
前端经常会问：
Java 不是说基本类型没有方法吗？那为啥可以写像
Integer这样的东西？
Java 的基本类型都有对应的包装类（Wrapper Classes）
| primitive | wrapper（对象） |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
示例：
int a = 10;
Integer b = a; // 自动装箱（int → Integer）
int c = b; // 自动拆箱（Integer → int）
类似 JS 的自动包装（如 "abc".length），但 Java 的规则更严格，有时会触发空指针：
Integer x = null;
int y = x; // ❌ 空指针异常
Java 是强类型语言，所有转换必须安全或显式。
8. Java 的变量默认值（与 JS 完全不同）
JS：
let x;
console.log(x); // undefined
Java（类字段有默认值，局部变量必须初始化，否则编译错误）
| 类型 | 默认值 |
|---|---|
| 整数（byte/short/int/long） | 0 |
| 浮点（float/double） | 0.0 |
| char | '\u0000'（空字符） |
| boolean | false |
| 引用类型（String 等） | null |
示例：
class A {
int x; // 默认 0
boolean ok; // 默认 false
}
但局部变量：
int a;
System.out.println(a); // ❌ 编译错误：未初始化
9. 基本类型在内存中的位置（与 JS 完全不一样）
Java：
- 基本类型（primitive）存储在 栈（stack） 或 JVM 局部变量区域
- 对象（String、Integer 等）存储在 堆（heap）
JS：
- 没有显式栈/堆的区分概念（由引擎内部管理）
- 所有“对象”都在堆，原始类型存储优化由引擎隐藏
10. Java 基本类型总结（给前端的快速记忆表）
| Java | 用途 | 注意事项 | JS 对比 |
|---|---|---|---|
| byte | 小整数 | 不常用 | Number |
| short | 中等整数 | 不常用 | Number |
| int | 默认整数类型 | 最常用 | Number |
| long | 大整数 | 必须加 L | BigInt |
| float | 单精度 | 必须加 f | Number |
| double | 默认浮点 | 最常用浮点 | Number |
| char | 单字符 | 用单引号 | JS 无 char |
| boolean | true/false | 必须是 boolean | 有 truthy/falsy |
