Java 语法与类型

先弄清代码怎么跑起来、值怎么存进变量，再看类型系统保证了什么。语法层的绝大多数“怪事”——1 + 2 + "3" 为什么等于 "33"、两个 Integer 比较为什么不一定相等——都能用值、引用和类型提升这三件事解释清楚。

一、编译执行与版本边界

Java 编译分两步：javac 把 .java 源文件编译成 .class 字节码，java 再由虚拟机加载执行。字节码不绑定具体操作系统，这是“一次编译，到处运行”的来源。

--release 21 不只是加一个编译参数：它同时锁定“语言特性 + 目标字节码版本 + 标准库 API”。只写 -source 21 而不写 --release，代码能编译却可能调用到目标运行时不存在的 API，编译期不报错、运行期才炸。

java single-file.java          // 单文件直接运行
jshell                        // 交互式
javac --release 21 App.java   // 正式构建

提示：IDEA 里能跑不等于构建能过。IDE 可能用了更高版本的 JDK，正式构建往往锁在 --release 指定的版本上，差异就出现在这里。

二、基本类型与取值范围

8 种基本类型占住了最常用的数值区间。选型的直觉很简单：够用就好，不必随手用最大的。

字面量后缀决定它落到哪个类型：整数默认 int，10L 才是 long；小数默认 double，1.5f 才是 float。

int i = 10;        // int
long n = 10;       // 仍然 int，赋值时提升为 long
long big = 10L;    // 明确 long
float f = 1.5f;    // 明确 float
double d = 1.5;    // double

宽类型可以隐式放进窄类型，反方向必须显式强转，且可能溢出：

long big = 300L;
int small = (int) big;   // 300

double avg = 34.9;
int truncated = (int) avg;  // 34，直接截断小数，不是四舍五入

警告：float/double 是二进制近似表示，0.1 + 0.2 不精确等于 0.3。金额、计量这类要求十进制精确的场景必须用 BigDecimal，不能用 double 硬扛。

三、变量、包装类与自动装箱

变量在声明时就有确定的存储形式：基本类型变量直接保存值，引用类型变量保存对对象的引用。8 种基本类型各有一个对应的包装类，把“值”包装成“对象”。

包装类存在的三个理由：集合与泛型只能装对象（List<int> 非法，要写 List<Integer>）、提供 parseInt/isDigit/isNaN 等工具方法、对象引用可以是 null 而基本类型变量不能。

自动装箱与拆箱让语法上不必手写转换，底层走的是 valueOf 与 intValue：

List<Integer> numbers = new ArrayList<>();
numbers.add(10);           // 装箱：int → Integer
int first = numbers.get(0); // 拆箱：Integer → int

char letter = 'A';
int code = letter;              // 65，char 底层是码点
char next = (char) (letter + 1);// 'B'

Integer.valueOf 会复用 −128 ~ 127 的缓存对象，这带来一个必须记住的陷阱：

Integer a = 127;
Integer b = Integer.valueOf(127);
Integer x = 128;
Integer y = Integer.valueOf(128);

a == b   // true，命中缓存
x == y   // false，缓存范围外是不同对象
x.equals(y) // true，内容相同

警告：比较数值是否相同一律用 equals（或先拆箱再比较），不要依赖 == 是否碰巧命中缓存。字符串转整数用 Integer.parseInt("42")，需要对象时才用 Integer.valueOf("42")，new Integer("42") 已废弃。

final 修饰变量后只能赋值一次；var 让编译器推断局部变量类型，声明处必须能从右值推出具体类型，不能用于字段、参数或无初始化的声明。

四、字符串、相等性与常量池

String 是不可变类——concat、toUpperCase、trim、replace 都返回新串，原串不变。这条性质换来三件事：字符串能安全地跨线程共享；能安全地作为 Map 键；相同字面量能共享同一个对象。

+ 是唯一“运算符”级别的字符串操作，规则是从左向右求值，一旦有一侧是 String 就转为拼接：

1 + 2            // 3
"1" + 2          // "12"
1 + 2 + "3"      // "33"，先算出 3 再拼接
"value=" + 20 + 20 // "value=2020"
"value=" + (20 + 20) // "value=40"

不可变加上常量池机制，让相同内容的字面量共享对象：

String a = "hello";
String b = "hello";
String c = new String("hello");
String d = c.intern();

a == b          // true，字面量复用池中同一对象
a == c          // false，new 明确要求再创建一个
a.equals(c)     // true，内容相同
a == d          // true，intern 返回池中该内容的规范引用

intern() 准确说是“返回常量池中与该内容对应的规范引用”，而不是把 new 出来的对象搬进池。业务上比较内容一律用 equals，== 只回答“是不是同一个对象”。

常用方法按用途分组记忆，比逐个背 API 更快：

注意：索引从 0 开始，substring(begin, end) 的 end 不包含在内——"abcdef".substring(1, 3) 得到 "bc"。越界访问抛 StringIndexOutOfBoundsException 而非返回 null。

多行文本用文本块（Java 15）比手写 \n 和转义清晰，三个双引号后必须换行：

String sql = """
        SELECT id, name
        FROM users
        WHERE active = true
        """;

五、流程控制

条件分支从 if 走向“取值更安全”的形态：

int score = 85;
String grade = switch (score / 10) {
    case 10, 9 -> "A";
    case 8 -> "B";
    case 7 -> "C";
    default -> "D";
};

传统 switch 靠每个分支末尾的 break 防贯穿，漏写一个 break 就会意外执行下一个分支。switch 表达式（Java 14 正式定稿）没有贯穿风险，多个值用逗号并列，分支逻辑复杂时用代码块加 yield 返回结果。

循环三兄弟按用途选：

int n = 5;
int factorial = 1;
for (int i = 1; i <= n; i++) factorial *= i; // 120

for 循环体里声明的 i 作用域仅限循环内，循环结束就不可见——刻意限制变量泄漏。

循环最常见的错误是差一（off-by-one）：

for (int i = 0; i <= 5; i++)  // 6 次
for (int i = 0; i < 5; i++)   // 5 次

六、方法与重载

方法把一段操作命名并收口，签名 = 返回类型不算在内的“方法名 + 形参列表”。重载发生在编译期：编译器按实参的类型和数量挑选最匹配的版本。

static int sum(int a, int b)          { return a + b; }
static double sum(double a, double b) { return a + b; }
static long sum(long a, long b, long c) { return a + b + c; }

重载三不原则：不靠返回值重载（int f() 与 void f() 无法共存）、参数列表必须真的不同、选择歧义时要显式转型。

可变参数（varargs）让方法接受零个或多个同类型实参，方法内部就是一个数组：

static int sum(int... numbers) {
    int total = 0;
    for (int number : numbers) total += number;
    return total;
}
sum();          // 0
sum(1, 2, 3);   // 6

注意：可变参数必须是签名中最后一个参数，一个方法只能有一个；传 null 时编译器会警告“可能传成了数组”，这时应加 (int[]) null 明确表达。

断言用来验证开发阶段的假设，默认不启用，需 -ea 打开：

assert score >= 0 && score <= 100 : "score out of range: " + score;

七、数组

数组是定长的连续存储容器：创建后长度不能改，元素类型统一，访问快。长度是字段 length，不是方法——这和字符串的 length() 正好相反：

int[] marks = {97, 98, 100};
marks.length        // 3，字段
"abc".length()      // 3，方法

数组不能直接打印成内容，要用工具方法：

int[] bigger = Arrays.copyOf(marks, 5);  // 多出的位置为 0
System.out.println(Arrays.toString(marks)); // [97, 98, 100]

int[][] matrix = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(matrix)); // [[1, 2], [3, 4]]

数组默认值：数值类型为 0（浮点 0.0）、boolean 为 false、对象引用为 null。

注意：Java 只有值传递。方法收到数组参数时复制的是引用，所以改元素会影响调用者，而给形参重新指向新数组不会。

static void mutate(int[] values) { values[0] = 99; }        // 调用者能看到 99
static void replaceRef(int[] values) { values = new int[3]; } // 调用者不受影响

八、关键字与访问控制

final 三种用法含义不同：final 变量只能赋值一次；final 方法子类不能重写（但可重载）；final 类不能被继承。

abstract 声明抽象方法（只有签名没有实现）并禁止实例化；抽象类可以带字段、构造器和具体方法，适合做模板。

访问控制从宽到严：

警告：包访问不等于“包及其子包”，这是最常被记错的一条。子类访问 protected 成员也受限制，只能在继承语境中访问，不能拿一个外部任意 Animal 引用去取 protected 字段。

this 指当前对象，this(...) 委托同类的另一个构造器，this.field 访问当前对象字段；super 指直接父类，super(...) 调父类构造器，super.method() 调父类实现。super(...) 必须是构造器第一条显式构造调用。

九、枚举与 Record

enum 是一种受限制的类型：只有列出的常量合法，编译器负责挡住拼错和魔法字符串。它还能带字段、构造器、getter 和业务方法。

enum Direction {
    NORTH("up"), SOUTH("down"), EAST("right"), WEST("left");

    private final String movement;

    Direction(String movement) { this.movement = movement; }

    public String getMovement() { return movement; }

    public Direction opposite() {
        return switch (this) {
            case NORTH -> SOUTH;
            case SOUTH -> NORTH;
            case EAST -> WEST;
            case WEST -> EAST;
        };
    }
}

枚举上有 switch 时可以做穷举处理，新增常量编译器会提醒漏掉的分支。面向枚举的集合用 EnumSet（内部按位向量实现，运算快，但不能放 null），键是枚举的映射用 EnumMap。

警告：不要把 ordinal() 当作永久业务编号。枚举顺序一调整，所有序号都变，库里存下来的旧数据会全部失真。需要稳定编号就自己给常量加一个 value 字段。

record（Java 16 引入）用来表达不可变数据载体，编译器自动生成规范构造器、访问器（name() 而非 getName()）、equals、hashCode 和 toString：

record User(String name, String email) {
    User {  // 紧凑构造器，做校验
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("name is required");
        }
    }
}

注意：record 不能继承普通类、不能有额外实例字段，适合 DTO 与值对象，不适合需要可变状态的领域对象。

十、易错点总表

把编译路径、取值范围、引用语义和访问边界想在前，语法层的错误大多不会发生；真正的复杂度总在集合、多态边界和并发上。