Java 基础语法

// 包声明：表示当前类属于 com.example.app 这个包
// 对应的文件系统路径为 com/example/app/
package com.example.app;

项目根目录/
└── src/
    └── com/
        └── example/
            └── app/
                └── HelloWorld.java    ← package com.example.app;

package com.example.app;
 
// 导入单个类：只引入 ArrayList 这一个类
import java.util.ArrayList;
 
// 通配符导入：引入 java.util 包下的所有类
// 注意：这不会导入子包（sub-package）中的类
import java.util.*;
 
// 静态导入：可以直接使用 Math 类的静态方法，无需写 Math.sqrt()
import static java.lang.Math.sqrt;
import static java.lang.Math.PI;

package com.example.app;
 
// 类定义：访问修饰符 + class 关键字 + 类名
// public 表示这个类对所有其他类可见
public class HelloWorld {
 
    // 成员变量（实例字段）
    private String message;  // private 表示只有本类内部可以访问
 
    // 构造方法：与类同名，没有返回值类型
    public HelloWorld(String message) {
        this.message = message;  // this 指向当前对象实例
    }
 
    // 成员方法（实例方法）
    public void printMessage() {
        System.out.println(message);  // 打印成员变量的值
    }
}

// 文件名：Demo.java
 
public class Demo {          // ✅ public 类，必须与文件名一致
    // ...
}
 
class Helper {               // ✅ 包级私有类，同一个文件中的非 public 类
    // ...
}
 
// 编译后生成：
// Demo.class
// Helper.class

public class WellOrganizedClass {
 
    // ① 静态常量（static final）
    public static final int MAX_SIZE = 100;
 
    // ② 静态变量（static）
    private static int instanceCount = 0;
 
    // ③ 实例变量（成员字段）
    private String name;
    private int age;
 
    // ④ 构造方法
    public WellOrganizedClass(String name, int age) {
        this.name = name;
        this.age = age;
        instanceCount++;  // 每创建一个实例，计数器加 1
    }
 
    // ⑤ 公有方法（public methods）
    public String getName() {
        return name;
    }
 
    // ⑥ 私有方法（private methods）
    private void validate() {
        // 内部校验逻辑
    }
 
    // ⑦ 静态方法
    public static int getInstanceCount() {
        return instanceCount;
    }
}

public class Application {
 
    // main 方法：Java 程序的唯一入口
    // public       → JVM 需要从外部调用它，所以必须是 public
    // static       → JVM 调用时不需要创建对象实例，所以必须是 static
    // void         → 不需要向 JVM 返回值
    // main         → 方法名固定，不能改
    // String[] args → 命令行参数，以字符串数组形式传入
    public static void main(String[] args) {
        System.out.println("Hello, Java!");  // 向标准输出打印一行文字
    }
}

public class FileTool {
 
    public static void main(String[] args) {
        // 检查用户是否传入了参数
        if (args.length == 0) {
            // 没有参数时，打印使用说明
            System.out.println("Usage: java FileTool <filename>");
            return;  // 提前退出
        }
 
        // args[0] 就是用户传入的第一个参数
        String filename = args[0];
        System.out.println("Processing file: " + filename);
    }
}

# 编译：javac 将 .java 源文件编译为 .class 字节码
javac FileTool.java
 
# 运行：java 命令启动 JVM，加载 FileTool 类，调用其 main 方法
# "data.txt" 会作为 args[0] 传入
java FileTool data.txt

Error: Main method not found in class com.example.app.HelloWorld

// ① 包声明：当前类属于 com.example.demo 包
package com.example.demo;
 
// ② 导入语句：引入 Arrays 工具类，后续章节会详细讲解
import java.util.Arrays;
 
// ③ 类定义：public 类，文件名必须是 Greeter.java
public class Greeter {
 
    // 静态常量：默认的问候语
    private static final String DEFAULT_GREETING = "Hello";
 
    // 实例变量：问候对象的名字
    private String name;
 
    // 构造方法：接收一个名字参数
    public Greeter(String name) {
        this.name = name;  // 将参数赋值给实例变量
    }
 
    // 实例方法：生成问候语
    public String greet() {
        // 使用静态常量和实例变量拼接字符串
        return DEFAULT_GREETING + ", " + name + "!";
    }
 
    // ④ main 方法：程序入口
    public static void main(String[] args) {
        // 打印命令行参数（如果有的话）
        System.out.println("Command line args: " + Arrays.toString(args));
 
        // 根据是否传入参数，决定问候谁
        String targetName;
        if (args.length > 0) {
            targetName = args[0];       // 使用第一个命令行参数
        } else {
            targetName = "World";       // 默认值
        }
 
        // 创建 Greeter 对象并调用 greet() 方法
        Greeter greeter = new Greeter(targetName);
        System.out.println(greeter.greet());
    }
}

# 不带参数运行
java com.example.demo.Greeter
# 输出：
# Command line args: []
# Hello, World!
 
# 带参数运行
java com.example.demo.Greeter Alice
# 输出：
# Command line args: [Alice]
# Hello, Alice!

// Java 21+ 预览特性，文件名：Hello.java
// 无需 class 声明，无需 public static
void main() {
    System.out.println("Hello, simplified Java!");
}

javac --enable-preview --release 21 Hello.java
java --enable-preview Hello

// 文件名：MyApp.java
package com.test;
 
public class App {
    public static void main(String[] args) {
        System.out.println("Running...");
    }
}

// byte: 8 位有符号整数
// 最高位为符号位，剩余 7 位表示数值
// 最大值: 0111_1111 = 2^7 - 1 = 127
// 最小值: 1000_0000 = -2^7    = -128
 
byte max = Byte.MAX_VALUE;   // 127
byte min = Byte.MIN_VALUE;   // -128
 
// 为什么负数比正数多一个？
// 因为 0 占用了正数的一个编码位（0000_0000 表示 0）
// 而负数侧的 1000_0000 没有对应的正数，它被定义为 -128

// 整数字面量默认是 int 类型
int a = 100;          // 正常：int 字面量赋给 int 变量
 
// byte 和 short 的赋值：编译器会做范围检查
byte b = 100;         // 正常：100 在 byte 范围内，编译器允许隐式窄化
byte c = 200;         // 编译错误！200 超出 byte 范围 (-128~127)
 
// long 类型必须加 L 后缀（推荐大写 L，小写 l 容易和数字 1 混淆）
long timestamp = 1718899200000L;  // 正确：加了 L 后缀
// long wrong = 1718899200000;    // 编译错误！字面量超出 int 范围，必须加 L

// 十进制 (Decimal) —— 最常用
int decimal = 255;
 
// 二进制 (Binary) —— 以 0b 或 0B 开头（Java 7+）
int binary = 0b1111_1111;       // 等于 255
 
// 八进制 (Octal) —— 以 0 开头（容易误用，不推荐）
int octal = 0377;               // 等于 255
 
// 十六进制 (Hexadecimal) —— 以 0x 或 0X 开头
int hex = 0xFF;                 // 等于 255
 
// 下划线分隔符（Java 7+）—— 提高大数字可读性
int billion = 1_000_000_000;    // 十亿，等价于 1000000000
long creditCard = 1234_5678_9012_3456L;  // 模拟信用卡号格式

int max = Integer.MAX_VALUE;    // 2,147,483,647
int overflow = max + 1;         // -2,147,483,648（回绕到最小值！）
 
// 内存中发生了什么？
// 0111_1111_..._1111  (MAX_VALUE)
// +                 1
// = 1000_0000_..._0000  (MIN_VALUE，符号位翻转)
 
System.out.println(overflow);   // 输出: -2147483648
 
// 安全做法：使用 Math.addExact()（Java 8+），溢出时抛出 ArithmeticException
int safe = Math.addExact(max, 1);  // 抛出 ArithmeticException

// 经典面试陷阱：循环中的溢出
// 下面这个循环会无限执行吗？
for (int i = Integer.MAX_VALUE - 1; i <= Integer.MAX_VALUE; i++) {
    // 当 i = MAX_VALUE 时，i++ 溢出变为 MIN_VALUE
    // MIN_VALUE <= MAX_VALUE 为 true，循环继续
    // 结果：死循环！
}

// 浮点字面量默认是 double
double pi = 3.141592653589793;   // 正常
 
// float 必须加 f 或 F 后缀
float piFloat = 3.14f;           // 正确
// float wrong = 3.14;           // 编译错误！double 不能隐式转为 float
 
// 科学计数法
double avogadro = 6.022e23;     // 6.022 × 10^23
float planck = 6.626e-34f;      // 6.626 × 10^-34

// 经典问题：0.1 + 0.2 != 0.3
System.out.println(0.1 + 0.2);           // 输出: 0.30000000000000004
System.out.println(0.1 + 0.2 == 0.3);    // 输出: false
 
// 为什么？
// 0.1 的二进制表示: 0.0001100110011001100... (无限循环)
// 0.2 的二进制表示: 0.0011001100110011001... (无限循环)
// 存储时被截断，累积了微小误差

// 金融计算中绝对不能用 float/double！
// 错误示范：
double price = 0.10;       // 商品单价
double total = price * 3;  // 期望 0.30
System.out.println(total);  // 0.30000000000000004 —— 多收了客户的钱！
 
// 正确做法：使用 BigDecimal
import java.math.BigDecimal;
 
// 注意：必须用 String 构造器，不要用 double 构造器
BigDecimal bdPrice = new BigDecimal("0.10");       // 精确的 0.10
BigDecimal bdTotal = bdPrice.multiply(new BigDecimal("3")); // 精确的 0.30
System.out.println(bdTotal);  // 0.30 —— 完美

// 正无穷和负无穷
double posInf = 1.0 / 0.0;               // Infinity
double negInf = -1.0 / 0.0;              // -Infinity
System.out.println(Double.POSITIVE_INFINITY);  // Infinity
System.out.println(Double.NEGATIVE_INFINITY);  // -Infinity
 
// NaN (Not a Number) —— 未定义的运算结果
double nan = 0.0 / 0.0;                  // NaN
double nanSqrt = Math.sqrt(-1);          // NaN
 
// NaN 的诡异特性：它不等于任何值，包括它自己！
System.out.println(nan == nan);           // false !!!
System.out.println(Double.isNaN(nan));    // true（正确的判断方式）
 
// 无穷大的运算
System.out.println(posInf + 1);           // Infinity（无穷大加任何有限数还是无穷大）
System.out.println(posInf + negInf);      // NaN（正无穷加负无穷未定义）
System.out.println(posInf * 0);           // NaN

double a = 0.1 + 0.2;  // 0.30000000000000004
double b = 0.3;         // 0.3
 
// 错误：直接用 == 比较
if (a == b) { /* 永远不会执行 */ }
 
// 正确方式一：使用 epsilon（容差）比较
final double EPSILON = 1e-10;  // 定义一个极小的容差值
if (Math.abs(a - b) < EPSILON) {
    System.out.println("近似相等");  // 会执行
}
 
// 正确方式二：使用 Double.compare()
if (Double.compare(a, b) == 0) {
    // 注意：这个方法也是精确比较，不解决精度问题
    // 但它能正确处理 NaN 和 -0.0 的比较
}
 
// 正确方式三：BigDecimal（金融场景首选）
BigDecimal bdA = new BigDecimal("0.1").add(new BigDecimal("0.2"));
BigDecimal bdB = new BigDecimal("0.3");
System.out.println(bdA.compareTo(bdB) == 0);  // true

// char 的多种赋值方式
char letter = 'A';            // 字符字面量
char unicode = '\u0041';      // Unicode 转义，也是 'A'
char number = 65;             // 整数赋值，ASCII 码 65 = 'A'
char chinese = '中';          // 中文字符，完全支持
 
// char 本质上是一个无符号 16 位整数
System.out.println((int) 'A');     // 65
System.out.println((int) '中');    // 20013
 
// 字符运算（char 参与运算时自动提升为 int）
char c1 = 'A';
// char c2 = c1 + 1;   // 编译错误！c1 + 1 的结果是 int
char c2 = (char)(c1 + 1);  // 正确：强制转换回 char，得到 'B'
int  c3 = c1 + 1;          // 正确：用 int 接收，得到 66

char newline   = '\n';    // 换行符 (Line Feed)
char tab       = '\t';    // 制表符 (Tab)
char backslash = '\\';    // 反斜杠本身
char quote     = '\'';    // 单引号
char dblQuote  = '\"';    // 双引号
char nullChar  = '\0';    // 空字符 (Null Character)
char carriageR = '\r';    // 回车符 (Carriage Return)

// 𝄞 (音乐符号 MUSICAL SYMBOL G CLEF)，码点 U+1D11E
// 一个 char 装不下，需要两个 char（代理对）
String musicNote = "𝄞";
System.out.println(musicNote.length());      // 2（两个 char 单元）
System.out.println(musicNote.codePointCount(0, musicNote.length())); // 1（一个逻辑字符）
 
// 正确遍历包含增补字符的字符串
String text = "Hello 𝄞 World";
// 错误方式：charAt 会拆散代理对
// 正确方式：使用 codePoints()
text.codePoints().forEach(cp -> {
    System.out.print(new String(Character.toChars(cp)));  // 逐个码点输出
});

boolean isActive = true;     // 布尔字面量
boolean isValid = false;
 
// 用于条件控制
if (isActive) {
    System.out.println("激活状态");
}
 
// 布尔表达式
boolean result = (10 > 5);   // true
boolean both = isActive && isValid;  // false（逻辑与）

// 在 C/C++ 中合法，在 Java 中全部编译错误：
// boolean b = 1;           // 错误！不能把 int 赋给 boolean
// boolean b = 0;           // 错误！
// if (1) { ... }           // 错误！if 条件必须是 boolean
// int x = true;            // 错误！不能把 boolean 赋给 int
 
// Java 的严格类型检查避免了 C 语言中经典的 if (x = 0) 误写 Bug
int x = 5;
// if (x = 0) { ... }      // Java 编译错误！赋值表达式结果是 int，不是 boolean
if (x == 0) { /* ... */ }   // 正确：== 比较返回 boolean

// 单个 boolean 变量：通常占 4 字节
// JVM 内部将 boolean 当作 int 处理（使用 iconst_0 / iconst_1 指令）
boolean flag = true;   // 实际占用 4 字节（与 int 相同）
 
// boolean 数组：每个元素占 1 字节
// JVM 使用 baload/bastore 指令（与 byte 数组相同）
boolean[] flags = new boolean[10];  // 每个元素 1 字节

public class DefaultValueDemo {
    // 成员变量 —— 有默认值
    static byte    sByte;      // 0
    static short   sShort;     // 0
    static int     sInt;       // 0
    static long    sLong;      // 0L
    static float   sFloat;     // 0.0f
    static double  sDouble;    // 0.0d
    static char    sChar;      // '\u0000'（空字符，打印为空白）
    static boolean sBoolean;   // false
 
    public static void main(String[] args) {
        // 成员变量可以直接使用，有默认值
        System.out.println(sInt);      // 输出: 0
        System.out.println(sBoolean);  // 输出: false
 
        // 局部变量 —— 没有默认值，必须初始化
        int localVar;
        // System.out.println(localVar);  // 编译错误！变量未初始化
        localVar = 42;                    // 初始化后才能使用
        System.out.println(localVar);     // 输出: 42
    }
}

// 内存占用对比（单位：字节）
//
// byte     [■]                          1 字节
// short    [■■]                         2 字节
// char     [■■]                         2 字节
// int      [■■■■]                       4 字节
// float    [■■■■]                       4 字节
// long     [■■■■■■■■]                   8 字节
// double   [■■■■■■■■]                   8 字节
// boolean  [■■■■] (JVM 实现，通常 4 字节)
//
// 栈帧 (Stack Frame) 中的局部变量表：
// ┌────────┬────────┬────────┬────────┐
// │ slot 0 │ slot 1 │ slot 2 │ slot 3 │  每个 slot 4 字节
// │  int a │float b │      long c     │  long/double 占 2 个 slot
// └────────┴────────┴────────┴────────┘

public class Quiz {
    public static void main(String[] args) {
        float f = 0.1f;
        double d = 0.1;
        System.out.println(f == d);
        System.out.println((double) f);
    }
}

// Java 5 之前：手动装箱与拆箱
Integer wrapped = Integer.valueOf(42);   // 手动装箱：int → Integer
int primitive = wrapped.intValue();       // 手动拆箱：Integer → int
 
List list = new ArrayList();
list.add(Integer.valueOf(10));            // 必须手动包装才能放入容器
int val = ((Integer) list.get(0)).intValue(); // 取出后还要手动拆箱

// Java 5+：自动装箱与拆箱
Integer wrapped = 42;        // 编译器自动转换为 Integer.valueOf(42)
int primitive = wrapped;      // 编译器自动转换为 wrapped.intValue()
 
List<Integer> list = new ArrayList<>();
list.add(10);                 // 自动装箱：int 10 → Integer.valueOf(10)
int val = list.get(0);        // 自动拆箱：Integer → int

public class AutoboxDemo {
    public static void main(String[] args) {
        Integer a = 100;       // 自动装箱
        int b = a;             // 自动拆箱
        Integer c = a + 10;    // 先拆箱做加法，再装箱存结果
    }
}

// Integer a = 100;
bipush 100                          // 将常量 100 压入操作数栈
invokestatic Integer.valueOf:(I)Ljava/lang/Integer;  // 调用 valueOf 装箱
 
// int b = a;
invokevirtual Integer.intValue:()I  // 调用 intValue 拆箱
 
// Integer c = a + 10;
invokevirtual Integer.intValue:()I  // 先拆箱 a
bipush 10                           // 压入 10
iadd                                // 执行 int 加法
invokestatic Integer.valueOf:(I)Ljava/lang/Integer;  // 结果再装箱

// ❌ 反面示例：循环中使用 Integer 累加
Long sum = 0L;  // 包装类型
for (long i = 0; i < 1_000_000; i++) {
    // 每次循环：sum 拆箱 → long 加法 → 结果装箱为新 Long 对象
    sum += i;   // 产生约 100 万个临时 Long 对象！
}
 
// ✅ 正确做法：循环内用基本类型
long sum = 0L;  // 基本类型，零对象开销
for (long i = 0; i < 1_000_000; i++) {
    sum += i;   // 纯栈上 long 加法，无装箱
}

Integer a = 127;    // Integer.valueOf(127)
Integer b = 127;    // Integer.valueOf(127)
System.out.println(a == b);   // true ✅
 
Integer c = 128;    // Integer.valueOf(128)
Integer d = 128;    // Integer.valueOf(128)
System.out.println(c == d);   // false ❌

// JDK Integer.valueOf 源码（简化版）
public static Integer valueOf(int i) {
    // 如果 i 在缓存范围内，直接返回缓存中的同一个对象
    if (i >= IntegerCache.low && i <= IntegerCache.high) {
        return IntegerCache.cache[i + (-IntegerCache.low)];
    }
    // 超出范围，每次 new 一个新对象
    return new Integer(i);
}

// IntegerCache 内部类（简化版）
private static class IntegerCache {
    static final int low = -128;                // 下界固定
    static final int high;                       // 上界可配置
    static final Integer[] cache;                // 缓存数组
 
    static {
        int h = 127;  // 默认上界
        // 可通过 JVM 参数 -XX:AutoBoxCacheMax=<size> 调整上界
        String integerCacheHighPropValue =
            VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            int i = parseInt(integerCacheHighPropValue);
            // 上界至少为 127
            i = Math.max(i, 127);
            // 上界不能超过 Integer.MAX_VALUE 的安全范围
            h = Math.min(i, Integer.MAX_VALUE - (-low) - 1);
        }
        high = h;
 
        // 创建缓存数组并填充
        cache = new Integer[(high - low) + 1];
        int j = low;
        for (int k = 0; k < cache.length; k++) {
            cache[k] = new Integer(j++);  // 预创建对象
        }
    }
}

// 缓存命中：a 和 b 指向缓存池中的同一个 Integer 对象
//
//  栈 (Stack)              堆 (Heap) - IntegerCache.cache[]
//  ┌──────────┐           ┌─────────────────────────────────┐
//  │ a (ref)  │ ────────► │ cache[255] = Integer(127)       │
//  ├──────────┤           │   value: 127                    │
//  │ b (ref)  │ ────────► │   (同一个对象，地址相同)          │
//  └──────────┘           └─────────────────────────────────┘
//  a == b  →  true（引用相同）
 
// 缓存未命中：c 和 d 各自 new 了不同的 Integer 对象
//
//  栈 (Stack)              堆 (Heap)
//  ┌──────────┐           ┌──────────────────┐
//  │ c (ref)  │ ────────► │ Integer@0x1A2B   │
//  │          │           │   value: 128     │
//  ├──────────┤           └──────────────────┘
//  │ d (ref)  │ ────────► ┌──────────────────┐
//  │          │           │ Integer@0x3C4D   │
//  └──────────┘           │   value: 128     │
//                         └──────────────────┘
//  c == d  →  false（引用不同，虽然 value 相同）

Double x = 1.0;
Double y = 1.0;
System.out.println(x == y);  // false，永远是不同对象

Integer a = 200;
Integer b = 200;
 
// ❌ 危险：== 比较的是引用地址
System.out.println(a == b);        // false
 
// ✅ 正确：equals 比较的是内部 int 值
System.out.println(a.equals(b));   // true
 
// ✅ Java 7+ 推荐：空安全的工具方法
System.out.println(Objects.equals(a, b));  // true，且任一方为 null 也不会 NPE

// 场景 1：直接赋值拆箱
Integer nullInteger = null;
int value = nullInteger;  // 💥 NullPointerException: null.intValue()
 
// 场景 2：方法返回值拆箱
public static Integer findById(int id) {
    // 查询数据库，未找到时返回 null
    return null;
}
int result = findById(999);  // 💥 NPE
 
// 场景 3：Map.get() 返回 null 后拆箱
Map<String, Integer> scores = new HashMap<>();
int score = scores.get("Alice");  // key 不存在 → get 返回 null → 💥 NPE
 
// 场景 4：三元表达式中的隐式拆箱（最隐蔽！）
Integer a = null;
int b = 10;
// 编译器为统一类型，会将 a 拆箱为 int
int result = (true) ? a : b;  // 💥 NPE！a 被拆箱

// 策略 1：拆箱前显式判空
Integer wrapped = getValueFromSomewhere();
int value = (wrapped != null) ? wrapped : 0;  // 提供默认值
 
// 策略 2：使用 Optional（Java 8+）
OptionalInt opt = OptionalInt.of(42);
int value = opt.orElse(0);  // 安全获取，无 NPE 风险
 
// 策略 3：使用 Objects.requireNonNullElse（Java 9+）
Integer wrapped = null;
int value = Objects.requireNonNullElse(wrapped, 0);  // 返回 0
 
// 策略 4：Map 操作使用 getOrDefault
Map<String, Integer> scores = new HashMap<>();
int score = scores.getOrDefault("Alice", 0);  // key 不存在时返回默认值 0

public final class Integer extends Number implements Comparable<Integer> {
    private final int value;  // 一旦构造完成，永远不可修改
 
    // 没有 setValue() 方法，没有任何途径修改 value
}

Integer x = 10;       // x → Integer(10)
x += 5;               // 等价于 x = Integer.valueOf(x.intValue() + 5)
                       // x 现在指向一个全新的 Integer(15) 对象
                       // 原来的 Integer(10) 如果没有其他引用，将被 GC 回收

// ❌ 已废弃：每次 new 都创建新对象，浪费内存
Integer a = new Integer(127);  // @Deprecated since Java 9
Integer b = new Integer(127);
System.out.println(a == b);    // false（两个不同对象）
 
// ✅ 推荐：valueOf 会利用缓存
Integer c = Integer.valueOf(127);  // 从缓存返回
Integer d = Integer.valueOf(127);  // 从缓存返回同一个对象
System.out.println(c == d);        // true

// ========== 字符串解析 ==========
int a = Integer.parseInt("42");          // 字符串 → int（基本类型）
Integer b = Integer.valueOf("42");       // 字符串 → Integer（包装类型）
int c = Integer.parseInt("FF", 16);      // 十六进制解析 → 255
int d = Integer.parseInt("1010", 2);     // 二进制解析 → 10
 
// ========== 进制转换 ==========
String bin = Integer.toBinaryString(42);  // "101010"
String oct = Integer.toOctalString(42);   // "52"
String hex = Integer.toHexString(42);     // "2a"
 
// ========== 位操作 ==========
int bits = Integer.bitCount(42);          // 二进制中 1 的个数 → 3
int high = Integer.highestOneBit(42);     // 最高位的 1 → 32
int zeros = Integer.numberOfLeadingZeros(42);  // 前导零个数 → 26
int reversed = Integer.reverse(42);       // 按位翻转
 
// ========== 比较与边界 ==========
int cmp = Integer.compare(10, 20);        // 比较两个 int，避免溢出
int max = Integer.MAX_VALUE;              // 2147483647 (2^31 - 1)
int min = Integer.MIN_VALUE;              // -2147483648 (-2^31)
 
// ========== Java 8+ 无符号操作 ==========
// 将 int 当作无符号数处理
int unsigned = Integer.parseUnsignedInt("4294967295");  // 无符号最大值
String uStr = Integer.toUnsignedString(unsigned);       // "4294967295"
int uDiv = Integer.divideUnsigned(-1, 2);               // 无符号除法 → 2147483647

// ❌ 基本类型：无法区分 "成绩为0" 和 "未参加考试"
public class Student {
    private int score;  // 默认值 0，语义模糊
}
 
// ✅ 包装类型：null 表示未参加考试，0 表示考了0分
public class Student {
    private Integer score;  // null = 未参加，0 = 考了0分
}

Integer a = 100;
Integer b = 100;
Integer c = 200;
Integer d = 200;
 
System.out.println(a == b);
System.out.println(c == d);
System.out.println(c.equals(d));

Map<String, Integer> map = new HashMap<>();
map.put("x", 1);
 
int a = map.get("x");
int b = map.get("y");

public class WideningDemo {
    public static void main(String[] args) {
        // ========== 1. byte/short/char 运算自动提升为 int ==========
        byte a = 10;                    // byte 类型，8 位
        byte b = 20;                    // byte 类型，8 位
        // byte c = a + b;             // ❌ 编译错误！a + b 的结果是 int，不能赋给 byte
        int c = a + b;                  // ✅ 正确：a 和 b 先提升为 int，结果也是 int
 
        char ch = 'A';                  // char 类型，Unicode 值为 65
        // char ch2 = ch + 1;          // ❌ 编译错误！ch + 1 结果是 int
        int charResult = ch + 1;        // ✅ 结果为 66（即 'B' 的 Unicode 值）
 
        // ========== 2. 混合类型的二元提升 ==========
        int i = 100;                    // int 类型
        long l = 200L;                  // long 类型
        long sum = i + l;              // i 自动提升为 long，结果为 long
 
        float f = 3.14f;               // float 类型
        double d = 2.718;              // double 类型
        double product = f * d;        // f 自动提升为 double，结果为 double
 
        // ========== 3. int 与 float 混合 ==========
        int bigInt = 1_000_000;        // int 类型，值为一百万
        float fResult = bigInt * 1.0f; // bigInt 提升为 float，结果为 float
        // 注意：此处 bigInt 的值在 float 精度范围内，暂无精度问题
 
        // ========== 4. 复合赋值运算符的隐式转换 ==========
        byte x = 10;                   // byte 类型
        x += 5;                        // ✅ 等价于 x = (byte)(x + 5)，编译器自动插入强转
        // x = x + 5;                  // ❌ 编译错误！x + 5 结果是 int
 
        System.out.println("c = " + c);              // 输出: c = 30
        System.out.println("charResult = " + charResult); // 输出: charResult = 66
        System.out.println("sum = " + sum);           // 输出: sum = 300
        System.out.println("product = " + product);   // 输出: product = 8.53452
        System.out.println("x = " + x);              // 输出: x = 15
    }
}

public class ConstantNarrowingDemo {
    public static void main(String[] args) {
        // ========== 编译期常量的隐式窄化 ==========
        byte b1 = 100;                 // ✅ 100 是编译期常量，且在 byte 范围 [-128, 127] 内
        // byte b2 = 200;              // ❌ 编译错误！200 超出 byte 范围
        byte b3 = 50 + 30;             // ✅ 50 + 30 = 80，编译期可计算，在 byte 范围内
 
        final int LIMIT = 120;         // final 变量，编译期常量
        byte b4 = LIMIT;              // ✅ LIMIT 是编译期常量，120 在 byte 范围内
 
        int variable = 100;            // 非 final，不是编译期常量
        // byte b5 = variable;         // ❌ 编译错误！variable 不是编译期常量
 
        short s1 = 32000;             // ✅ 32000 在 short 范围 [-32768, 32767] 内
        char c1 = 65;                 // ✅ 65 在 char 范围 [0, 65535] 内，对应 'A'
    }
}

public class NarrowingDemo {
    public static void main(String[] args) {
        // ========== 1. 基本的窄化转换 ==========
        int bigValue = 300;            // int 类型，值为 300
        byte narrowed = (byte) bigValue; // 强制转换为 byte
        // 300 的二进制: 00000000 00000000 00000001 00101100
        // 截断为 8 位:                           00101100 = 44
        System.out.println("narrowed = " + narrowed); // 输出: narrowed = 44
 
        // ========== 2. 负数的窄化 ==========
        int negative = -129;           // 超出 byte 范围
        byte negNarrowed = (byte) negative; // 强制转换
        // -129 的补码(32位): 11111111 11111111 11111111 01111111
        // 截断为 8 位:                                  01111111 = 127
        System.out.println("negNarrowed = " + negNarrowed); // 输出: negNarrowed = 127
 
        // ========== 3. double → int 截断小数部分 ==========
        double pi = 3.99;             // double 类型
        int truncated = (int) pi;     // 直接截断小数部分，不是四舍五入！
        System.out.println("truncated = " + truncated); // 输出: truncated = 3
 
        // ========== 4. double → int 的极端情况 ==========
        double huge = 1.0E20;         // 远超 int 最大值
        int overflow = (int) huge;    // 结果为 Integer.MAX_VALUE
        System.out.println("overflow = " + overflow); // 输出: overflow = 2147483647
 
        double nan = Double.NaN;      // NaN（Not a Number）
        int nanToInt = (int) nan;     // NaN 转整型结果为 0
        System.out.println("nanToInt = " + nanToInt); // 输出: nanToInt = 0
    }
}

public class TruncationRulesDemo {
    public static void main(String[] args) {
        // ========== 整型截断的位级分析 ==========
        int value = 0x1_FF;           // 十六进制 0x1FF = 十进制 511
        // 二进制: 00000000 00000000 00000001 11111111
        byte result = (byte) value;   // 截断为低 8 位: 11111111
        // 11111111 作为有符号 byte 的补码 = -1
        System.out.println("0x1FF as byte = " + result); // 输出: -1
 
        // ========== 浮点转整型的边界行为 ==========
        double posInf = Double.POSITIVE_INFINITY; // 正无穷
        double negInf = Double.NEGATIVE_INFINITY; // 负无穷
 
        // 正无穷转 int → Integer.MAX_VALUE
        System.out.println("posInf → int: " + (int) posInf);   // 2147483647
        // 负无穷转 int → Integer.MIN_VALUE
        System.out.println("negInf → int: " + (int) negInf);   // -2147483648
        // 正无穷转 long → Long.MAX_VALUE
        System.out.println("posInf → long: " + (long) posInf); // 9223372036854775807
 
        // ========== 向零截断 vs 四舍五入 ==========
        System.out.println("(int) 3.7  = " + (int) 3.7);   // 3，不是 4
        System.out.println("(int) -3.7 = " + (int) -3.7);  // -3，不是 -4
        // 如果需要四舍五入，使用 Math.round()
        System.out.println("Math.round(3.7) = " + Math.round(3.7));   // 4
        System.out.println("Math.round(-3.7) = " + Math.round(-3.7)); // -4
    }
}

public class CharConversionDemo {
    public static void main(String[] args) {
        // ========== char → int：widening，安全 ==========
        char ch = '中';               // Unicode: \u4E2D = 20013
        int codePoint = ch;           // 自动提升为 int
        System.out.println("'中' 的 Unicode 值: " + codePoint); // 20013
 
        // ========== int → char：narrowing，需要强转 ==========
        int code = 65;                // 'A' 的 Unicode 值
        char letter = (char) code;    // 强制转换
        System.out.println("code 65 → char: " + letter); // A
 
        // ========== byte → char：需要强转（两步转换） ==========
        // byte 是有符号的 [-128, 127]，char 是无符号的 [0, 65535]
        // 这不是简单的 widening，因为 byte 的负值无法直接映射到 char
        byte b = -1;                  // byte 值为 -1
        // char c = b;                // ❌ 编译错误！
        char c = (char) b;           // 强制转换
        // -1 的补码(32位): 11111111 11111111 11111111 11111111
        // 先提升为 int，再截断为 16 位: 11111111 11111111 = 65535
        System.out.println("byte -1 → char: " + (int) c); // 65535
 
        // ========== short ↔ char：双向都需要强转 ==========
        // short 范围 [-32768, 32767]，char 范围 [0, 65535]
        // 两者都是 16 位，但符号性不同
        short s = -1;                 // short 值为 -1
        // char c2 = s;              // ❌ 编译错误！
        char c2 = (char) s;          // 强制转换，结果为 65535
        // char c3 = 'A';
        // short s2 = c3;            // ❌ 编译错误！char 可能超出 short 范围
    }
}

public class PrecisionLossDemo {
    public static void main(String[] args) {
        // ========== 场景 1: int → float 精度丢失 ==========
        int bigInt = 16_777_217;       // 2^24 + 1 = 16777217
        float f = bigInt;              // 自动提升为 float（widening，编译器不报错）
        System.out.println("原始 int 值:  " + bigInt);       // 16777217
        System.out.println("转为 float:   " + f);            // 1.6777216E7
        System.out.println("float 转回 int: " + (int) f);    // 16777216 ← 丢失了 1！
 
        // 验证：float 无法区分 16777216 和 16777217
        float f1 = 16_777_216f;        // 2^24
        float f2 = 16_777_217f;        // 2^24 + 1
        System.out.println("f1 == f2 ? " + (f1 == f2));      // true！两个不同的值变成了同一个
 
        // ========== 场景 2: long → float 精度丢失（更严重） ==========
        long bigLong = 123_456_789_123_456_789L; // 18 位十进制数
        float fFromLong = bigLong;     // long → float，widening
        System.out.println("\n原始 long 值:  " + bigLong);
        System.out.println("转为 float:    " + fFromLong);    // 1.23456792E17
        // float 只有约 7 位有效数字，18 位的 long 值被严重截断
 
        // ========== 场景 3: long → double 精度丢失 ==========
        long precisionLong = Long.MAX_VALUE;  // 9223372036854775807
        double dFromLong = precisionLong;     // long → double，widening
        System.out.println("\n原始 long 值:  " + precisionLong);
        System.out.println("转为 double:   " + dFromLong);    // 9.223372036854776E18
        // double 有约 15-16 位有效数字，long 最大值有 19 位，末尾几位被四舍五入
 
        long backToLong = (long) dFromLong;   // double → long
        System.out.println("double 转回 long: " + backToLong);
        // 输出: -9223372036854775808 (Long.MIN_VALUE!) ← 溢出了！
        System.out.println("与原值相等? " + (precisionLong == backToLong)); // false
    }
}

public class FloatingPointTrapDemo {
    public static void main(String[] args) {
        // ========== 经典陷阱: 0.1 + 0.2 != 0.3 ==========
        double a = 0.1;                // 0.1 在二进制中是无限循环小数
        double b = 0.2;                // 0.2 同样是无限循环小数
        double sum = a + b;            // 两个近似值相加
        System.out.println("0.1 + 0.2 = " + sum);           // 0.30000000000000004
        System.out.println("0.1 + 0.2 == 0.3 ? " + (sum == 0.3)); // false!
 
        // ========== 解决方案 1: 使用 epsilon 比较 ==========
        double epsilon = 1e-10;        // 定义一个极小的容差值
        boolean isEqual = Math.abs(sum - 0.3) < epsilon; // 判断差值是否在容差内
        System.out.println("使用 epsilon 比较: " + isEqual); // true
 
        // ========== 解决方案 2: 使用 BigDecimal（推荐用于金融场景） ==========
        java.math.BigDecimal bd1 = new java.math.BigDecimal("0.1"); // 必须用 String 构造！
        java.math.BigDecimal bd2 = new java.math.BigDecimal("0.2");
        java.math.BigDecimal bdSum = bd1.add(bd2);
        System.out.println("BigDecimal: 0.1 + 0.2 = " + bdSum); // 0.3（精确）
 
        // ⚠️ 注意：不要用 double 构造 BigDecimal
        java.math.BigDecimal bad = new java.math.BigDecimal(0.1); // 传入的已经是不精确的 double
        System.out.println("BigDecimal(0.1) = " + bad);
        // 输出: 0.1000000000000000055511151231257827021181583404541015625
    }
}

public class BestPracticeDemo {
    public static void main(String[] args) {
        // ========== 实践 1: 金融计算永远用 BigDecimal ==========
        java.math.BigDecimal price = new java.math.BigDecimal("19.99");  // 用 String 构造
        java.math.BigDecimal quantity = new java.math.BigDecimal("3");
        java.math.BigDecimal total = price.multiply(quantity);           // 精确乘法
        System.out.println("总价: " + total);  // 59.97（精确）
 
        // ========== 实践 2: 比较浮点数用 Double.compare() ==========
        double x = 0.1 + 0.2;         // 不精确的浮点运算
        double y = 0.3;               // 不精确的浮点字面量
        // 不推荐: x == y（结果为 false）
        // 推荐: 使用容差比较或 Double.compare
        System.out.println("Double.compare: " + Double.compare(x, y));  // 可能不为 0
 
        // ========== 实践 3: 整型除法要小心 ==========
        int total2 = 7;               // 被除数
        int count = 2;                // 除数
        // 整型除法直接截断小数
        System.out.println("7 / 2 = " + (total2 / count));         // 3，不是 3.5
        // 需要浮点结果时，先将一个操作数转为 double
        System.out.println("7.0 / 2 = " + ((double) total2 / count)); // 3.5
 
        // ========== 实践 4: 避免用 float/double 做循环计数器 ==========
        // ❌ 错误示范：浮点累加误差会不断积累
        float fSum = 0.0f;            // float 累加器
        for (int i = 0; i < 10; i++) {
            fSum += 0.1f;             // 每次加 0.1f（不精确）
        }
        System.out.println("float 累加 10 次 0.1: " + fSum); // 1.0000001（不是 1.0）
 
        // ✅ 正确做法：用整型计数，最后再转换
        int cents = 0;                // 用"分"作为单位（整型）
        for (int i = 0; i < 10; i++) {
            cents += 10;              // 每次加 10 分
        }
        double yuan = cents / 100.0;  // 最后转换为"元"
        System.out.println("整型累加后转换: " + yuan); // 1.0（精确）
    }
}

public class Quiz {
    public static void main(String[] args) {
        byte b = 127;
        b += 1;
        float f = 16_777_217;
        int i = (int) f;
        System.out.println(b + " " + i);
    }
}

public class LocalVariableDemo {
 
    public void demonstrate() {
        // ========== 1. 基本声明与初始化 ==========
        int count;          // 声明局部变量，此时栈帧中分配了空间，但值未定义
        // System.out.println(count); // ❌ 编译错误：variable count might not have been initialized
        count = 10;         // 显式赋值后才可使用
        System.out.println(count); // ✅ 输出 10
 
        // ========== 2. 声明时直接初始化（推荐写法） ==========
        double price = 99.5; // 声明与初始化一步完成，代码更清晰
 
        // ========== 3. 作用域演示 ==========
        if (count > 5) {
            String message = "count 大于 5"; // message 的作用域仅限于这个 if 块
            System.out.println(message);     // ✅ 在作用域内，可以访问
        }
        // System.out.println(message); // ❌ 编译错误：message 在此处不可见
 
        // ========== 4. for 循环中的局部变量 ==========
        for (int i = 0; i < 3; i++) { // i 的作用域仅限于 for 循环
            int squared = i * i;       // squared 每次循环迭代都会重新创建
            System.out.println(squared);
        }
        // System.out.println(i); // ❌ 编译错误：i 在循环外不可见
 
        // ========== 5. 条件分支中的明确赋值分析 ==========
        int result;
        boolean flag = true;
        if (flag) {
            result = 1;  // 分支一赋值
        } else {
            result = -1; // 分支二赋值
        }
        // 编译器分析：所有路径都对 result 赋了值，所以下面可以使用
        System.out.println(result); // ✅ 编译通过
 
        // ========== 6. 反例：不完整的分支赋值 ==========
        int value;
        if (flag) {
            value = 42;
        }
        // 如果 flag 为 false，value 就没有被赋值
        // System.out.println(value); // ❌ 编译错误：variable value might not have been initialized
    }
}

// 局部变量表的底层视角（概念模型）
// 假设方法签名为: void calculate(int x, double y)
// 对于实例方法，slot 0 始终是 this 引用

┌─────────────────────────────────────────┐
│           局部变量表 (Local Variable Table)  │
├────────┬────────────┬───────────────────┤
│ Slot 0 │ this       │ 当前对象引用 (隐式)   │
│ Slot 1 │ x          │ int, 占 1 个 slot    │
│ Slot 2 │ y          │ double, 占 2 个 slot │
│ Slot 4 │ localVar   │ 方法体内声明的变量     │
└────────┴────────────┴───────────────────┘

public void slotReuse() {
    {
        int a = 1;       // a 占用 slot 1
        System.out.println(a);
    } // a 的作用域结束，slot 1 可被复用
 
    int b = 2;           // b 复用了 slot 1（编译器优化）
    System.out.println(b);
}

public class InstanceVariableDemo {
 
    // ========== 各类型成员变量的默认值 ==========
    byte    byteVal;      // 默认值: 0
    short   shortVal;     // 默认值: 0
    int     intVal;       // 默认值: 0
    long    longVal;      // 默认值: 0L
    float   floatVal;     // 默认值: 0.0f
    double  doubleVal;    // 默认值: 0.0d
    char    charVal;      // 默认值: '\u0000' (空字符, 不是 '0')
    boolean boolVal;      // 默认值: false
    String  stringVal;    // 默认值: null (所有引用类型都是 null)
    int[]   arrayVal;     // 默认值: null (数组也是引用类型)
 
    // ========== 声明时初始化 ==========
    int     initialized = 42;          // 显式初始化，覆盖默认值
    String  greeting    = "Hello";     // 引用类型显式初始化
 
    public void printDefaults() {
        // 成员变量无需显式初始化即可直接使用（与局部变量不同）
        System.out.println("int 默认值: " + intVal);       // 输出 0
        System.out.println("boolean 默认值: " + boolVal);  // 输出 false
        System.out.println("String 默认值: " + stringVal); // 输出 null
        System.out.println("char 默认值: [" + charVal + "]"); // 输出 [ ] (空字符不可见)
    }
}

┌──────────────────────────────────────────────────┐
│              对象在堆内存中的布局                     │
├──────────────────────────────────────────────────┤
│  Object Header (对象头)                            │
│  ┌─────────────────────────────────────────────┐ │
│  │ Mark Word (8 bytes on 64-bit)               │ │
│  │ → hashCode / GC age / lock state            │ │
│  ├─────────────────────────────────────────────┤ │
│  │ Klass Pointer (4 bytes, 压缩指针)            │ │
│  │ → 指向方法区中的 Class 元数据                  │ │
│  └─────────────────────────────────────────────┘ │
├──────────────────────────────────────────────────┤
│  Instance Data (实例数据 / 成员变量)                │
│  ┌─────────────────────────────────────────────┐ │
│  │ intVal     = 0          (4 bytes)           │ │
│  │ floatVal   = 0.0f       (4 bytes)           │ │
│  │ longVal    = 0L         (8 bytes)           │ │
│  │ doubleVal  = 0.0d       (8 bytes)           │ │
│  │ boolVal    = false      (1 byte)            │ │
│  │ charVal    = '\u0000'   (2 bytes)           │ │
│  │ stringVal  = null       (4 bytes, 压缩引用)  │ │
│  └─────────────────────────────────────────────┘ │
├──────────────────────────────────────────────────┤
│  Padding (对齐填充, 凑齐 8 的倍数)                  │
└──────────────────────────────────────────────────┘

public class StaticVariableDemo {
 
    // 类变量：所有实例共享同一份
    static int instanceCount = 0;  // 记录创建了多少个实例
 
    // 成员变量：每个实例独立拥有
    String name;
 
    public StaticVariableDemo(String name) {
        this.name = name;       // 为当前实例的成员变量赋值
        instanceCount++;        // 类变量 +1，所有实例看到的是同一个计数器
    }
 
    public static void main(String[] args) {
        StaticVariableDemo a = new StaticVariableDemo("Alice");
        StaticVariableDemo b = new StaticVariableDemo("Bob");
        StaticVariableDemo c = new StaticVariableDemo("Charlie");
 
        // 通过类名访问类变量（推荐写法）
        System.out.println(StaticVariableDemo.instanceCount); // 输出 3
 
        // 也可以通过实例访问，但不推荐（容易误解为实例变量）
        System.out.println(a.instanceCount); // 输出 3，编译器会给出警告
    }
}

public class VariableComparison {
 
    // ① 类变量 (static field) — 类加载时初始化，全局唯一
    static String className = "VariableComparison";
 
    // ② 成员变量 (instance field) — new 对象时初始化，每个对象一份
    int id;
 
    public void method() {
        // ③ 局部变量 (local variable) — 方法调用时在栈上分配，方法结束即销毁
        int temp = 0;
    }
}

public class InitOrderDemo {
 
    // ② 成员变量声明时初始化（按源码顺序执行）
    int x = 10;
 
    // ③ 实例初始化块（Instance Initializer Block）
    {
        System.out.println("实例初始化块执行, x = " + x); // x 已经是 10
        x = 20; // 可以修改
    }
 
    // ④ 构造器
    public InitOrderDemo() {
        System.out.println("构造器执行, x = " + x); // x 是 20
        x = 30;
    }
 
    // 对于类变量，还有 static 初始化块
    static int s;
 
    static {
        s = 100; // 类加载时执行，早于任何实例创建
        System.out.println("静态初始化块执行");
    }
 
    public static void main(String[] args) {
        // 输出顺序：
        // 静态初始化块执行          ← 类加载阶段
        // 实例初始化块执行, x = 10  ← 对象创建阶段
        // 构造器执行, x = 20       ← 对象创建阶段
        InitOrderDemo demo = new InitOrderDemo();
        System.out.println("最终 x = " + demo.x); // 输出 30
    }
}

class Parent {
    Parent() {
        // 构造器中调用了可被覆盖的方法 —— 危险！
        display(); // 此时如果实际类型是 Child，会调用 Child.display()
    }
 
    void display() {
        System.out.println("Parent display");
    }
}
 
class Child extends Parent {
    int value = 42; // 此时还没执行到这一行！
 
    @Override
    void display() {
        // 在 Parent 构造器中被调用时，value 还是默认值 0
        System.out.println("Child display, value = " + value); // 输出 0，不是 42！
    }
}
 
// new Child() 的输出：
// Child display, value = 0   ← 陷阱！value 还未被初始化为 42

public class FinalVariableDemo {
 
    // ========== 1. final 基本类型：值不可变 ==========
    final int MAX_RETRY = 3;
    // MAX_RETRY = 5; // ❌ 编译错误：cannot assign a value to final variable
 
    // ========== 2. final 引用类型：引用不可变，对象内容可变！ ==========
    final List<String> names = new ArrayList<>();
 
    public void modifyFinalReference() {
        names.add("Alice");   // ✅ 可以修改对象内部状态
        names.add("Bob");     // ✅ 列表内容变了，但 names 引用没变
        // names = new ArrayList<>(); // ❌ 编译错误：不能让 names 指向新对象
    }
 
    // ========== 3. final 局部变量 ==========
    public void finalLocal() {
        final int x = 10;
        // x = 20; // ❌ 编译错误
 
        // final 局部变量可以先声明后赋值（但只能赋值一次）
        final int y;
        y = computeValue(); // ✅ 第一次赋值
        // y = 100;          // ❌ 编译错误：已经赋过值了
    }
 
    // ========== 4. final 方法参数 ==========
    public void process(final String input) {
        // input = "new value"; // ❌ 编译错误：final 参数不可重新赋值
        System.out.println(input.toUpperCase()); // ✅ 可以调用方法
    }
 
    private int computeValue() {
        return 42;
    }
}