Java

发表于 2024-11-26 更新于 2025-04-26 分类于编程语言

语法树

graph LR
    A[Java 语法概览]

    %% 1. 基础语法特性 (Java SE 1.0-7)
    A --> B[基础语法特性<br>Java SE 1.0-7]
    B --> B1[基本数据类型]
    B1 --> B1a["整型: byte, short, int, long"]
    B1 --> B1b["浮点型: float, double"]
    B1 --> B1c["字符型: char"]
    B1 --> B1d["布尔型: boolean"]
    
    B --> B2[变量与常量]
    B2 --> B2a["变量声明与定义"]
    B2 --> B2b["常量: final"]
    
    B --> B3[运算符]
    B3 --> B3a["算术运算符: +, -, *, /, %"]
    B3 --> B3b["关系运算符: ==, !=, &lt;, &gt;"]
    B3 --> B3c["逻辑运算符: &amp;&amp;, ||, !"]
    B3 --> B3d["位运算符: &amp;, |, ^, ~, &lt;&lt;, &gt;&gt;"]
    B3 --> B3e["赋值运算符: =, +=, -="]
    B3 --> B3f["其他: instanceof, ternary ?:"]
    
    B --> B4[控制结构]
    B4 --> B4a["条件语句: if, else"]
    B4 --> B4b["开关语句: switch, case"]
    B4 --> B4c["循环: for, while, do-while"]
    B4 --> B4d["跳转: break, continue, return"]
    
    B --> B5[函数与方法]
    B5 --> B5a["方法定义与调用"]
    B5 --> B5b["参数传递: 值传递"]
    B5 --> B5c["方法重载"]
    
    B --> B6[类与对象]
    B6 --> B6a["类定义: class"]
    B6 --> B6b["访问控制: public, private, protected"]
    B6 --> B6c["构造函数"]
    B6 --> B6d["静态成员: static"]
    B6 --> B6e["继承: extends"]
    B6 --> B6f["多态性: override"]
    B6 --> B6g["接口: interface"]
    B6 --> B6h["抽象类: abstract"]
    
    B --> B7[包与命名空间]
    B7 --> B7a["包定义: package"]
    B7 --> B7b["导入: import"]
    
    B --> B8[异常处理]
    B8 --> B8a["try, catch, finally"]
    B8 --> B8b["throw, throws"]
    B8 --> B8c["自定义异常"]
    
    B --> B9[泛型]
    B9 --> B9a["泛型类"]
    B9 --> B9b["泛型方法"]
    B9 --> B9c["通配符: ?, extends, super"]
    
    B --> B10[动态内存管理]
    B10 --> B10a["new"]
    
    B --> B11[注解]
    B11 --> B11a["内置注解: @Override, @Deprecated"]
    B11 --> B11b["自定义注解"]

    %% 2. 现代 Java 新特性
    A --> C[现代 Java 新特性]
    
    C --> C1[Java 8]
    C1 --> C1a["Lambda 表达式"]
    C1 --> C1b["函数式接口: @FunctionalInterface"]
    C1 --> C1c["Stream API"]
    C1 --> C1d["Optional 类"]
    C1 --> C1e["默认方法: default"]
    C1 --> C1f["静态方法: 接口中 static"]
    C1 --> C1g["方法引用: ::"]
    C1 --> C1h["日期时间 API: java.time"]
    
    C --> C2[Java 9]
    C2 --> C2a["模块化: module-info.java"]
    C2 --> C2b["私有接口方法"]
    C2 --> C2c["try-with-resources 改进"]
    C2 --> C2d["集合工厂方法: List.of()"]
    
    C --> C3[Java 10]
    C3 --> C3a["局部变量类型推导: var"]
    
    C --> C4[Java 11]
    C4 --> C4a["字符串增强: strip(), lines()"]
    C4 --> C4b["HTTP Client API"]
    
    C --> C5[Java 14]
    C5 --> C5a["Switch 表达式"]
    C5 --> C5b["instanceof 模式匹配"]
    
    C --> C6[Java 15]
    C6 --> C6a["文本块: """...""""]
    
    C --> C7[Java 17]
    C7 --> C7a["密封类: sealed, permits"]
    C7 --> C7b["模式匹配 Switch (预览)"]
    
    C --> C8[Java 21]
    C8 --> C8a["虚拟线程"]
    C8 --> C8b["结构化并发"]
    C8 --> C8c["记录模式匹配"]

    %% 3. 其他特性
    A --> D[其他特性]
    D --> D1[标准库扩展<br>Java SE 1.0+]
    D1 --> D1a["集合框架: List, Map, Set"]
    D1 --> D1b["输入输出: java.io, java.nio"]
    D1 --> D1c["并发库: java.util.concurrent"]
    D1 --> D1d["字符串: String, StringBuilder"]
    
    D --> D2[编译器与运行时]
    D2 --> D2a["JVM: 垃圾回收"]
    D2 --> D2b["反射: java.lang.reflect"]

详解

1. 基础语法特性 (Java SE 1.0-7)

1.1 基本数据类型

1.1.1 整型 (`byte`, `short`, `int`, `long`)

功能：表示整数值，范围分别为 8 位、16 位、32 位和 64 位。
使用场景：存储数值数据，如计数器、索引、文件大小。
底层原理：在 JVM 中存储为二进制补码，long 需要加 L 后缀以区分。
注意事项：注意溢出问题，byte 范围为 -128 到 127。

示例代码：

public class IntegerTypes {
    public static void main(String[] args) {
        byte b = 127;
        int i = 2147483647;
        long l = 9223372036854775807L;
        System.out.println("byte: " + b + ", int: " + i + ", long: " + l);
    }
}

1.1.2 浮点型 (`float`, `double`)

功能：表示浮点数，float 32 位，double 64 位。
使用场景：科学计算、图形处理、需要小数运算的场景。
底层原理：遵循 IEEE 754 浮点标准，分为符号、指数和尾数。
注意事项：float 需要加 f 后缀，避免精度丢失问题。

示例代码：

public class FloatTypes {
    public static void main(String[] args) {
        float f = 3.14f;
        double d = 3.14159;
        System.out.println("float: " + f + ", double: " + d);
    }
}

1.1.3 字符型 (`char`)

功能：表示单个 Unicode 字符（16 位）。
使用场景：处理单个字符，如字母、符号。
底层原理：存储为无符号整数，对应 Unicode 编码。
注意事项：范围为 0 到 65535，可用 \u 表示 Unicode。

示例代码：

public class CharType {
    public static void main(String[] args) {
        char c = 'A';
        char unicode = '\u0041'; // 'A'
        System.out.println("char: " + c + ", unicode: " + unicode);
    }
}

1.1.4 布尔型 (`boolean`)

功能：表示真假值（true 或 false）。
使用场景：条件判断、标志位。
底层原理：JVM 实现中通常占 1 位，但实际大小取决于实现。
注意事项：不能与整数直接转换。

示例代码：

public class BooleanType {
    public static void main(String[] args) {
        boolean flag = true;
        System.out.println("boolean: " + flag);
    }
}

1.2 变量与常量

1.2.1 变量声明与定义

功能：分配内存并命名，用于存储数据。
使用场景：任何需要临时存储数据的场景。
底层原理：在栈或堆中分配内存，类型决定大小。
注意事项：局部变量必须初始化，类变量有默认值。

示例代码：

public class VariableDeclaration {
    public static void main(String[] args) {
        int x = 10;
        System.out.println("x: " + x);
    }
}

1.2.2 常量 (`final`)

功能：定义不可修改的值。
使用场景：定义数学常数、配置值。
底层原理：编译时替换为字面量，运行时不可变。
注意事项：必须在声明时或构造函数中初始化。

示例代码：

public class Constants {
    public static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println("PI: " + PI);
    }
}

1.3 运算符

1.3.1 算术运算符 (`+`, `-`, `*`, `/`, `%`)

功能：执行基本数学运算。
使用场景：计算、数值处理。
底层原理：基于 CPU 算术逻辑单元（ALU）执行。
注意事项：除以 0 会抛出 ArithmeticException。

示例代码：

public class ArithmeticOperators {
    public static void main(String[] args) {
        int a = 10, b = 3;
        System.out.println("a + b = " + (a + b));
        System.out.println("a % b = " + (a % b));
    }
}

1.3.2 关系运算符 (`==`, `!=`, `<`, `>`, `<=`, `>=`)

功能：比较两个值，返回布尔结果。
使用场景：条件判断、排序。
底层原理：比较内存中的二进制值。
注意事项：对象用 equals() 而非 ==。

示例代码：

public class RelationalOperators {
    public static void main(String[] args) {
        int a = 10, b = 3;
        System.out.println("a > b: " + (a > b));
    }
}

1.3.3 逻辑运算符 (`&&`, `||`, `!`)

功能：组合布尔表达式。
使用场景：多条件判断。
底层原理：短路求值，&& 前为假则不计算后。
注意事项：确保操作数是布尔值。

示例代码：

public class LogicalOperators {
    public static void main(String[] args) {
        boolean x = true, y = false;
        System.out.println("x && y: " + (x && y));
    }
}

1.3.4 位运算符 (`&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`)

功能：按位操作整数。
使用场景：位标志、低级优化。
底层原理：直接操作二进制位。
注意事项：>>> 是无符号右移。

示例代码：

public class BitOperators {
    public static void main(String[] args) {
        int a = 5; // 0101
        System.out.println("a << 1: " + (a << 1)); // 1010
    }
}

1.3.5 赋值运算符 (`=`, `+=`, `-=`, `*=`, `/=`, `%=`)

功能：赋值或复合运算。
使用场景：更新变量值。
底层原理：直接修改内存值。
注意事项：类型需匹配。

示例代码：

public class AssignmentOperators {
    public static void main(String[] args) {
        int a = 10;
        a += 5;
        System.out.println("a: " + a);
    }
}

1.3.6 其他运算符 (`instanceof`, `?:`)

功能：类型检查（instanceof）和条件选择（?:）。
使用场景：对象类型判断、三元表达式。
底层原理：instanceof 检查类层次，?: 是条件分支。
注意事项：instanceof 不适用于基本类型。

示例代码：

public class OtherOperators {
    public static void main(String[] args) {
        String s = "Hello";
        System.out.println("s instanceof String: " + (s instanceof String));
        int x = 5;
        String result = (x > 0) ? "Positive" : "Negative";
        System.out.println(result);
    }
}

1.4 控制结构

1.4.1 条件语句 (`if`, `else`)

功能：根据条件执行代码。
使用场景：分支逻辑。
底层原理：JVM 跳转指令（if_icmpeq 等）。
注意事项：避免嵌套过深。

示例代码：

public class IfElse {
    public static void main(String[] args) {
        int x = 10;
        if (x > 0) System.out.println("Positive");
        else System.out.println("Non-positive");
    }
}

1.4.2 开关语句 (`switch`, `case`)

功能：多分支选择。
使用场景：固定值匹配。
底层原理：编译为跳转表或条件分支。
注意事项：需 break，支持基本类型和枚举。

示例代码：

public class SwitchCase {
    public static void main(String[] args) {
        int day = 1;
        switch (day) {
            case 1: System.out.println("Monday"); break;
            default: System.out.println("Other");
        }
    }
}

1.4.3 循环 (`for`, `while`, `do-while`)

功能：重复执行代码。
使用场景：迭代、遍历。
底层原理：跳转和条件检查指令。
注意事项：避免死循环。

示例代码：

public class Loops {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) System.out.println(i);
        int x = 0;
        while (x < 2) { System.out.println(x++); }
    }
}

1.4.4 跳转 (`break`, `continue`, `return`)

功能：控制循环或方法流程。
使用场景：提前退出、跳过迭代。
底层原理：跳转到指定字节码位置。
注意事项：谨慎使用带标签的 break。

示例代码：

public class Jumps {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            if (i == 3) break;
            System.out.println(i);
        }
    }
}

1.5 函数与方法

1.5.1 方法定义与调用

功能：封装可重用代码。
使用场景：逻辑复用。
底层原理：JVM 调用栈帧。
注意事项：方法必须在类中。

示例代码：

public class MethodDef {
    static int add(int a, int b) { return a + b; }
    public static void main(String[] args) {
        System.out.println(add(2, 3));
    }
}

1.5.2 参数传递 (值传递)

功能：将参数值传递给方法。
使用场景：方法输入。
底层原理：复制变量值，对象传递引用副本。
注意事项：无法修改原始基本类型变量。

示例代码：

public class ParamPassing {
    static void modify(int x) { x = 20; }
    public static void main(String[] args) {
        int a = 10;
        modify(a);
        System.out.println("a: " + a); // 仍为 10
    }
}

1.5.3 方法重载

功能：同名方法不同参数。
使用场景：提高代码灵活性。
底层原理：编译时根据签名区分。
注意事项：返回值类型不影响重载。

示例代码：

public class MethodOverload {
    static int add(int a, int b) { return a + b; }
    static double add(double a, double b) { return a + b; }
    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(add(2.5, 3.5));
    }
}

1.6 类与对象

1.6.1 类定义 (`class`)

功能：定义对象模板。
使用场景：面向对象编程。
底层原理：编译为字节码，JVM 加载。
注意事项：类名与文件名一致。

示例代码：

public class ClassDef {
    int x = 5;
    public static void main(String[] args) {
        ClassDef obj = new ClassDef();
        System.out.println(obj.x);
    }
}

1.6.2 访问控制 (`public`, `private`, `protected`)

功能：控制成员访问权限。
使用场景：封装数据。
底层原理：编译器检查访问规则。
注意事项：默认访问为包级。

示例代码：

public class AccessControl {
    private int x = 10;
    public int getX() { return x; }
    public static void main(String[] args) {
        AccessControl obj = new AccessControl();
        System.out.println(obj.getX());
    }
}

1.6.3 构造函数

功能：初始化对象。
使用场景：对象创建时设置初始值。
底层原理：JVM 调用 <init> 方法。
注意事项：无返回值，可重载。

示例代码：

public class Constructor {
    int x;
    Constructor(int x) { this.x = x; }
    public static void main(String[] args) {
        Constructor obj = new Constructor(5);
        System.out.println(obj.x);
    }
}

1.6.4 静态成员 (`static`)

功能：属于类而非实例。
使用场景：共享数据或工具方法。
底层原理：存储在方法区。
注意事项：不能访问非静态成员。

示例代码：

public class StaticMember {
    static int count = 0;
    StaticMember() { count++; }
    public static void main(String[] args) {
        new StaticMember();
        new StaticMember();
        System.out.println("Count: " + count);
    }
}

1.6.5 继承 (`extends`)

功能：子类继承父类成员。
使用场景：代码复用。
底层原理：类层次存储在 JVM。
注意事项：Java 只支持单继承。

示例代码：

class Parent { int x = 10; }
public class Inheritance extends Parent {
    public static void main(String[] args) {
        Inheritance obj = new Inheritance();
        System.out.println(obj.x);
    }
}

1.6.6 多态性 (`@Override`)

功能：子类覆盖父类方法。
使用场景：动态行为。
底层原理：虚方法表（vtable）。
注意事项：需一致签名。

示例代码：

class Animal { void sound() { System.out.println("Sound"); } }
public class Polymorphism extends Animal {
    @Override
    void sound() { System.out.println("Woof"); }
    public static void main(String[] args) {
        Animal dog = new Polymorphism();
        dog.sound();
    }
}

1.6.7 接口 (`interface`)

功能：定义方法契约。
使用场景：多实现、解耦。
底层原理：编译为抽象类。
注意事项：方法默认 public abstract。

示例代码：

interface Animal { void sound(); }
public class InterfaceDemo implements Animal {
    public void sound() { System.out.println("Meow"); }
    public static void main(String[] args) {
        InterfaceDemo cat = new InterfaceDemo();
        cat.sound();
    }
}

1.6.8 抽象类 (`abstract`)

功能：部分实现，禁止实例化。
使用场景：定义通用模板。
底层原理：与普通类类似，但限制实例化。
注意事项：可包含具体方法。

示例代码：

abstract class Shape { abstract void draw(); }
public class AbstractClass extends Shape {
    void draw() { System.out.println("Circle"); }
    public static void main(String[] args) {
        AbstractClass shape = new AbstractClass();
        shape.draw();
    }
}

1.7 包与命名空间

1.7.1 包定义 (`package`)

功能：组织类文件。
使用场景：避免命名冲突。
底层原理：对应文件系统目录。
注意事项：包名小写。

示例代码：

package mypackage;
public class PackageDemo {
    public static void main(String[] args) {
        System.out.println("In mypackage");
    }
}

1.7.2 导入 (`import`)

功能：引用其他包的类。
使用场景：使用标准库或第三方类。
底层原理：编译时解析类路径。
注意事项：避免使用 * 影响性能。

示例代码：

import java.util.ArrayList;
public class ImportDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        System.out.println(list);
    }
}

1.8 异常处理

1.8.1 `try`, `catch`, `finally`

功能：捕获和处理异常。
使用场景：错误处理。
底层原理：JVM 异常表跳转。
注意事项：finally 总是执行。

示例代码：

public class TryCatch {
    public static void main(String[] args) {
        try {
            int x = 1 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            System.out.println("Done");
        }
    }
}

1.8.2 `throw`, `throws`

功能：抛出异常或声明异常。
使用场景：自定义错误。
底层原理：JVM 异常栈追踪。
注意事项：throws 在方法签名。

示例代码：

public class ThrowDemo {
    static void check(int x) throws Exception {
        if (x < 0) throw new Exception("Negative");
    }
    public static void main(String[] args) {
        try {
            check(-1);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

1.8.3 自定义异常

功能：定义特定异常类型。
使用场景：业务逻辑错误。
底层原理：继承 Exception 或 RuntimeException。
注意事项：提供有意义的错误信息。

示例代码：

class MyException extends Exception {
    MyException(String msg) { super(msg); }
}
public class CustomException {
    public static void main(String[] args) {
        try {
            throw new MyException("Custom error");
        } catch (MyException e) {
            System.out.println(e.getMessage());
        }
    }
}

1.9 泛型

1.9.1 泛型类

功能：类型参数化。
使用场景：通用数据结构。
底层原理：类型擦除，编译时替换为 Object。
注意事项：不能用基本类型。

示例代码：

class Box<T> {
    private T value;
    Box(T value) { this.value = value; }
    T getValue() { return value; }
}
public class GenericClass {
    public static void main(String[] args) {
        Box<Integer> box = new Box<>(123);
        System.out.println(box.getValue());
    }
}

1.9.2 泛型方法

功能：方法级类型参数。
使用场景：灵活处理类型。
底层原理：编译时推导类型。
注意事项：类型参数在方法签名。

示例代码：

public class GenericMethod {
    static <T> void print(T item) {
        System.out.println(item);
    }
    public static void main(String[] args) {
        print("Hello");
        print(42);
    }
}

1.9.3 通配符 (`?`, `extends`, `super`)

功能：限制泛型范围。
使用场景：处理未知类型或上下界。
底层原理：编译时类型检查。
注意事项：extends 用于读取，super 用于写入。

示例代码：

import java.util.ArrayList;
public class Wildcards {
    static void printList(ArrayList<? extends Number> list) {
        for (Number n : list) System.out.println(n);
    }
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        printList(list);
    }
}

1.10 动态内存管理

1.10.1 `new`

功能：分配对象内存。
使用场景：创建对象。
底层原理：JVM 在堆上分配，垃圾回收管理。
注意事项：无需手动释放。

示例代码：

public class NewOperator {
    public static void main(String[] args) {
        String str = new String("Hello");
        System.out.println(str);
    }
}

1.11 注解

1.11.1 内置注解 (`@Override`, `@Deprecated`)

功能：提供元数据。
使用场景：标记方法覆盖、废弃。
底层原理：编译器或运行时处理。
注意事项：@Override 确保签名正确。

示例代码：

public class BuiltInAnnotations {
    @Override
    public String toString() { return "Overridden"; }
    @Deprecated
    static void oldMethod() { System.out.println("Old"); }
    public static void main(String[] args) {
        System.out.println(new BuiltInAnnotations());
    }
}

1.11.2 自定义注解

功能：定义特定元数据。
使用场景：框架开发。
底层原理：反射读取注解。
注意事项：需指定保留策略。

示例代码：

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String value();
}
@MyAnnotation(value = "Test")
public class CustomAnnotation {
    public static void main(String[] args) {
        System.out.println("Annotated");
    }
}

2. 现代 Java 新特性

2.1 Java 8

2.1.1 Lambda 表达式

功能：简化函数式编程。
使用场景：替代匿名类。
底层原理：编译为 invokedynamic 指令。
注意事项：需配合函数式接口。

示例代码：

interface MyFunc { void run(); }
public class LambdaDemo {
    public static void main(String[] args) {
        MyFunc func = () -> System.out.println("Lambda");
        func.run();
    }
}

2.1.2 函数式接口 (`@FunctionalInterface`)

功能：标记单一抽象方法的接口。
使用场景：Lambda 的目标类型。
底层原理：编译器检查方法数量。
注意事项：只能有一个抽象方法。

示例代码：

@FunctionalInterface
interface MyFunc { void run(); }
public class FunctionalInterfaceDemo {
    public static void main(String[] args) {
        MyFunc func = () -> System.out.println("Running");
        func.run();
    }
}

2.1.3 Stream API

功能：流式处理集合。
使用场景：数据过滤、映射。
底层原理：管道操作，延迟执行。
注意事项：流只能使用一次。

示例代码：

import java.util.Arrays;
public class StreamDemo {
    public static void main(String[] args) {
        Arrays.asList(1, 2, 3).stream()
              .filter(x -> x > 1)
              .forEach(System.out::println);
    }
}

2.1.4 Optional 类

功能：处理可能为空的值。
使用场景：避免 NullPointerException。
底层原理：封装对象引用。
注意事项：不要用 get() 直接取值。

示例代码：

import java.util.Optional;
public class OptionalDemo {
    public static void main(String[] args) {
        Optional<String> opt = Optional.ofNullable(null);
        System.out.println(opt.orElse("Default"));
    }
}

2.1.5 默认方法 (`default`)

功能：接口中提供默认实现。
使用场景：扩展接口功能。
底层原理：编译为普通方法。
注意事项：多接口冲突需显式覆盖。

示例代码：

interface MyInterface {
    default void defaultMethod() { System.out.println("Default"); }
}
public class DefaultMethod implements MyInterface {
    public static void main(String[] args) {
        new DefaultMethod().defaultMethod();
    }
}

2.1.6 静态方法 (接口中 `static`)

功能：接口中的工具方法。
使用场景：接口相关工具。
底层原理：与类静态方法相同。
注意事项：不能被实现类继承。

示例代码：

interface MyInterface {
    static void staticMethod() { System.out.println("Static"); }
}
public class StaticMethod {
    public static void main(String[] args) {
        MyInterface.staticMethod();
    }
}

2.1.7 方法引用 (`::`)

功能：简化 Lambda。
使用场景：引用已有方法。
底层原理：编译为 Lambda 表达式。
注意事项：方法签名需匹配。

示例代码：

import java.util.Arrays;
public class MethodReference {
    public static void main(String[] args) {
        Arrays.asList("a", "b").forEach(System.out::println);
    }
}

2.1.8 日期时间 API (`java.time`)

功能：处理日期和时间。
使用场景：时间计算、格式化。
底层原理：基于 ISO 8601 标准。
注意事项：线程安全，替代 Date。

示例代码：

import java.time.LocalDate;
public class DateTime {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        System.out.println(date);
    }
}

2.2 Java 9

2.2.1 模块化 (`module-info.java`)

功能：封装模块，控制依赖。
使用场景：大型项目管理。
底层原理：JVM 加载模块描述符。
注意事项：需配置模块路径。

示例代码：

// module-info.java
module mymodule {
    requires java.base;
    exports mypackage;
}
// mypackage/MyClass.java
package mypackage;
public class MyClass {
    public static void main(String[] args) {
        System.out.println("Module demo");
    }
}

2.2.2 私有接口方法

功能：接口中私有实现。
使用场景：复用接口代码。
底层原理：编译为私有方法。
注意事项：仅接口内部使用。

示例代码：

interface MyInterface {
    default void method() { privateMethod(); }
    private void privateMethod() { System.out.println("Private"); }
}
public class PrivateInterface implements MyInterface {
    public static void main(String[] args) {
        new PrivateInterface().method();
    }
}

2.2.3 `try-with-resources` 改进

功能：简化资源管理。
使用场景：文件、连接关闭。
底层原理：自动调用 close()。
注意事项：资源需实现 AutoCloseable。

示例代码：

import java.io.*;
public class TryWithResources {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new StringReader("Hello"));
        try (br) {
            System.out.println(br.readLine());
        }
    }
}

2.2.4 集合工厂方法 (`List.of()`)

功能：创建不可变集合。
使用场景：快速初始化。
底层原理：返回不可变实现。
注意事项：不可修改。

示例代码：

import java.util.List;
public class CollectionFactory {
    public static void main(String[] args) {
        List<String> list = List.of("A", "B");
        System.out.println(list);
    }
}

2.3 Java 10

2.3.1 局部变量类型推导 (`var`)

功能：自动推导变量类型。
使用场景：简化代码。
底层原理：编译时确定类型。
注意事项：仅限局部变量。

示例代码：

public class VarDemo {
    public static void main(String[] args) {
        var x = 10; // int
        var list = new java.util.ArrayList<String>();
        list.add("Hello");
        System.out.println(x + " " + list);
    }
}

2.4 Java 11

2.4.1 字符串增强 (`strip()`, `lines()`)

功能：增强字符串操作。
使用场景：文本处理。
底层原理：基于 String 内部数组。
注意事项：strip() 支持 Unicode 空白。

示例代码：

public class StringEnhance {
    public static void main(String[] args) {
        String text = "  Hello\nWorld  ";
        System.out.println(text.strip());
        text.lines().forEach(System.out::println);
    }
}

2.4.2 HTTP Client API

功能：发送 HTTP 请求。
使用场景：网络通信。
底层原理：基于 NIO。
注意事项：支持异步请求。

示例代码：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class HttpClientDemo {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://example.com"))
                .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body().substring(0, 50));
    }
}

2.5 Java 14

2.5.1 Switch 表达式

功能：Switch 返回值。
使用场景：简化多分支。
底层原理：编译为条件跳转。
注意事项：需覆盖所有情况。

示例代码：

public class SwitchExpression {
    public static void main(String[] args) {
        int day = 2;
        String result = switch (day) {
            case 1 -> "Monday";
            case 2 -> "Tuesday";
            default -> "Unknown";
        };
        System.out.println(result);
    }
}

2.5.2 `instanceof` 模式匹配

功能：类型检查并转换。
使用场景：简化类型处理。
底层原理：编译器优化类型检查。
注意事项：变量作用域限于条件。

示例代码：

public class InstanceofPattern {
    public static void main(String[] args) {
        Object obj = "Hello";
        if (obj instanceof String s) System.out.println(s);
    }
}

2.6 Java 15

2.6.1 文本块 (`"""..."""`)

功能：多行字符串。
使用场景：HTML、SQL。
底层原理：编译为单行字符串。
注意事项：自动去除缩进。

示例代码：

public class TextBlock {
    public static void main(String[] args) {
        String html = """
            <html>
                <body>Hello</body>
            </html>
            """;
        System.out.println(html);
    }
}

2.7 Java 17

2.7.1 密封类 (`sealed`, `permits`)

功能：限制继承。
使用场景：控制类层次。
底层原理：编译器检查继承。
注意事项：子类需声明 final 或 sealed。

示例代码：

sealed interface Shape permits Circle {}
final class Circle implements Shape {}
public class SealedClass {
    public static void main(String[] args) {
        Shape shape = new Circle();
        System.out.println(shape instanceof Circle);
    }
}

2.7.2 模式匹配 Switch (预览)

功能：增强 Switch 类型匹配。
使用场景：复杂条件处理。
底层原理：编译器模式分析。
注意事项：需启用预览特性。

示例代码：

public class SwitchPattern {
    public static void main(String[] args) {
        Object obj = "Hello";
        String result = switch (obj) {
            case String s -> "String: " + s;
            default -> "Other";
        };
        System.out.println(result);
    }
}

2.8 Java 21

2.8.1 虚拟线程

功能：轻量级线程。
使用场景：高并发任务。
底层原理：JVM 调度器管理。
注意事项：需 JDK 21。

示例代码：

public class VirtualThread {
    public static void main(String[] args) throws Exception {
        Thread vThread = Thread.startVirtualThread(() -> {
            System.out.println("Virtual thread");
        });
        vThread.join();
    }
}

2.8.2 结构化并发

功能：管理并发任务。
使用场景：多任务协调。
底层原理：基于 StructuredTaskScope。
注意事项：需 JDK 21。

示例代码：

import java.util.concurrent.StructuredTaskScope;
public class StructuredConcurrency {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            scope.fork(() -> { System.out.println("Task 1"); return null; });
            scope.join();
        }
    }
}

2.8.3 记录模式匹配

功能：解构记录。
使用场景：简化数据处理。
底层原理：编译器模式匹配。
注意事项：需 JDK 21。

示例代码：

record Point(int x, int y) {}
public class RecordPattern {
    public static void main(String[] args) {
        Object obj = new Point(1, 2);
        if (obj instanceof Point(int x, int y)) {
            System.out.println("x: " + x + ", y: " + y);
        }
    }
}

3. 其他特性

3.1 标准库扩展

3.1.1 集合框架 (`List`, `Map`, `Set`)

功能：管理动态数据。
使用场景：数据存储、查询。
底层原理：基于数组或链表。
注意事项：选择合适的实现类。

示例代码：

import java.util.ArrayList;
public class CollectionsDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        System.out.println(list);
    }
}

3.1.2 输入输出 (`java.io`, `java.nio`)

功能：文件和流操作。
使用场景：读写文件、网络。
底层原理：基于 OS 文件系统。
注意事项：关闭资源。

示例代码：

import java.io.*;
public class IODemo {
    public static void main(String[] args) throws IOException {
        FileWriter writer = new FileWriter("test.txt");
        writer.write("Hello");
        writer.close();
    }
}

3.1.3 并发库 (`java.util.concurrent`)

功能：多线程支持。
使用场景：并发任务。
底层原理：线程池、锁机制。
注意事项：避免死锁。

示例代码：

import java.util.concurrent.*;
public class ConcurrentDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(() -> System.out.println("Task"));
        executor.shutdown();
    }
}

3.1.4 字符串 (`String`, `StringBuilder`)

功能：处理文本。
使用场景：字符串操作。
底层原理：String 不可变，StringBuilder 可变。
注意事项：频繁拼接用 StringBuilder。

示例代码：

public class StringDemo {
    public static void main(String[] args) {
        String str = "Hello";
        StringBuilder sb = new StringBuilder("World");
        sb.append("!");
        System.out.println(str + " " + sb);
    }
}

3.2 编译器与运行时

3.2.1 JVM (垃圾回收)

功能：自动内存管理。
使用场景：运行 Java 程序。
底层原理：标记-清除、分代回收。
注意事项：调优 GC 参数。

示例代码：

public class JVMDemo {
    public static void main(String[] args) {
        String s = new String("Temp");
        s = null; // 可被 GC 回收
        System.gc(); // 建议 GC
        System.out.println("Running");
    }
}

3.2.2 反射 (`java.lang.reflect`)

功能：运行时检查类信息。
使用场景：框架开发。
底层原理：JVM 元数据。
注意事项：性能开销大。

示例代码：

import java.lang.reflect.Method;
public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        Class<?> cls = String.class;
        Method[] methods = cls.getMethods();
        for (Method m : methods) System.out.println(m.getName());
    }
}

语法树

详解

1. 基础语法特性 (Java SE 1.0-7)

1.1 基本数据类型

1.1.1 整型 (byte, short, int, long)

1.1.2 浮点型 (float, double)

1.1.3 字符型 (char)

1.1.4 布尔型 (boolean)

1.2 变量与常量

1.2.1 变量声明与定义

1.2.2 常量 (final)

1.3 运算符

1.3.1 算术运算符 (+, -, *, /, %)

1.3.2 关系运算符 (==, !=, <, >, <=, >=)

1.3.3 逻辑运算符 (&&, ||, !)

1.3.4 位运算符 (&, |, ^, ~, <<, >>, >>>)

1.3.5 赋值运算符 (=, +=, -=, *=, /=, %=)

1.3.6 其他运算符 (instanceof, ?:)

1.4 控制结构

1.4.1 条件语句 (if, else)

1.4.2 开关语句 (switch, case)

1.4.3 循环 (for, while, do-while)

1.4.4 跳转 (break, continue, return)

1.5 函数与方法

1.5.1 方法定义与调用

1.5.2 参数传递 (值传递)

1.5.3 方法重载

1.6 类与对象

1.6.1 类定义 (class)

1.6.2 访问控制 (public, private, protected)

1.6.3 构造函数

1.6.4 静态成员 (static)

1.6.5 继承 (extends)

1.6.6 多态性 (@Override)

1.6.7 接口 (interface)

1.6.8 抽象类 (abstract)

1.7 包与命名空间

1.7.1 包定义 (package)

1.7.2 导入 (import)

1.8 异常处理

1.8.1 try, catch, finally

1.8.2 throw, throws

1.8.3 自定义异常

1.9 泛型

1.9.1 泛型类

1.9.2 泛型方法

1.9.3 通配符 (?, extends, super)

1.10 动态内存管理

1.10.1 new

1.11 注解

1.11.1 内置注解 (@Override, @Deprecated)

1.11.2 自定义注解

2. 现代 Java 新特性

2.1 Java 8

2.1.1 Lambda 表达式

2.1.2 函数式接口 (@FunctionalInterface)

2.1.3 Stream API

2.1.4 Optional 类

2.1.5 默认方法 (default)

2.1.6 静态方法 (接口中 static)

2.1.7 方法引用 (::)

2.1.8 日期时间 API (java.time)

2.2 Java 9

2.2.1 模块化 (module-info.java)

2.2.2 私有接口方法

2.2.3 try-with-resources 改进

2.2.4 集合工厂方法 (List.of())

2.3 Java 10

2.3.1 局部变量类型推导 (var)

2.4 Java 11

2.4.1 字符串增强 (strip(), lines())

2.4.2 HTTP Client API

2.5 Java 14

2.5.1 Switch 表达式

2.5.2 instanceof 模式匹配

2.6 Java 15

2.6.1 文本块 ("""...""")

2.7 Java 17

2.7.1 密封类 (sealed, permits)

2.7.2 模式匹配 Switch (预览)

1.1.1 整型 (`byte`, `short`, `int`, `long`)

1.1.2 浮点型 (`float`, `double`)

1.1.3 字符型 (`char`)

1.1.4 布尔型 (`boolean`)

1.2.2 常量 (`final`)

1.3.1 算术运算符 (`+`, `-`, `*`, `/`, `%`)

1.3.2 关系运算符 (`==`, `!=`, `<`, `>`, `<=`, `>=`)

1.3.3 逻辑运算符 (`&&`, `||`, `!`)

1.3.4 位运算符 (`&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`)

1.3.5 赋值运算符 (`=`, `+=`, `-=`, `*=`, `/=`, `%=`)

1.3.6 其他运算符 (`instanceof`, `?:`)

1.4.1 条件语句 (`if`, `else`)

1.4.2 开关语句 (`switch`, `case`)

1.4.3 循环 (`for`, `while`, `do-while`)

1.4.4 跳转 (`break`, `continue`, `return`)

1.6.1 类定义 (`class`)

1.6.2 访问控制 (`public`, `private`, `protected`)

1.6.4 静态成员 (`static`)

1.6.5 继承 (`extends`)

1.6.6 多态性 (`@Override`)

1.6.7 接口 (`interface`)

1.6.8 抽象类 (`abstract`)

1.7.1 包定义 (`package`)

1.7.2 导入 (`import`)

1.8.1 `try`, `catch`, `finally`

1.8.2 `throw`, `throws`

1.9.3 通配符 (`?`, `extends`, `super`)

1.10.1 `new`

1.11.1 内置注解 (`@Override`, `@Deprecated`)

2.1.2 函数式接口 (`@FunctionalInterface`)

2.1.5 默认方法 (`default`)

2.1.6 静态方法 (接口中 `static`)

2.1.7 方法引用 (`::`)

2.1.8 日期时间 API (`java.time`)

2.2.1 模块化 (`module-info.java`)

2.2.3 `try-with-resources` 改进

2.2.4 集合工厂方法 (`List.of()`)

2.3.1 局部变量类型推导 (`var`)

2.4.1 字符串增强 (`strip()`, `lines()`)

2.5.2 `instanceof` 模式匹配

2.6.1 文本块 (`"""..."""`)

2.7.1 密封类 (`sealed`, `permits`)

3.1.1 集合框架 (`List`, `Map`, `Set`)

3.1.2 输入输出 (`java.io`, `java.nio`)

3.1.3 并发库 (`java.util.concurrent`)

3.1.4 字符串 (`String`, `StringBuilder`)

3.2.2 反射 (`java.lang.reflect`)