Java关键字汇总

一、关键字汇总

• 访问控制：private、protected、public、default
• 修饰符：class、abstract、extends、implements、interface、final、strictfp、static、synchronized、transient、volatile、native、enum
• 程序控制：for、break、continue、do、while、if、else、switch、case、default、instanceof、return、assert
• 异常处理：try、catch、finally、throw、throws
• 基本类型：boolean、byte、char、short、int、long、float、double
• 变量引用：new、super、this、void、null、true、false
• 包：import、package
• 保留字：goto、const

所有的关键字都是小写。

二、访问控制

作用域	当前类	当前包	子类	其他包
private	✓	x	x	x
default	✓	✓	x	x
protected	✓	✓	✓	x
public	✓	✓	✓	✓

说明：✓表示可以访问，x表示不能访问。

2.1 private(私有化)

private关键字是访问控制修饰符，可以应用于内部类、方法或类的变量字段。只能在声明private(内部)类、方法或字段的类中引用这些类、方法或字段。在类的外部或者对于子类而言，它们是不可见的。

2.2 default(缺省)

default关键字是可以应用于类、方法或类的变量字段的访问控制修饰符。当没有指定类的访问权限的时候，虚拟机就会默认的形式给类划定界限！默认修饰的类无法被其他包的类继承！

2.3 protected(受保护的)

protected关键字是可以应用于内部类、方法或类的变量字段的访问控制修饰符。可以在声明protected类、方法或字段的类、同一个包中的其他任何类以及任何子类(无论子类是在哪个包中声明的)中引用这些类、方法或字段。

2.4 public(公共的)

public关键字是可以应用于类、方法或类的变量字段的访问控制修饰符。可以在其他任何类或包中引用public类、方法或字段。

三、修饰符

3.1 class(类)

class关键字用来声明新的Java类，该类是相关变量和/或方法的集合。类是面向对象的程序设计方法的基本构造单位。要使用类，通常使用new操作符将类的对象实例化，然后调用类的方法来访问类的功能。

3.2 abstract(声明抽象)

abstract关键字可以修改类或方法。abstract类可以扩展(增加子类)，但不能直接实例化。abstract方法不在声明它的类中实现，但必须在某个子类中重写。采用abstract方法的类本来就是抽象类，并且必须声明为abstract。

3.3 extends(继承)

extends关键字用在class或interface声明中，用于指示所声明的类或接口是其名称后跟有extends关键字的类或接口的子类。子类继承父类的所有public和protected变量和方法(但是不包括构造函数)。子类可以重写父类的任何非final方法。一个类只能扩展一个其他类，但一个接口可以继承多个接口。

3.4 implements(实现)

implements关键字在class声明中使用，以指示所声明的类提供了在implements关键字后面的名称所指定的接口中所声明的所有方法的实现。类必须提供在接口中所声明的所有方法的实现。一个类可以实现多个接口。

3.5 interface(接口)

interface关键字用来声明新的Java接口，接口是方法的集合。

3.6 final(不可改变)

在Java中，final关键字可以用来修饰类、方法和变量(包括成员变量和局部变量)。final方法在编译阶段绑定，称为静态绑定(static binding)。

下面就从这四个方面来了解一下final关键字的基本用法。

3.6.1 修饰类

当用final修饰一个类时，表明这个类不能被继承，不能有子类。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

3.6.2 修饰方法

下面这段话摘自《Java编程思想》：

使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。因此，如果只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final的。

还有就是，类的private方法会隐式地被指定为final方法。

3.6.3 修饰变量

修饰变量是final用得最多的地方。

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。引用变量被final修饰之后，虽然不能再指向其他对象，但是它指向的对象的内容是可变的。

3.6.4 修饰参数

当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值或者引用指向。道理同final变量。

3.7 strictfp(精准)

strictfp的意思是strict float point，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令人满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果想让浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。

可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字。

3.8 static(静态)

static可以用于修饰属性，可以修饰代码块，也可以用于修饰方法，还可以用于修饰类。

3.8.1 修饰属性

无论一个类生成了多少个对象，所有这些对象共同使用唯一一份静态的成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之发生变化。如果一个成员变量是static的，那么我们可以通过‘类名.成员变量名’的方式来使用它。

3.8.2 修饰方法

static修饰的方法叫做静态方法。对于静态方法来说，可以使用‘类名.方法名’的方式来访问。静态方法只能继承，不能重写(Override)，因为重写是用于表现多态的，重写只能适用于实例方法，而静态方法是可以不生成实例直接用类名来调用，这就会与重写的定义所冲突，与多态所冲突，所以静态方法不能重写，只能是隐藏。

static方法与非static方法：不能在静态方法中访问非静态成员变量；可以在静态方法中访问静态的成员变量。可以在非静态方法中访问静态的成员变量：因为静态方法可以直接用类名来调用，而非静态成员变量是在创建对象实例时才为变量分配内存和初始化变量值。

不能在静态方法中使用this关键字：因为静态方法可以直接用类名来调用，而this实际上是创建实例时，实例对应的一个应用，所以不能在静态方法上使用this。

3.8.3 修饰代码块

静态代码块。静态代码块的作用也是完成一些初始化工作。首先执行静态代码块，然后执行构造方法。静态代码块在类被加载的时候执行，而构造方法是在生成对象的时候执行；要想调用某个类来生成对象，首先需要将类加载到Java虚拟机上(JVM)，然后由JVM加载这个类来生成对象。

类的静态代码块只会执行一次，是在类被加载的时候执行的，因为每个类只会被加载一次，所以静态代码块也只会被执行一次；而构造方法则不然，每次生成一个对象的时候都会调用类的构造方法，所以new一次就会调用构造方法一次。如果继承体系中既有构造方法，又有静态代码块，那么首先执行最顶层的类的静态代码块，一直执行到最底层类的静态代码块，然后再去执行最顶层类的构造方法，一直执行到最底层类的构造方法。注意：静态代码块只会执行一次。

3.8.4 修饰类

这个有点特殊，首先，static是可以用来修饰类的，但是static是不允许用来修饰普通类，只能用来修饰内部类，被static所修饰的内部类可以用new关键字来直接创建一个实例，不需要先创建外部类实例。static内部类可以被其他类实例化和引用(即使它是顶级类)。

其实理解起来也简单。因为static主要是修饰类里面的成员，包括内部类、属性、方法这些。修饰这些变量的目的也很单纯，那就是暗示这个成员在该类之中是唯一的一份拷贝，即便是不断的实例化该类，所有的这个类的对象都会共享这些static成员。这样就好办了。因为是共享的、唯一的，所以，也就不需要在实例化这个类以后再通过这个类来调用这个成员了，显然有点麻烦，所以就简单一点，直接通过类名直接调用static成员，更加直接。然而这样设置之后，就出现了一个限制，就是，static方法之中不能访问非static属性，因为这个时候非static属性可能还没有给他分配内存，该类还没有实例化。

所以，通常，static关键字意味着应用它的实体在声明该实体的类的任何特定实例外部可用。

可以从类的外部调用static方法，而不用首先实例化该类。这样的引用始终包括类名作为方法调用的限定符。

3.9 synchronized(同步)

synchronized关键字可以应用于方法或语句块，并为一次只应由一个线程执行的关键代码段提供保护。

synchronized关键字可防止代码的关键代码段一次被多个线程执行。

3.10 transient(短暂)

transient关键字可以应用于类的成员变量，以便指出该成员变量不应在包含它的类实例已序列化时被序列化。

当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

3.11 volatile(易失)

volatile关键字用于表示可以被多个线程异步修改的成员变量。

注意：volatile关键字在许多Java虚拟机中都没有实现。

volatile的目标用途是为了确保所有线程所看到的指定变量的值都是相同的。

3.12 native(本地)

native关键字可以应用于方法，以指示该方法是用Java以外的语言实现的，方法对应的实现不是在当前文件，而是在用其他语言(如C和C++)实现的文件中。

Java不是完美的，Java的不足除了体现在运行速度上要比传统的C++慢许多之外，Java无法直接访问到操作系统底层(如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。

3.13 enum(枚举)

枚举类型(Enumerated Type)很早就出现在编程语言中，它被用来将一组类似的值包含到一种类型当中。而这种枚举类型的名称则会被定义成独一无二的类型描述符，在这一点上和常量的定义相似。不过相比较常量类型，枚举类型可以为申明的变量提供更大的取值范围。

四、程序控制

4.1 流程判断

if (布尔值) {
    // ...
} else {
    // ...
}

4.2 for(循环)

for (int i = 0; i < 10; i++) {
    // ...
}

4.3 fore(循环)

for (数据类型 变量值 : 数组) {
    // ...
}

4.4 while(循环)

while (布尔值) {
    // ...
}

4.5 do...while(循环)

do {
    // ...
} while (布尔值);

4.6 switch(选择)

switch (变量) {
    case 值1 :
        // 语句
        break; // 可选
    case 值2 :
        // 语句
        break; // 可选
    // 你可以有任意数量的case语句
    default : // 可选
        // 语句
}

java 17 switch增加了null值判断优化和类型匹配自动转换功能。

switch (o) {
    case null      -> System.out.println("");
    case Integer i -> String.format("int %d", i);
    case Long l    -> String.format("long %d", l);
    case Double d  -> String.format("double %f", d);
    case String s  -> String.format("String %s", s);
    default        -> o.toString();
}    

4.7 instanceof(对象类型判断)

result = 需要判断的对象 instanceof 已知对象
// result为布尔值

从Java 16开始，可以对instanceof中的变量值进行修改。

// 以前的写法：(先判断是否为String类型，然后做类型的强制转换，然后对字符串进行操作，一共三步)
Object value = map.get("key");
if (value instanceof String) {
    String tempStr = (String) value;
    System.out.println(tempStr.substring(1));
}

// 新写法：(先判断是否为String类型，符合则自动做类型的强制转换，然后对字符串进行操作，一共两步)
Object value = map.get("key1");
if (value instanceof String tempStr) {
    System.out.println(tempStr.substring(1));
} 

4.8 continue(继续)

continue：表示跳过当前程序，继续下一个，一般用于循环语句。

for (int i = 0; i < 10; i++) {
    if (i == 6) {
        // 如果i等于6，就跳过，进行下一次循环
        continue;
    }
}

4.9 break(停止)

break：表示跳过当前程序，结束，一般用于循环语句。

for (int i = 0; i < 10; i++) {
    if (i == 6) {
        // 如果i等于6，就跳过，结束循环语句
        continue;
    }
}

4.10 return(返回)

return：结束当前流程，返回结果！

return null;

4.11 assert(断言)

assert：断言是为了方便调试程序，并不是发布程序的组成部分。

断言是通过关键字assert来定义的，一般的，它有两种形式。

// 例如：assert <bool expression>;
boolean isStudent = false; 
assert isStudent;
// 例如：assert <bool expression> : <message>;
boolean isSafe = false;
assert isSafe : "Not Safe at all";

五、异常处理

5.1 异常捕捉

try {
    // ...
} catch (Exception e) {
    // 异常
} finally {
    // 异常最终执行语句
}

拓展

public int test() {
    int x = 1;
    try {
        return ++x;
    } catch (Exception e) {
    } finally {
        ++x;
    }
    return x;
}

上面程序运行的结果是2而不是3。具体可以参考https://www.cnblogs.com/averey/p/4379646.html

当执行到return ++x;时，jvm在执行完++x后会在局部变量表里另外分配一个空间来保存当前x的值。finally里没有return，所以返回的只是try保存的值2而非3。

5.2 异常抛出

throw new Exception();

对应的方法需要声明跑出异常

throws Exception

例如：

public static void main(String[] args) throws Exception {
    try {
        System.out.println("hello world");
    } catch (Exception e) {
        throw new Exception();
    } finally {
        System.out.println("异常结束");
    }
}

六、基本数据类型

关键字	类型	大小位	默认值	数据范围
boolean	布尔型	8	false	true/false
byte	字节型	8	0	-128 ~ 127
char	字符型	16	空	0 ~ 65535
short	短整型	16	0	\(-2^{15}\) ~ \(2^{15}-1\)
int	整型	32	0	\(-2^{31}\) ~ \(2^{31}-1\)
long	长整型	64	0L	\(-2^{63}\) ~ \(2^{63}-1\)
float	浮点型	32	0F	\(-2^{149}\) ~ \(2^{128}-1\)
double	双精度	64	0D	\(-2^{1074}\) ~ \(2^{1024}-1\)

七、变量引用

关键字	作用
new	实例化对象
super	父类(超类)
this	当前对象
void	无返回值，用于方法返回类型
null	什么都没有，用于参数返回或变量定义
true	布尔类型值
false	布尔类型值

八、包相关

8.1 import(引入)

import关键字使一个包中的一个或所有类在当前Java源文件中可见。可以不使用完全限定的类名来引用导入的类。

当多个包包含同名的类时，许多Java程序员只使用特定的import语句(没有*)来避免不确定性。

8.2 package(包)

package关键字指定在Java源文件中声明的类所驻留的Java包。

package语句(如果出现)必须是Java源文件中的第一个非注释性文本。例：java.lang.Object。如果Java源文件不包含package语句，在该文件中定义的类将位于“默认包”中。请注意，不能从非默认包中的类引用默认包中的类。

九、保留字

正确识别java语言的关键字(keyword)和保留字(reserved word)是十分重要的。Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。识别java语言的关键字，不要和其他语言如c/c++的关键字混淆。

const和goto是java的保留字。

9.1 goto(跳转)

goto保留关键字，但无任何作用。结构化程序设计完全不需要goto语句即可完成各种流程，而goto语句的使用往往会使程序的可读性降低，所以Java不允许goto跳转。

9.2 const(静态)

const保留字，是一个类型修饰符，使用const声明的对象不能更新。与final某些类似。

十、总结

以上内容，只是简单的介绍一下java所有的关键字。其实每个关键字都有很深的含义和应用场景，而且每个java的版本，一些关键字的应用可能还会有些变动，比如jdk1.8接口里面的方法可以用default修饰，实现接口的类，不必显式的进行重写改方法，所以，需要在实际的工作中去不断的深入了解这些关键字！

参考

• Java关键字汇总