Java 关键字

关键字概述

Java 共有 53 个关键字（包括保留字），这些关键字按功能可以分为以下几类：

访问控制关键字：控制类、方法、变量的访问权限
类、方法和变量修饰符：定义类、方法、变量的特性
程序控制语句：控制程序的执行流程
错误处理：处理异常和错误
包相关：管理包和导入
基本数据类型：定义基本数据类型
变量引用：处理变量引用和实例
保留字：为将来使用而保留的关键字

Java 拥有一组关键字，这些关键字是保留字，不能用作变量、方法、类或任何其他标识符：

关键字	描述
abstract	非访问修饰符。用于类和方法：抽象类不能用于创建对象（要访问它，必须从另一个类继承）。抽象方法只能在抽象类中使用，并且没有方法体。方法体由子类（继承的）提供
assert	用于调试
boolean	只能存储 true 或 false 值的数据类型
break	跳出循环或 switch 代码块
byte	可以存储 -128 到 127 整数的数据类型
case	在 switch 语句中标记代码块
catch	捕获 try 语句生成的异常
char	用于存储单个字符的数据类型
class	定义一个类
continue	继续循环的下一次迭代
const	定义常量。未使用 - 请使用 final 代替
default	在 switch 语句中指定默认代码块
do	与 while 一起使用创建 do-while 循环
double	可以存储 1.7e−308 到 1.7e+308 小数的数据类型
else	用于条件语句
enum	声明枚举（不可更改）类型
exports	使用模块导出包。Java 9 新增
extends	扩展类（表示一个类从另一个类继承）
final	用于类、属性和方法的非访问修饰符，使它们不可更改（无法继承或重写）
finally	与异常一起使用，无论是否有异常都会执行的代码块
float	可以存储 3.4e−038 到 3.4e+038 小数的数据类型
for	创建 for 循环
goto	未使用，没有功能
if	创建条件语句
implements	实现接口
import	用于导入包、类或接口
instanceof	检查对象是否是特定类或接口的实例
int	可以存储 -2147483648 到 2147483647 整数的数据类型
interface	用于声明只包含抽象方法的特殊类型的类
long	可以存储 -9223372036854775808 到 9223372036854775808 整数的数据类型
module	声明模块。Java 9 新增
native	指定方法不在同一个 Java 源文件中实现（而是在另一种语言中）
new	创建新对象
package	声明包
private	用于属性、方法和构造器的访问修饰符，使它们只能在声明的类内访问
protected	用于属性、方法和构造器的访问修饰符，使它们在同一包和子类中可访问
public	用于类、属性、方法和构造器的访问修饰符，使它们可被任何其他类访问
requires	在模块内指定所需的库。Java 9 新增
return	完成方法的执行，可用于从方法返回值
short	可以存储 -32768 到 32767 整数的数据类型
static	用于方法和属性的非访问修饰符。静态方法/属性可以在不创建类对象的情况下访问
strictfp	已过时。限制浮点计算的精度和舍入
super	引用超类（父类）对象
switch	选择要执行的多个代码块之一
synchronized	非访问修饰符，指定方法一次只能被一个线程访问
this	在方法或构造器中引用当前对象
throw	创建自定义错误
throws	指示方法可能抛出的异常
transient	在序列化对象时用于忽略属性
try	创建 try...catch 语句
var	声明变量。Java 10 新增
void	指定方法不应有返回值
volatile	指示属性不在线程本地缓存，始终从"主内存"读取
while	创建 while 循环

Java 关键字是 Java 语言中预定义的、具有特殊含义的保留字。这些关键字不能用作变量名、方法名、类名或任何其他标识符。Java 语言规范定义了这些关键字，它们构成了 Java 语法的基础。

NOTE

注意：true、false 和 null 并非关键字，但它们属于字面量和保留字，不能用作标识符。

访问控制关键字

public

定义公共访问权限，可以被任何其他类访问。

public class MyClass {
    public int publicVariable = 10;
    
    public void publicMethod() {
        System.out.println("这是一个公共方法");
    }
}

private

定义私有访问权限，只能在同一个类内部访问。

public class MyClass {
    private int privateVariable = 20;
    
    private void privateMethod() {
        System.out.println("这是一个私有方法");
    }
}

protected

定义受保护的访问权限，可以被同一包内的类或子类访问。

public class Parent {
    protected int protectedVariable = 30;
    
    protected void protectedMethod() {
        System.out.println("这是一个受保护的方法");
    }
}

class Child extends Parent {
    public void accessProtected() {
        System.out.println(protectedVariable); // 可以访问
        protectedMethod(); // 可以调用
    }
}

类、方法和变量修饰符

static

定义静态成员，属于类而不是实例。

public class StaticExample {
    static int staticVariable = 100;
    
    static void staticMethod() {
        System.out.println("静态方法，静态变量值：" + staticVariable);
    }
    
    public static void main(String[] args) {
        // 直接通过类名访问
        StaticExample.staticMethod();
        System.out.println(StaticExample.staticVariable);
    }
}

final

定义最终的、不可改变的元素。

public class FinalExample {
    // final 变量（常量）
    final int CONSTANT = 42;
    
    // final 方法（不能被重写）
    final void finalMethod() {
        System.out.println("这个方法不能被重写");
    }
}

// final 类（不能被继承）
final class FinalClass {
    // 类的内容
}

abstract

定义抽象类或抽象方法。

abstract class AbstractClass {
    // 抽象方法（没有实现）
    abstract void abstractMethod();
    
    // 普通方法
    void concreteMethod() {
        System.out.println("具体方法的实现");
    }
}

class ConcreteClass extends AbstractClass {
    @Override
    void abstractMethod() {
        System.out.println("实现抽象方法");
    }
}

synchronized

用于多线程同步。

public class SynchronizedExample {
    private int count = 0;
    
    // 同步方法
    synchronized void increment() {
        count++;
    }
    
    void anotherMethod() {
        // 同步代码块
        synchronized(this) {
            count--;
        }
    }
}

volatile

确保变量的可见性，防止编译器优化。

public class VolatileExample {
    private volatile boolean flag = false;
    
    public void setFlag() {
        flag = true; // 对所有线程立即可见
    }
    
    public boolean getFlag() {
        return flag;
    }
}

程序控制语句

条件语句

if, else

条件判断语句。

int score = 85;

if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

switch, case, default

多分支选择语句。

int dayOfWeek = 3;

switch (dayOfWeek) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    default:
        System.out.println("其他日期");
        break;
}

循环语句

for

for 循环语句。

// 传统 for 循环
for (int i = 0; i < 5; i++) {
    System.out.println("i = " + i);
}

// 增强型 for 循环（for-each）
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println("数字：" + num);
}

while

while 循环语句。

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

do

do-while 循环语句。

int j = 0;
do {
    System.out.println("do-while 循环：" + j);
    j++;
} while (j < 3);

跳转语句

break

跳出循环或 switch 语句。

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 跳出循环
    }
    System.out.println(i);
}

continue

跳过当前循环迭代。

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

return

从方法中返回。

public int calculateSum(int a, int b) {
    if (a < 0 || b < 0) {
        return -1; // 提前返回
    }
    return a + b; // 正常返回
}

错误处理关键字

try, catch, finally

异常处理机制。

public class ExceptionExample {
    public void divideNumbers(int a, int b) {
        try {
            int result = a / b;
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("除零错误：" + e.getMessage());
        } finally {
            System.out.println("无论是否发生异常都会执行");
        }
    }
}

throw

抛出异常。

public void validateAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("年龄不能为负数");
    }
    System.out.println("年龄验证通过：" + age);
}

throws

声明方法可能抛出的异常。

public void readFile(String filename) throws IOException {
    FileReader file = new FileReader(filename);
    // 文件读取操作
}

包相关关键字

package

声明包。

package com.example.myproject;

public class MyClass {
    // 类的内容
}

import

导入其他包的类。

import java.util.ArrayList;
import java.util.List;
import java.io.*; // 导入整个包

public class ImportExample {
    public void useImportedClasses() {
        List<String> list = new ArrayList<>();
        // 使用导入的类
    }
}

基本数据类型关键字

Java 定义了 8 种基本数据类型：

整数类型

byte byteValue = 127;        // 8位，范围：-128 到 127
short shortValue = 32767;    // 16位，范围：-32,768 到 32,767
int intValue = 2147483647;   // 32位，范围：-2^31 到 2^31-1
long longValue = 9223372036854775807L; // 64位，范围：-2^63 到 2^63-1

浮点类型

float floatValue = 3.14f;    // 32位单精度浮点数
double doubleValue = 3.14159265359; // 64位双精度浮点数

字符和布尔类型

char charValue = 'A';        // 16位 Unicode 字符
boolean booleanValue = true; // 布尔值：true 或 false

变量引用关键字

this

引用当前对象。

public class ThisExample {
    private int value;
    
    public void setValue(int value) {
        this.value = value; // 区分参数和成员变量
    }
    
    public ThisExample getThis() {
        return this; // 返回当前对象
    }
}

super

引用父类。

class Parent {
    protected String name = "父类";
    
    public void display() {
        System.out.println("父类方法");
    }
}

class Child extends Parent {
    private String name = "子类";
    
    public void display() {
        super.display(); // 调用父类方法
        System.out.println("当前类名：" + this.name);
        System.out.println("父类名：" + super.name);
    }
}

null

表示空引用。

String str = null; // 空引用
if (str == null) {
    System.out.println("字符串为空");
}

对象和类型相关关键字

new

创建新对象。

// 创建对象
ArrayList<String> list = new ArrayList<>();
String str = new String("Hello");

// 创建数组
int[] numbers = new int[10];

instanceof

检查对象类型。

Object obj = "Hello World";

if (obj instanceof String) {
    String str = (String) obj;
    System.out.println("这是一个字符串：" + str);
}

class

获取类的 Class 对象。

Class<?> stringClass = String.class;
System.out.println("类名：" + stringClass.getName());

// 也可以通过对象获取
String str = "Hello";
Class<?> objClass = str.getClass();

其他重要关键字

void

表示方法不返回任何值。

public void printMessage() {
    System.out.println("这个方法不返回任何值");
}

interface

定义接口。

interface Drawable {
    void draw(); // 接口方法（默认是 public abstract）
    
    default void defaultMethod() {
        System.out.println("默认方法");
    }
}

class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

implements

实现接口。

class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

extends

继承类。

class Animal {
    public void eat() {
        System.out.println("动物在吃东西");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("狗在叫");
    }
}

保留字

以下是 Java 保留的关键字，目前没有使用，但为将来的版本保留：

const：常量声明（未使用，使用 final 代替）
goto：跳转语句（未使用，Java 不支持 goto）

严格浮点关键字

strictfp

确保浮点计算的可移植性。

strictfp class StrictMath {
    public double calculate(double a, double b) {
        return a * b; // 严格按照 IEEE 754 标准计算
    }
}

断言关键字

assert

用于调试时的断言检查。

public void validateInput(int value) {
    assert value > 0 : "值必须大于0";
    System.out.println("输入值：" + value);
}

枚举关键字

enum

定义枚举类型。

enum Color {
    RED, GREEN, BLUE;
    
    public void printColor() {
        System.out.println("颜色：" + this.name());
    }
}

public class EnumExample {
    public static void main(String[] args) {
        Color color = Color.RED;
        color.printColor();
    }
}

关键字使用注意事项

区分大小写：Java 关键字都是小写的，Public 不是关键字，但 public 是。
不能作为标识符：关键字不能用作变量名、方法名、类名等。

// 错误示例
int class = 10;    // 错误：class 是关键字
void if() {}       // 错误：if 是关键字

// 正确示例
int className = 10;  // 正确
void ifCondition() {} // 正确

上下文敏感：某些词在特定上下文中才是关键字，如 var（Java 10+）。
版本差异：不同 Java 版本可能引入新的关键字，如：
- Java 1.2：strictfp
- Java 1.4：assert
- Java 5：enum
- Java 10：var（上下文关键字）

实践建议

熟记常用关键字：重点掌握访问控制、程序控制、异常处理等常用关键字。
理解关键字含义：不仅要知道语法，更要理解每个关键字的作用和使用场景。
避免命名冲突：选择变量名时避免使用关键字或与关键字相似的名称。
合理使用修饰符：根据实际需要选择合适的访问修饰符和其他修饰符。
异常处理：正确使用 try-catch-finally 和 throws 关键字处理异常。

通过掌握这些 Java 关键字，您将能够更好地理解和编写 Java 代码，构建出结构清晰、功能完善的 Java 应用程序。

#Java 关键字

#关键字概述

#访问控制关键字

#public

#private

#protected

#类、方法和变量修饰符

#static

#final

#abstract

#synchronized

#volatile

#程序控制语句

#条件语句

#if, else

#switch, case, default

#循环语句

#for

#while

#do

#跳转语句

#break

#continue

#return

#错误处理关键字

#try, catch, finally

#throw

#throws

#包相关关键字

#package

#import

#基本数据类型关键字

#整数类型

#浮点类型

#字符和布尔类型

#变量引用关键字

#this

#super

#null

#对象和类型相关关键字

#new

#instanceof

#class

#其他重要关键字

#void

#interface

#implements

#extends

#保留字

#严格浮点关键字

#strictfp

#断言关键字

#assert

#枚举关键字

#enum

#关键字使用注意事项

#实践建议