Java关键字详解：从基础到高级应用-代码聚汇网

1. Java关键字概述

在Java编程语言中，关键字（Keywords）是具有特殊含义的保留字，这些单词被Java语言赋予了特定的语法功能。作为Java语言的基础构建块，关键字构成了程序的控制结构、数据类型定义、访问控制等核心功能。与标识符不同，关键字不能用作变量名、方法名或任何其他用户自定义的名称。

Java关键字的特点包括：

全部由小写字母组成
在IDE中通常以特殊颜色高亮显示
数量固定（根据Java版本不同略有变化）
每个关键字都有明确的语法含义

注意：从Java 8到Java 17，关键字集合基本保持稳定，但某些版本会引入上下文相关的限制关键字（如var），这些虽然不是严格意义上的关键字，但在特定上下文中具有特殊含义。

2. Java关键字的分类与详解

2.1 访问控制关键字

访问控制关键字用于定义类、变量、方法的可见性范围：

public：最大访问权限，任何类都可以访问

java复制public class Main {
    public int count;  // 任何类都可访问
}

protected：包内可见 + 子类可见

java复制protected void show() {  // 同包或子类可访问
    System.out.println("Protected method");
}

private：最小访问权限，仅本类可见

java复制private String secret;  // 只有当前类能访问

default（隐式，无实际关键字）：包级私有

java复制class PackagePrivate {  // 不加修饰符即为default
    int value;         // 同包内可见
}

2.2 类、方法和变量修饰符

这些关键字用于定义类和成员的属性：

class：定义类

java复制class Student {  // 类声明
    // 类体
}

interface：定义接口

java复制interface Drawable {  // 接口声明
    void draw();
}

enum：定义枚举类型

java复制enum Color {  // 枚举定义
    RED, GREEN, BLUE
}

abstract：抽象类/方法

java复制abstract class Shape {  // 抽象类
    abstract void area();  // 抽象方法
}

final：不可修改/继承

java复制final class MathUtils {  // 不可继承的类
    final double PI = 3.14;  // 常量
}

static：类级别成员

java复制class Counter {
    static int count;  // 类变量
    static void increment() {  // 类方法
        count++;
    }
}

synchronized：线程同步

java复制synchronized void update() {  // 同步方法
    // 线程安全代码
}

volatile：易变变量（保证可见性）

java复制volatile boolean running = true;  // 多线程可见

transient：不被序列化

java复制transient String tempData;  // 序列化时忽略

native：本地方法

java复制native void systemCall();  // 由本地代码实现

strictfp：严格浮点计算

java复制strictfp class Calculator {  // 严格浮点运算
    // 类体
}

2.3 流程控制关键字

控制程序执行流程的关键字：

if-else：条件判断

java复制if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

switch-case-default：多分支选择

java复制switch (day) {
    case 1: System.out.println("周一"); break;
    case 2: System.out.println("周二"); break;
    default: System.out.println("其他");
}

for：循环结构

java复制for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

while：循环结构

java复制while (condition) {
    // 循环体
}

do-while：循环结构

java复制do {
    // 至少执行一次
} while (condition);

break：跳出循环/switch

java复制while (true) {
    if (exit) break;  // 跳出循环
}

continue：跳过本次循环

java复制for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) continue;  // 跳过偶数
    System.out.println(i);
}

return：方法返回值

java复制int add(int a, int b) {
    return a + b;  // 返回结果
}

2.4 异常处理关键字

Java异常处理机制相关关键字：

try-catch-finally：异常捕获

java复制try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 异常处理
} finally {
    // 最终执行
}

throw：抛出异常

java复制if (value < 0) {
    throw new IllegalArgumentException("不能为负");
}

throws：声明可能抛出的异常

java复制void readFile() throws IOException {
    // 方法可能抛出IOException
}

2.5 包相关关键字

package：定义包

java复制package com.example.util;  // 包声明

import：导入包/类

java复制import java.util.List;  // 导入单个类
import java.util.*;     // 导入整个包

2.6 类型相关关键字

boolean：布尔类型

java复制boolean flag = true;  // 只能是true/false

byte：字节类型

java复制byte b = 127;  // 8位有符号整数

char：字符类型

java复制char c = 'A';  // 16位Unicode字符

double：双精度浮点
```
java复制double d = 3.1415926;
```

float：单精度浮点

java复制float f = 3.14f;  // 需要f后缀

int：整型
```
java复制int count = 100;
```

long：长整型

java复制long bigNum = 10000000000L;  // 需要L后缀

short：短整型

java复制short s = 32767;  // 16位有符号整数

void：无返回值

java复制void print() {  // 无返回值方法
    System.out.println("Hello");
}

var（Java 10+）：局部变量类型推断

java复制var list = new ArrayList<String>();  // 自动推断为ArrayList<String>

2.7 面向对象相关关键字

new：创建对象实例

java复制String s = new String("Hello");

this：当前对象引用

java复制class Person {
    String name;
    Person(String name) {
        this.name = name;  // 区分成员变量和参数
    }
}

super：父类引用

java复制class Student extends Person {
    Student() {
        super("默认");  // 调用父类构造器
    }
}

instanceof：类型检查

java复制if (obj instanceof String) {
    String s = (String) obj;
}

extends：类继承

java复制class Animal {}
class Dog extends Animal {}  // Dog继承Animal

implements：接口实现

java复制class Runner implements Runnable {  // 实现Runnable接口
    public void run() {}
}

2.8 其他特殊关键字

assert（Java 4+）：断言

java复制assert x > 0 : "x必须为正数";  // 调试时验证条件

const（保留未使用）：Java中不使用

java复制// const在Java中无效，应使用final

goto（保留未使用）：Java中不使用

java复制// goto在Java中无效，会引发编译错误

3. Java关键字的使用技巧与陷阱

3.1 关键字的正确使用

final关键字的三种用法：
- final变量：常量，不可修改
- final方法：不可重写
- final类：不可继承

static的最佳实践：

java复制class Utility {
    // 工具方法设为static
    static int max(int a, int b) {
        return a > b ? a : b;
    }
    
    // 静态初始化块
    static {
        // 类加载时执行的代码
    }
}

enum的高级用法：

java复制enum Operation {
    ADD { double apply(double x, double y) { return x + y; } },
    SUBTRACT { double apply(double x, double y) { return x - y; } };
    
    abstract double apply(double x, double y);
}

3.2 常见陷阱与规避方法

switch的穿透问题：

java复制switch (x) {
    case 1:
        System.out.println("1");
        // 缺少break会继续执行case 2
    case 2:
        System.out.println("2");
        break;
}

提示：Java 12+可以使用switch表达式避免此问题

浮点数比较陷阱：

java复制float f1 = 0.1f;
float f2 = 0.2f;
if (f1 + f2 == 0.3f) {  // 可能不成立
    // 应使用Math.abs(f1 + f2 - 0.3f) < EPSILON
}

自动装箱拆箱的NPE：

java复制Integer i = null;
int j = i;  // 运行时NullPointerException

finally块的执行时机：

java复制try {
    return 1;  // 先计算返回值
} finally {
    return 2;  // 最终返回2，覆盖之前的返回值
}

4. Java版本演进中的关键字变化

4.1 Java 5新增特性

enum关键字：

java复制// Java 5之前使用public static final常量模拟枚举
public static final int RED = 1;
public static final int GREEN = 2;

// Java 5引入真正的枚举类型
enum Color { RED, GREEN, BLUE }

注解相关关键字：
- @Override
- @Deprecated
- @SuppressWarnings

4.2 Java 8新增特性

default方法（接口中）：

java复制interface Vehicle {
    default void print() {  // 接口默认方法
        System.out.println("我是一辆车");
    }
}

static方法（接口中）：

java复制interface MathOps {
    static int add(int a, int b) {  // 接口静态方法
        return a + b;
    }
}

4.3 Java 10+新增特性

var局部变量类型推断：

java复制var list = new ArrayList<String>();  // 自动推断为ArrayList<String>
var stream = list.stream();          // 自动推断为Stream<String>

注意：var只能用于局部变量，不能用于字段、方法参数或返回类型

4.4 Java 14+新增特性

record关键字（简化数据类）：

java复制record Point(int x, int y) {  // 自动生成构造器、getter等
    // 可以添加额外方法
    public double distance() {
        return Math.sqrt(x*x + y*y);
    }
}

sealed关键字（限制继承）：

java复制public sealed class Shape  // 只能被指定类继承
    permits Circle, Square, Rectangle {
    // 类定义
}

5. 关键字在面试中的常见问题

5.1 基础概念问题

final、finally、finalize的区别：
- final：修饰符，表示不可变
- finally：异常处理块，保证执行
- finalize：Object类的方法，垃圾回收前调用
static关键字的四种用法：
- 静态变量
- 静态方法
- 静态代码块
- 静态内部类
volatile和synchronized的区别：
- volatile保证可见性，不保证原子性
- synchronized保证可见性和原子性

5.2 代码分析问题

以下代码输出什么？为什么？

java复制class Test {
    static {
        System.out.println("静态块");
    }
    
    {
        System.out.println("实例块");
    }
    
    Test() {
        System.out.println("构造器");
    }
}

try-with-resources的实现原理：

java复制try (BufferedReader br = new BufferedReader(new FileReader(path))) {
    return br.readLine();
}

自动调用AutoCloseable接口的close()方法

5.3 设计模式相关问题

如何用enum实现单例模式？

java复制public enum Singleton {
    INSTANCE;
    
    public void doSomething() {
        // 单例方法
    }
}

抽象类与接口的选择依据：
- 需要多继承：选择接口
- 需要共享代码：选择抽象类
- Java 8+：接口可以有默认方法

6. 关键字的底层实现原理

6.1 JVM层面的关键字实现

synchronized的底层实现：
- 方法级同步：方法标志位ACC_SYNCHRONIZED
- 代码块同步：monitorenter/monitorexit指令
volatile的底层实现：
- 内存屏障（Memory Barrier）
- 禁止指令重排序
- 保证可见性（直接操作主内存）
final的内存语义：
- 构造函数内对final域的写入
- 随后将构造对象的引用赋值给引用变量
- 这两个操作不能重排序

6.2 字节码层面的关键字表现

try-catch-finally的字节码：
- 异常表（Exception Table）
- 多个return指令
- finally块的代码复制
switch的两种实现方式：
- tableswitch：连续值，直接跳转
- lookupswitch：稀疏值，二分查找
lambda表达式的实现：
- invokedynamic指令
- 生成匿名类
- 方法句柄（MethodHandle）

7. 关键字的性能考量

7.1 影响性能的关键字使用

synchronized的性能影响：
- 偏向锁->轻量级锁->重量级锁的升级过程
- 锁粗化（Lock Coarsening）
- 锁消除（Lock Elimination）
volatile的性能代价：
- 读写操作不能缓存
- 内存屏障带来的性能损耗
- 适合读多写少的场景
final的性能优势：
- 编译时常量折叠
- 方法内联优化
- 减少同步开销

7.2 最佳实践建议

减少同步范围：

java复制// 不推荐
public synchronized void process() {
    // 整个方法同步
}

// 推荐
public void process() {
    synchronized(this) {
        // 只同步必要部分
    }
}

使用局部变量替代字段访问：

java复制// 不推荐
for (int i = 0; i < this.count; i++) {
    // 每次循环都访问字段
}

// 推荐
int localCount = this.count;
for (int i = 0; i < localCount; i++) {
    // 使用局部变量
}

合理使用final：

java复制// 推荐将不会改变的字段声明为final
class Config {
    private final String serverUrl;
    
    public Config(String url) {
        this.serverUrl = url;
    }
}

8. 关键字在不同场景下的应用

8.1 Web开发中的关键字应用

Servlet中的synchronized：

java复制public class CounterServlet extends HttpServlet {
    private int count;
    
    protected synchronized void doGet(HttpServletRequest req, HttpServletResponse resp) {
        count++;
        // 线程安全的计数
    }
}

Spring中的final应用：

java复制@Service
public class UserService {
    private final UserRepository userRepo;  // 推荐使用final
    
    @Autowired
    public UserService(UserRepository userRepo) {
        this.userRepo = userRepo;
    }
}

8.2 并发编程中的关键字应用

volatile在双重检查锁定中的应用：

java复制class Singleton {
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Atomic类与volatile的对比：

java复制// volatile版本
class Counter {
    private volatile int count;
    
    public void increment() {
        count++;  // 非原子操作
    }
}

// AtomicInteger版本
class SafeCounter {
    private AtomicInteger count = new AtomicInteger();
    
    public void increment() {
        count.incrementAndGet();  // 原子操作
    }
}

8.3 函数式编程中的关键字应用

final与lambda表达式：

java复制public void process(List<String> names) {
    final String prefix = "Mr. ";  // 必须是final或等效final
    names.forEach(name -> System.out.println(prefix + name));
}

方法引用中的static：

java复制class StringUtils {
    static boolean isEmpty(String s) {
        return s == null || s.isEmpty();
    }
}

List<String> list = Arrays.asList("a", "", "b");
list.removeIf(StringUtils::isEmpty);  // 静态方法引用

9. 关键字的调试与问题排查

9.1 常见关键字相关错误

NullPointerException：
- 自动拆箱导致
- 同步null对象
- 调用null对象的实例方法

IllegalMonitorStateException：

java复制Object lock = new Object();
lock.wait();  // 必须在synchronized块中

IncompatibleClassChangeError：
- final类被尝试继承
- final方法被尝试重写

9.2 调试技巧

使用javap查看字节码：
```
bash复制javap -c -p MyClass.class
```
可以查看synchronized、volatile等关键字的实际实现
使用JConsole观察锁竞争：
- 监控线程状态
- 检测死锁
- 分析同步块性能
使用-XX:+PrintAssembly查看汇编代码：
```
bash复制java -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly MyClass
```
可以观察volatile的内存屏障实现

10. 关键字的未来发展趋势

10.1 Java近期版本的关键字变化

Java 14的record关键字：
- 简化数据类的定义
- 自动生成equals()、hashCode()等方法
- 不可变特性
Java 15的sealed关键字：
- 限制类的继承
- 增强领域建模能力
- 与模式匹配结合使用

Java 16的instanceof模式匹配：

java复制if (obj instanceof String s) {  // 直接绑定变量
    System.out.println(s.length());
}

10.2 可能引入的新关键字

value关键字提案：
- 用于定义值类型
- 减少对象开销
- 类似C#的结构体

with关键字提案：

java复制var updated = original with {
    .name = "新名字",
    .age = original.age + 1
};

defer关键字提案：

java复制void process(Resource r) {
    defer r.close();  // 函数返回前执行
    // 使用资源
}

11. 关键字的跨语言比较

11.1 与C++关键字的对比

const vs final：
- C++的const更强大（指针const、方法const）
- Java的final更简单（基本类型不可变，引用类型引用不可变）
virtual vs 默认虚方法：
- C++默认非虚，需显式声明virtual
- Java默认虚方法，可用final禁止重写
多重继承：
- C++支持类多重继承
- Java只支持接口多重继承

11.2 与C#关键字的对比

readonly vs final：
- C#的readonly类似Java的final
- 但readonly可以在构造函数中多次赋值
unsafe关键字：
- C#允许不安全代码
- Java没有直接等价物
async/await：
- C#原生支持
- Java通过CompletableFuture模拟

11.3 与Python关键字的对比

访问控制：
- Java有严格的public/protected/private
- Python依靠命名约定（_前缀表示protected，__前缀表示private）
同步机制：
- Java使用synchronized关键字
- Python使用with语句和锁对象
final/const：
- Java有final关键字
- Python没有真正的常量，靠约定

12. 关键字的编码规范建议

12.1 命名约定

常量命名：

java复制public static final int MAX_COUNT = 100;  // 全大写+下划线

枚举值命名：

java复制enum Color { RED, GREEN, BLUE }  // 全大写，简单枚举
enum Status { RUNNING, STOPPED }  // 状态枚举

12.2 访问控制原则

最小权限原则：
- 优先使用private
- 需要子类访问用protected
- 跨包访问考虑包私有或public

接口设计：

java复制public interface Service {
    void execute();  // 公共API
    
    default void log(String msg) {  // 默认方法
        System.out.println(msg);
    }
}

12.3 并发编程规范

volatile使用场景：
- 状态标志位
- 一次性安全发布
- 独立观察变量

synchronized最佳实践：

同步块优于同步方法
使用私有锁对象

java复制private final Object lock = new Object();

public void safeMethod() {
    synchronized(lock) {
        // 临界区
    }
}

13. 关键字的工具支持

13.1 IDE对关键字的支持

语法高亮：
- 关键字特殊颜色显示
- 错误使用实时提示
代码补全：
- 关键字自动补全
- 上下文相关的关键字建议
重构工具：
- 提取常量（final）
- 内联变量
- 同步块重构

13.2 静态分析工具

FindBugs/SpotBugs：
- 检测不正确的synchronized使用
- volatile误用检查
- final变量潜在问题
Checkstyle：
- 检查final变量命名
- 验证访问控制修饰符
- 同步块格式检查
PMD：
- 检测空的synchronized块
- 不必要的final修饰符
- switch语句穿透警告

13.3 性能分析工具

JProfiler：
- 分析synchronized竞争
- 监控volatile变量访问
- 锁争用热点识别
VisualVM：
- 线程状态监控
- 死锁检测
- 同步块性能分析
Java Mission Control：
- 详细的锁分析
- 线程转储
- 内存屏障影响评估

14. 关键字的进阶应用

14.1 注解处理器中的关键字处理

处理final类：

java复制@SupportedAnnotationTypes("*")
public class FinalChecker extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element e : roundEnv.getRootElements()) {
            if (e.getModifiers().contains(Modifier.FINAL)) {
                // 处理final类
            }
        }
        return true;
    }
}

生成enum代码：

java复制@AutoService(Processor.class)
public class EnumGenerator extends AbstractProcessor {
    // 生成包含特定方法的enum
}

14.2 反射API中的关键字访问

检查修饰符：

java复制Field field = clazz.getDeclaredField("count");
int modifiers = field.getModifiers();
boolean isFinal = Modifier.isFinal(modifiers);
boolean isVolatile = Modifier.isVolatile(modifiers);

修改final字段（不推荐）：

java复制Field field = clazz.getDeclaredField("CONSTANT");
field.setAccessible(true);

Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);

field.set(null, newValue);  // 修改final静态字段

14.3 字节码操作中的关键字

ASM库添加synchronized：

java复制MethodVisitor mv = cw.visitMethod(
    ACC_PUBLIC + ACC_SYNCHRONIZED,  // 添加synchronized
    "safeMethod",
    "()V", null, null);

Javassist设置volatile：

java复制CtField field = ctClass.getDeclaredField("flag");
field.setModifiers(Modifier.VOLATILE | Modifier.PRIVATE);

Byte Buddy定义final类：

java复制new ByteBuddy()
    .subclass(Object.class)
    .modifiers(Visibility.PUBLIC, TypeManifestation.FINAL)
    .make();

15. 关键字的替代方案

15.1 替代synchronized的方案

ReentrantLock：

java复制private final Lock lock = new ReentrantLock();

public void safeMethod() {
    lock.lock();
    try {
        // 临界区
    } finally {
        lock.unlock();
    }
}

StampedLock：

java复制private final StampedLock lock = new StampedLock();

public double read() {
    long stamp = lock.tryOptimisticRead();
    // 读操作
    if (!lock.validate(stamp)) {
        stamp = lock.readLock();
        try {
            // 重新读
        } finally {
            lock.unlockRead(stamp);
        }
    }
    return result;
}

15.2 替代volatile的方案

Atomic类：

java复制private final AtomicInteger counter = new AtomicInteger();

public void increment() {
    counter.incrementAndGet();
}

VarHandle（Java 9+）：

java复制private static final VarHandle COUNT_HANDLE;
private volatile int count;

static {
    try {
        COUNT_HANDLE = MethodHandles.lookup()
            .findVarHandle(MyClass.class, "count", int.class);
    } catch (Exception e) {
        throw new Error(e);
    }
}

public void update() {
    COUNT_HANDLE.getAndAdd(this, 1);
}

15.3 替代final的方案

不可变集合：

java复制List<String> list = Collections.unmodifiableList(new ArrayList<>());
Map<String, Integer> map = Map.of("a", 1, "b", 2);

防御性拷贝：

java复制class ImmutablePoint {
    private final int x;
    private final int y;
    
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int getX() { return x; }
    public int getY() { return y; }
}

16. 关键字的性能优化

16.1 synchronized优化技巧

减小同步范围：

java复制// 不推荐
public synchronized void process() {
    // 大量非同步代码
    synchronized(this) {
        // 少量需要同步的代码
    }
    // 更多非同步代码
}

// 推荐
public void process() {
    // 非同步代码
    synchronized(this) {
        // 需要同步的代码
    }
    // 更多非同步代码
}

使用读写锁：

java复制private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

public void read() {
    rwLock.readLock().lock();
    try {
        // 读操作
    } finally {
        rwLock.readLock().unlock();
    }
}

public void write() {
    rwLock.writeLock().lock();
    try {
        // 写操作
    } finally {
        rwLock.writeLock().unlock();
    }
}

16.2 final的优化效果

内联优化：

java复制public class Config {
    public static final int MAX_SIZE = 1024;
    
    public void process() {
        if (data.length > MAX_SIZE) {  // 编译时直接替换为1024
            throw new IllegalArgumentException();
        }
    }
}

线程安全优化：

java复制public class Publisher {
    private final List<Subscriber> subscribers;  // 安全发布
    
    public Publisher(List<Subscriber> subs) {
        this.subscribers = new ArrayList<>(subs);  // 防御性拷贝
    }
}

16.3 volatile的使用模式

状态标志：

java复制class Worker implements Runnable {
    private volatile boolean running = true;
    
    public void stop() { running = false; }
    
    public void run() {
        while (running) {
            // 工作循环
        }
    }
}

一次性安全发布：

java复制class ResourceHolder {
    private volatile Resource resource;
    
    public Resource getResource() {
        Resource result = resource;
        if (result == null) {
            synchronized(this) {
                result = resource;
                if (result == null) {
                    resource = result = new Resource();
                }
            }
        }
        return result;
    }
}

17. 关键字的测试策略

17.1 测试final行为

尝试修改final字段：

java复制@Test(expected = IllegalAccessError.class)
public void testFinalField() throws Exception {
    FinalClass obj = new FinalClass();
    Field field = FinalClass.class.getDeclaredField("VALUE");
    field.setAccessible(true);
    field.set(obj, 2);  // 应该抛出异常
}

尝试继承final类：

java复制@Test
public void testFinalClass() {
    try {
        class SubClass extends FinalClass {}  // 编译错误
        fail("Should not allow subclassing final class");
    } catch (Exception e) {
        // 预期行为
    }
}

17.2 测试synchronized行为

并发访问测试：

java复制@Test
public void testSynchronizedMethod() throws InterruptedException {
    Counter counter = new Counter();
    
    Runnable task = () -> {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    };
    
    Thread t1 = new Thread(task);
    Thread t2 = new Thread(task);
    
    t1.start();
    t2.start();
    
    t1.join();
    t2.join();
    
    assertEquals(2000, counter.getCount());  // 确保线程安全
}

死锁检测测试：

java复制@Test(timeout = 1000)
public void testDeadlock() throws InterruptedException {
    Object lock1 = new Object();
    Object lock2 = new Object();
    
    Thread t1 = new Thread(() -> {
        synchronized(lock1) {
            sleep(100);
            synchronized(lock2) {
                // 获取lock2
            }
        }
    });
    
    Thread t2 = new Thread(() -> {
        synchronized(lock2) {
            sleep(100);
            synchronized(lock1) {
                // 获取lock1
            }
        }
    });
    
    t1.start();
    t2.start();
    
    t1.join(500);
    t2.join(500);
    
    assertFalse(t1.isAlive() && t2.isAlive());  // 至少一个线程应完成
}

Java关键字详解：从基础到高级应用