Java 常用关键字详解

Java 关键字 (Keywords) 是 Java 语言中被赋予特殊含义的、预定义的、保留的标识符。它们不能用作变量名、类名、方法名或其他用户自定义的标识符。理解和正确使用这些关键字是编写有效 Java 代码的基础。本文将详细介绍 Java 中最常用的关键字及其功能。

核心思想：关键字是 Java 编译器识别和理解代码结构及行为的“命令词”。

一、基本概念

Java 关键字在语言语法中扮演着核心角色，它们指示编译器如何解释和处理代码的特定部分。所有 Java 关键字都是小写字母。

二、数据类型关键字

这些关键字用于声明变量的数据类型。

boolean：表示布尔类型，只有 true 和 false 两个值。
1
boolean isActive = true;
byte：表示 8 位带符号整数，范围 -128 到 127。
1
byte level = 10;
short：表示 16 位带符号整数，范围 -32768 到 32767。
1
short count = 1000;
int：表示 32 位带符号整数，最常用的整数类型。
1
int score = 100000;
long：表示 64 位带符号整数，用于表示更大的整数值，常在数字后加 L 或 l。
1
long timestamp = 1678886400000L;
float：表示 32 位浮点数，常在数字后加 F 或 f。
1
float price = 19.99F;
double：表示 64 位浮点数，最常用的浮点类型。
1
double pi = 3.1415926535;
char：表示 16 位 Unicode 字符。
1
char grade = 'A';

三、流程控制关键字

这些关键字用于控制程序的执行流程。

if / else：条件语句，根据布尔表达式的结果执行不同的代码块。

int x = 10;
if (x > 5) {
    System.out.println("x 大于 5");
} else {
    System.out.println("x 不大于 5");
}

switch / case / default：多分支选择语句，根据表达式的值匹配对应的 case。

int day = 3;
switch (day) {
    case 1:
        System.out.println("星期一");
        break;
    case 7:
        System.out.println("星期日");
        break;
    default:
        System.out.println("其他工作日");
}

for：循环语句，用于固定次数的迭代。

1
2
3

for (int i = 0; i < 5; i++) {
    System.out.println("循环次数: " + i);
}

while：循环语句，只要条件为真就一直执行。

int i = 0;
while (i < 3) {
    System.out.println("while 循环: " + i);
    i++;
}

do / while：先执行一次代码块，然后检查条件是否为真，为真则继续循环。

int j = 0;
do {
    System.out.println("do-while 循环: " + j);
    j++;
} while (j < 0); // 尽管条件为假，do 块也会执行一次

break：用于跳出循环（for, while, do-while）或 switch 语句。

for (int k = 0; k < 10; k++) {
    if (k == 3) {
        break; // 当 k 为 3 时跳出循环
    }
    System.out.println(k);
}

continue：用于跳过当前循环的剩余部分，直接进入下一次循环。

for (int k = 0; k < 5; k++) {
    if (k == 2) {
        continue; // 当 k 为 2 时跳过当前迭代
    }
    System.out.println(k);
}

return：用于从方法中返回一个值（如果方法有返回类型）或终止方法的执行。
1
2
3
public int add(int a, int b) {
return a + b; // 返回两个数的和
}

四、修饰符关键字

这些关键字用于修饰类、方法、变量等，改变它们的访问权限或行为特性。

4.1 访问修饰符 (Access Modifiers)

public：公开的，可以在任何地方被访问。
private：私有的，只能在声明它的类内部访问。
protected：受保护的，可以在同一包内和所有子类中访问。
(默认/包级私有)：没有指定访问修饰符时，只能在同一包内访问。

package com.example.model;

public class MyClass {
    public int publicVar;
    private int privateVar;
    protected int protectedVar;
    int defaultVar; // 默认 (package-private)

    public void publicMethod() { /* ... */ }
    private void privateMethod() { /* ... */ }
    protected void protectedMethod() { /* ... */ }
    void defaultMethod() { /* ... */ }
}

4.2 非访问修饰符 (Non-Access Modifiers)

static：静态的。

修饰变量：使其成为类变量，所有对象共享一份。
修饰方法：使其成为类方法，可以直接通过类名调用，无需创建对象。
修饰代码块：静态初始化块，在类加载时执行一次。
修饰内部类：静态内部类。

public class Counter {
    static int count = 0; // 静态变量，所有 Counter 对象共享
    public Counter() {
        count++;
    }
    public static void displayCount() { // 静态方法
        System.out.println("当前计数: " + count);
    }
}

final：最终的。

修饰变量：变量值一旦初始化后不能再改变（常量）。
修饰方法：方法不能被子类重写。
修饰类：类不能被继承。

public final class Constants { // final 类，不能被继承
    public static final double PI = 3.14159; // final 静态变量 (常量)
}

class MySubClass {
    public final void doSomething() { // final 方法，不能被重写
        System.out.println("Doing something...");
    }
}

abstract：抽象的。

修饰方法：方法只有声明没有实现（抽象方法），所在的类必须是抽象类。
修饰类：类不能被实例化，必须被子类继承并实现其所有抽象方法。

public abstract class Shape { // 抽象类
    public abstract double getArea(); // 抽象方法
    public void display() {
        System.out.println("这是一个形状");
    }
}

class Circle extends Shape {
    private double radius;
    public Circle(double radius) { this.radius = radius; }
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

synchronized：同步的。用于修饰方法或代码块，确保在多线程环境下同一时间只有一个线程可以访问受保护的代码，防止并发问题。

public class Account {
    private double balance;
    public synchronized void deposit(double amount) { // 同步方法
        balance += amount;
    }
    public void withdraw(double amount) {
        synchronized (this) { // 同步代码块
            balance -= amount;
        }
    }
}

volatile：易变的。用于修饰变量，指示 JVM 该变量的值可能在任何时候被多个线程修改，确保所有线程看到的是最新的值，避免缓存不一致问题。

public class FlagChecker {
    private volatile boolean running = true; // 确保 running 变量的可见性
    public void stop() {
        running = false;
    }
    public void run() {
        while (running) {
            // do something
        }
        System.out.println("线程停止");
    }
}

transient：瞬态的。用于修饰类成员变量，指示该变量在对象序列化时不会被保存。

import java.io.Serializable;

public class User implements Serializable {
    String username;
    transient String password; // password 不会被序列化
    // ...
}

native：本地的。用于修饰方法，指示该方法的实现由外部语言（如 C/C++）提供，通过 JNI (Java Native Interface) 调用。

public class MyNativeCode {
    public native void helloWorld(); // 本地方法声明
    static {
        System.loadLibrary("MyNativeLib"); // 加载本地库
    }
}

五、面向对象关键字

这些关键字是 Java 面向对象特性的核心。

class：用于声明一个类，是创建对象的模板。

public class Dog { // 声明一个 Dog 类
    String name;
    public void bark() { /* ... */ }
}

interface：用于声明一个接口，定义一组抽象方法和常量。

1
2
3

public interface Flyable { // 声明一个 Flyable 接口
    void fly();
}

enum：用于声明一个枚举类型，表示一组有限的命名常量。

1
2
3

public enum DayOfWeek { // 声明一个枚举
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

extends：用于类继承，表示一个类是另一个类的子类。

class Animal { /* ... */ }
class Dog extends Animal { // Dog 继承 Animal
    // ...
}

implements：用于类实现接口，表示一个类实现了一个或多个接口。

class Bird implements Flyable { // Bird 实现 Flyable 接口
    @Override
    public void fly() { /* ... */ }
}

new：用于创建对象实例或数组实例。

1 2	Dog myDog = new Dog(); // 创建 Dog 对象 int[] numbers = new int[5]; // 创建 int 数组

this：引用当前对象实例。

用于区分成员变量和局部变量。
用于在构造器中调用另一个构造器。

public class Person {
    String name;
    public Person(String name) {
        this.name = name; // 使用 this 区分成员变量
    }
}

super：引用父类的成员。

用于访问父类的成员变量或方法。
用于在子类构造器中调用父类的构造器。

class Parent {
    int value = 10;
    public Parent(int v) { this.value = v; }
}
class Child extends Parent {
    int value = 20;
    public Child() {
        super(5); // 调用父类构造器
        System.out.println(super.value); // 访问父类成员变量
    }
}

instanceof：用于检查对象是否是指定类或接口的实例。

String str = "Hello";
if (str instanceof String) {
    System.out.println("str 是 String 的实例");
}

void：用于声明方法不返回任何值。

1
2
3

public void printMessage() { // 不返回任何值的方法
    System.out.println("这是一个消息");
}

六、异常处理关键字

这些关键字用于处理程序运行时可能发生的错误和异常。

try：用于包围可能抛出异常的代码块。
catch：用于捕获并处理 try 块中抛出的特定类型的异常。

finally：无论 try 块中是否发生异常，finally 块中的代码都会被执行（通常用于资源清理）。

try {
    int result = 10 / 0; // 抛出 ArithmeticException
    System.out.println(result);
} catch (ArithmeticException e) {
    System.err.println("发生算术异常: " + e.getMessage());
} finally {
    System.out.println("Finally 块总是执行");
}

throw：用于显式地抛出一个异常对象。

public void checkAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("年龄不能为负数");
    }
    System.out.println("年龄有效");
}

throws：用于在方法签名中声明该方法可能抛出的异常类型。

1
2
3

public void readFile(String fileName) throws FileNotFoundException, IOException {
    // ... 读取文件的代码 ...
}

assert：用于在开发和调试阶段进行断言，检查某个条件是否为真。如果条件为假，则抛出 AssertionError。
1
2
int value = 10;
assert value > 0 : "Value 必须大于 0"; // 断言 value > 0

七、包和导入关键字

这些关键字用于组织和引用类。

package：用于声明当前文件所属的包。必须是文件的第一个非注释语句。
1
package com.myapp.utils; // 声明当前文件属于 com.myapp.utils 包

import：用于导入其他包中的类或接口，以便在当前文件中使用它们而无需完全限定名。

import java.util.ArrayList; // 导入 ArrayList 类
import java.io.*; // 导入 java.io 包中的所有类

public class MyClass {
    ArrayList<String> list = new ArrayList<>(); // 直接使用 ArrayList
    // ...
}

八、其他关键字

strictfp (Strict Floating-Point)：用于确保浮点数运算在所有平台上都具有严格的 IEEE 754 浮点数行为。主要用于旧版 Java，现在较少使用。
1
2
3
public strictfp class MyMath {
// ...
}
super：已在“面向对象关键字”中介绍。
this：已在“面向对象关键字”中介绍。

8.1 保留字 (Reserved Words)

Java 还包含一些保留字，它们是关键字或字面值，但不能用作标识符。

const：Java 中没有 const 关键字用于定义常量，而是使用 public static final 组合。const 是 C++ 中的关键字，在 Java 中被保留，但未使用。
goto：Java 中没有 goto 语句，尽管它是其他一些语言（如 C/C++）中的关键字。goto 在 Java 中被保留，但未使用。