⚡ Java语言关键字总览
Java语言中,关键字(Keywords)是语言保留的、具有特殊含义的标识符,不能用作类名、方法名、变量名等用户自定义名称。截至Java 21,共有53个关键字(含2个保留字),另有3个特殊字面值(true、false、null)和1个未使用关键字(const已保留但未启用)。
所有关键字均小写,部分版本新增关键字如sealed(Java 17预览)、record(Java 14预览)、yield(Java 14预览)等已正式纳入语言规范。下表按功能分类列出全部关键字及其作用简述:
〔按用途分类〕
- 访问控制:private、protected、public
- 类、方法、变量修饰:abstract、class、extends、final、implements、interface、native、static、strictfp、synchronized、transient、volatile
- 程序控制流程:break、continue、do、for、if、else、return、switch、while
- 错误处理:catch、finally、throw、throws、try
- 引用与实例:instanceof、new
- 包与导入:import、package
- 基本数据类型:boolean、byte、char、double、float、int、long、short
- 特殊值与字面量:true、false、null
- 引用本对象:this、super
- 变量声明与定义:const(保留)、goto(保留)
- 枚举与断言:enum、assert
- 模块化(Java 9+):module、requires、exports、opens、opens to、uses、provides、with
其中const和goto虽被保留为关键字,但从未在Java中实际使用,仅保留以防未来扩展冲突。例如,若未来添加结构化并发特性,可能重新启用goto;而const可作为final的别名使用(如Kotlin)。当前版本中,二者作为标识符会引发编译错误:
int const = 5; // 编译错误:'const' is a keyword
int goto = 10; // 编译错误:'goto' is a keyword
⚙️ 修饰符关键字详解
修饰符用于限定类、方法、变量等的访问权限、生命周期、行为约束等特性。Java中修饰符可分为:访问控制修饰符、非访问控制修饰符两类。
〔1〕访问控制修饰符
private:私有访问权限
被private修饰的成员(字段、方法、构造器)仅在声明它的类内部可见,外部类、子类均无法直接访问。这是封装性(Encapsulation)的核心体现,防止外部误用内部实现细节。
典型应用:封装字段(字段私有化 + 提供getter/setter)
public class User {
private String name;
private int age;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}
private构造器可实现单例模式(Singleton Pattern):
public class Singleton {
private static final Singleton INSTANCE = new Singleton();
private Singleton() {} // 防止外部new
public static Singleton getInstance() { return INSTANCE; }
}
protected:受保护访问权限
介于private与public之间,允许:
① 同一包内类访问;
② 不同包中的子类访问(即使子类未导入父类)。
注意:不同包中非子类无法访问,即使通过继承链也不行。
常见误区:认为protected成员对子类“可见”即可直接访问父类实例的protected`成员——实际仅当通过子类引用或子类自身定义的字段时才允许:
class Parent {
protected int x = 10;
}
class Child extends Parent {
void test(Parent p) {
// System.out.println(p.x); // ❌ 编译错误:x is protected
System.out.println(x); // ✅ 子类中可直接访问
}
}
public:公共访问权限
被public修饰的类、方法、字段可在任意位置访问,是API开放的默认选择。
类声明限制:一个.java文件中最多只能有一个public类,且文件名必须与该类名完全一致(含大小写)。
最佳实践:最小权限原则——默认使用private,仅在必要时提升权限至protected或public。
〔2〕非访问控制修饰符
static:静态成员修饰符
static用于修饰变量(类变量)、方法(类方法)、代码块(静态初始化块)、内部类(静态内部类)。其核心特性是:不依赖实例存在,随类加载而初始化。
类变量 vs 实例变量:
class Counter {
static int count = 0; // 所有实例共享
int id; // 每个实例独立
Counter() { count++; id = count; }
}
Counter a = new Counter(); // count = 1
Counter b = new Counter(); // count = 2(共享!)
System.out.println(a.count); // 2
System.out.println(b.count); // 2
静态方法限制:
- 不能直接访问实例成员(需通过对象引用)
- 不能使用
this或super关键字 - 常用于工具类(如
java.lang.Math)
final:最终不可变修饰符
final可修饰类、方法、变量,含义分别为:
- final类:不能被继承(如
String、Integer、Math) - final方法:不能被子类重写(防止核心逻辑被篡改)
- final变量:只能赋值一次(常量)
注意:final引用变量指向的对象内容仍可变,仅引用本身不可变:
final List list = new ArrayList<>();
list.add("Java"); // ✅ 合法
list = new LinkedList<>(); // ❌ 编译错误:不能重新赋值
常量池优化:编译期常量(public static final String NAME = "Java")会被内联,修改后需重新编译所有依赖类。
abstract:抽象类与抽象方法
abstract用于定义抽象类(不能实例化)和抽象方法(无方法体)。抽象类可包含具体方法与字段,抽象方法必须在子类中实现。
设计原则:模板方法模式(Template Method Pattern)常结合abstract使用:
abstract class DataProcessor {
public final void process() { // 模板方法:final防止重写
loadData();
transform();
saveData();
}
protected abstract void loadData(); // 子类实现
protected abstract void transform();
protected void saveData() {} // 可有默认实现
}
常见误区:abstract不能与final、static、private共存(矛盾语义):
abstract static void foo(); // ❌ 静态方法无需子类实现
abstract private void bar(); // ❌ 私有方法无法被子类重写
volatile:轻量级同步机制
volatile确保变量的可见性与禁止指令重排序,适用于单写多读场景(如状态标志、配置参数)。其性能高于synchronized,但不保证原子性。
典型用法:双检锁单例(DCL)中需volatile防止指令重排序导致部分初始化:
class Singleton {
private volatile static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton(); // 无volatile可能返回未初始化对象
}
}
}
return instance;
}
}
不适用场景:count++等复合操作仍需synchronized或AtomicInteger。
transient:序列化排除字段
被transient修饰的字段在对象序列化时被跳过,反序列化时赋默认值(如null、0)。
典型场景:敏感信息(密码)、临时状态、可计算字段:
class User implements Serializable {
private String name;
private transient String password; // 不序列化
private transient int tempCache; // 可由name动态计算
}
自定义序列化:可通过writeObject/readObject手动控制序列化过程,transient仅影响默认机制。
〔流程控制关键字〕
Java流程控制关键字用于控制程序执行路径,包括条件判断、循环、跳转等。
〔if-else与switch〕
- if / else:条件分支,支持嵌套与三元运算符(
? :) - switch:从Java 7起支持
String、enum、Integer等;Java 14起支持表达式形式与yield返回值
switch新语法(Java 14+):
String result = switch (day) {
case "Mon", "Tue", "Wed", "Thu", "Fri" -> "工作日";
case "Sat", "Sun" -> "周末";
default -> throw new IllegalStateException("无效日期");
};
〔循环关键字〕
- for:传统for、增强for(foreach)
——增强for本质是迭代器模式,适用于Iterable对象 - while / do-while:先判断后执行 / 先执行后判断
增强for陷阱:遍历时修改集合会抛ConcurrentModificationException:
List list = new ArrayList<>(Arrays.asList("a","b","c"));
for (String s : list) {
if ("b".equals(s)) list.remove(s); // ❌ 运行时异常
}
〔跳转关键字〕
- break:终止当前循环或switch;可带标签跳转外层循环(少用)
- continue:跳过本次循环剩余部分,进入下一次迭代
- return:结束方法执行,返回值(或无返回值)
- yield(Java 14+):在switch表达式中返回值(替代break+赋值)
标签用法示例:
outer: for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == 1 && j == 1) break outer; // 跳出外层循环
System.out.println(i + "," + j);
}
}
// 输出:0,0 0,1 0,2 1,0
〔类与接口关键字〕
〔class / interface / enum〕
- class:定义类(Java程序基本单元)
- interface:定义接口(Java 8起支持默认方法、静态方法、私有方法)
- enum:定义枚举(Java 5引入,本质是特殊类)
接口默认方法(Java 8+):
interface Logger {
void log(String msg);
default void info(String msg) { log("[INFO] " + msg); } // 默认实现
}
枚举特性:
- 隐式继承
java.lang.Enum,不能继承其他类 - 构造器默认为
private(防止外部new) - 每个常量是该枚举类的实例,自动添加
public static final
enum Season {
SPRING("春天"), SUMMER("夏天");
private final String desc;
Season(String desc) { this.desc = desc; }
public String getDesc() { return desc; }
}
〔extends / implements〕
- extends:单继承(类)或多继承(接口)
- implements:实现接口(可多实现)
继承限制:final类不能被继承;接口不能被继承类(只能被实现)
多实现冲突处理:若多个接口有同名默认方法,子类必须重写该方法:
interface A { default void hello() { System.out.println("A"); } }
interface B { default void hello() { System.out.println("B"); } }
class C implements A, B {
public void hello() { // 必须显式重写
A.super.hello(); // 或 B.super.hello()
}
}
〔sealed类(Java 17)〕
sealed关键字限制类的继承层次,仅允许指定子类(通过permits或non-sealed)。
sealed class Shape permits Circle, Rectangle {
abstract double area();
}
final class Circle extends Shape {
double r; double area() { return Math.PI * r * r; }
}
non-sealed class Polygon extends Shape {} // 允许进一步继承
优势:增强类型安全与模式匹配完整性(如instanceof分支覆盖所有可能)
〔对象与引用关键字〕
〔this / super〕
- this:引用当前对象;用于区分字段与参数、调用本类其他构造器
- super:引用父类成员;用于访问被覆盖的字段/方法、调用父类构造器
构造器链式调用:
class Person {
String name;
int age;
Person(String name) { this.name = name; }
Person(String name, int age) { this(name); this.age = age; } // this(...)必须在首行
}
常见错误:
this不能用于static上下文super()必须是构造器第一条语句- 不能同时使用
this()和super()
〔new〕
new用于创建对象实例,触发类加载(若未加载)、内存分配、构造器执行。
对象创建过程:
- 类加载检查(是否已加载)
- 分配内存(堆空间)
- 执行构造器(赋初始值)
特殊用法:
- 匿名内部类:
Runnable r = new Runnable() { public void run() {} }; - 数组创建:
int[] arr = new int[5];
〔instanceof〕
instanceof用于判断对象是否属于某类型(含子类),Java 16起支持模式匹配(Pattern Matching):
// 传统写法
if (obj instanceof String) {
String s = (String) obj;
System.out.println(s.length());
}
// Java 16+写法
if (obj instanceof String s) {
System.out.println(s.length()); // 自动类型转换
}
注意:instanceof对null恒为false;不能用于基本类型(如int instanceof Number非法)
〔包与导入关键字〕
〔package〕
package声明文件所属包,必须位于源文件第一行(除注释外)。
命名规范:全小写 + 域名倒序(如com.example.project)
〔import〕
import导入类/接口/枚举,支持通配符(*)或单类型导入。
最佳实践:
- 避免通配符导入(如
import java.util.*;),明确依赖关系 - 静态导入需谨慎(
import static java.lang.Math.*;)易降低可读性
命名冲突处理:
import java.util.Date;
import java.sql.Date; // ❌ 编译错误:重复导入Date
// 解决方案:使用全限定名
java.util.Date utilDate = new java.util.Date();
java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis());
〔异常处理关键字〕
〔try / catch / finally / throw / throws〕
- try:监控可能抛异常的代码块
- catch:捕获并处理异常(可多级捕获,从子类到父类)
- finally:无论是否异常均执行(资源释放)
- throw:显式抛出异常对象
- throws:声明方法可能抛出的异常(编译期检查)
try-with-resources(Java 7+):自动关闭资源(实现AutoCloseable接口):
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
return br.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
} // 自动关闭br
异常处理原则:
- 避免空catch块(掩盖问题)
- 优先捕获具体异常(如
FileNotFoundException),再捕获通用异常(如IOException) - 自定义异常应继承
Exception(检查型)或RuntimeException(非检查型)
〔其他关键字〕
〔assert(Java 1.4+)〕
assert用于断言(调试阶段),语法:assert condition : detailMessage;
启用方式:运行时添加-ea参数(java -ea MyApp)
适用场景:内部不变量检查、方法前置/后置条件验证
〔strictfp(Java 1.2+)〕
strictfp强制浮点运算遵循IEEE 754标准(保证跨平台一致性),可修饰类、接口、方法。
使用场景:金融计算、科学计算等需高精度浮点结果的场景
〔module(Java 9+)〕
模块化系统(JPMS)关键字,用于module-info.java文件:
- module:声明模块(如
module com.example.app {}) - requires:依赖其他模块
- exports:导出包供其他模块访问
- opens:运行时反射导出包
示例:
module com.example.app {
requires java.base;
exports com.example.service;
opens com.example.ui to javafx.graphics;
}