Java关键字和示例：深入了解常用关键字的用法

摘要
Java 关键字、标识符和命名规范
- 一、Java 关键字
- 常用关键字`DEMO`
- - 1. 示例代码使用 `if` 和 `else` 关键字：
  - 2. 示例代码使用 `for` 循环：
  - 3. 示例代码使用 `switch` 关键字：
  - 4. 示例代码使用 `while` 循环：
  - 5. 示例代码使用 `while` 循环读取用户输入：
  - 6. 示例代码使用 `for` 循环遍历数组：
  - 7. 示例代码使用 `try` 和 `catch` 处理异常：
  - 8. 示例代码使用 `static` 定义静态方法：
  - 9. 示例代码使用 `public`、`private` 和 `protected` 访问修饰符：
  - 10. 示例代码使用 `enum` 枚举类型：
  - 11. 示例代码使用 `try`、`catch` 和 `finally` 处理异常：
  - 12. 示例代码使用 `interface` 接口：
  - 13. 示例代码使用 `extends` 关键字继承类：
  - 14. 示例代码使用 `static` 关键字创建静态成员：
  - 15. 示例代码使用 `return` 语句返回值：
  - 16. 示例代码使用 `volatile` 关键字：
  - 17. 示例代码使用 `break` 和 `continue` 关键字：
  - 18. 示例代码使用 `assert` 关键字：
  - 19. 示例代码使用 `native` 关键字：
  - 16. 示例代码使用 `goto` 关键字：
  - 17. 示例代码使用 `strictfp` 关键字：
  - 18. 示例代码使用 `this` 关键字：
  - 19. 示例代码使用 `super` 关键字：
  - 20. 示例代码使用 `instanceof` 关键字：
- 二、Java 标识符
- 三、命名规范
- - 3.1 基本命名规范
  - 3.2 高级命名规范
  - - 3.2.1 类名
    - 3.2.2 方法名
    - 3.2.3 变量名
    - 3.2.4 常量名
    - 3.2.5 包命名
    - 3.2.6 泛型命名
- 结论

)

在这里插入图片描述

博主默语带您 Go to New World.
✍ 个人主页—— 默语的博客👦🏻
《java 面试题大全》
🍩惟余辈才疏学浅，临摹之作或有不妥之处，还请读者海涵指正。☕🍭
《MYSQL从入门到精通》数据库是开发者必会基础之一~
🪁 吾期望此文有资助于尔，即使粗浅难及深广，亦备添少许微薄之助。苟未尽善尽美，敬请批评指正，以资改进。！💻⌨

🪁🍁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🍁🐥

在这里插入图片描述

摘要

本文深入探讨了Java编程语言中的常用关键字及其示例用法。我们从基本的数据类型声明开始，逐步介绍了控制流、异常处理、多线程、类继承等多个关键字的实际应用。通过详细的示例代码，读者将能够更好地理解这些关键字的功能和用法，为Java编程提供了坚实的基础。无论是新手还是有经验的开发人员，都可以从本文中获得有关Java关键字的重要知识和实用技巧。

Java 关键字、标识符和命名规范

在Java编程中，关键字、标识符和命名规范是构建清晰、可维护代码的关键因素。本文将深入探讨这些概念，并提供示例以帮助您更好地理解它们。

一、Java 关键字

Java关键字是具有特殊含义的保留单词，它们构成了Java编程语言的基础，开发人员不能重新定义这些关键字。下面是Java的一些关键字及其用途：

abstract：用于表明类或成员方法具有抽象属性，即不能被实例化的类或未完整实现的方法。
assert：主要用于调试目的，用来断言某个条件为真。如果条件不满足，将抛出AssertionError。
boolean：声明布尔类型的关键字，表示真或假值。
break：用于跳出当前循环或switch语句。
byte：声明字节类型的关键字，用于存储小整数值。
case：用在switch语句中，表示一个分支的情况。
catch：用于异常处理，用来捕获并处理异常。
char：声明字符类型的关键字，用于存储单个字符。
class：声明一个类。
const：在Java中已被废弃，不再使用。
continue：用于结束当前循环的本次迭代，然后继续下一次迭代。
default：用在switch语句中，表示默认情况。
do：用于创建一个do-while循环结构，至少执行一次循环体。
double：声明双精度浮点数类型的关键字。
else：用在条件语句中，表示当条件不满足时执行的块。
enum：用于声明枚举类型，表示一组命名的常量。
extends：用于表示一个类是另一个类的子类，或者一个接口是另一个接口的子接口。
final：用于修饰类、方法或变量，表示它们不可继承、重写或修改。也用于定义常量。
finally：用于异常处理，声明的代码块通常会在try或catch块执行后执行，无论是否发生异常。
float：声明单精度浮点数类型的关键字。
for：用于创建for循环，重复执行一段代码。
goto：在Java中已被废弃，不再使用。
if：用于条件语句，根据条件执行不同的代码块。
implements：用于表示一个类实现了给定的接口。
import：用于导入其他类或包，以便在当前代码中使用。
instanceof：用于测试一个对象是否是指定类型的实例。
int：声明整数类型的关键字。
interface：用于声明接口，接口是一种抽象的、纯粹的规范。
long：声明长整数类型的关键字。
native：用于声明一个方法是由与计算机相关的本地语言实现的。
new：用于创建新的实例对象。
package：用于声明包，包是一种组织和管理类的方式。
private：用于指定私有访问控制方式，只能在类内部访问。
protected：用于指定受保护的访问控制方式，可以在同一包内或子类中访问。
public：用于指定公共访问控制方式，可以被任何类访问。
return：用于从成员方法中返回值。
short：声明短整数类型的关键字。
static：用于表示静态属性或方法，属于类而不是实例。
strictfp：用于声明单精度或双精度浮点数表达式遵循IEEE 754算术规范。
super：用于表示当前对象的父类型的引用或调用父类型的构造方法。
switch：用于创建分支语句结构，根据不同的条件执行不同的分支。
synchronized：用于表示一段代码需要同步执行，通常与多线程编程相关。
this：用于指向当前实例对象的引用。
throw：用于抛出异常。
throws：用于声明在当前定义的成员方法中可能抛出的异常。
transient：用于声明不需要序列化的成员域。
try：用于尝试执行可能抛出异常的代码块。
void：用于声明当前成员方法没有返回值。
volatile：用于表示两个或多个变量必须同步地发生变化，通常与多线程编程相关。
while：用于创建循环结构，根据条件反复执行一段代码。

此外，Java还有3个特殊直接量：true、false、null，它们也不能用作标识符。

常用关键字`DEMO`

1. 示例代码使用 `if` 和 `else` 关键字：

public class IfElseDemo {
    public static void main(String[] args) {
        int number = 10;

        // 使用 if 来判断条件是否成立
        if (number > 5) {
            System.out.println("Number is greater than 5.");
        } else {
            System.out.println("Number is not greater than 5.");
        }
    }
}

这个示例演示了如何使用 if 和 else 来根据条件执行不同的代码块。

2. 示例代码使用 `for` 循环：

public class ForLoopDemo {
    public static void main(String[] args) {
        // 使用 for 循环打印数字 1 到 5
        for (int i = 1; i <= 5; i++) {
            System.out.println("Number: " + i);
        }
    }
}

这个示例展示了如何使用 for 循环来重复执行一段代码。

3. 示例代码使用 `switch` 关键字：

public class SwitchDemo {
    public static void main(String[] args) {
        int dayOfWeek = 3;

        // 使用 switch 来根据不同的值执行不同的分支
        switch (dayOfWeek) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Other day");
        }
    }
}

这个示例演示了如何使用 switch 来根据不同的值执行不同的分支代码，同时使用 break 来终止分支。

4. 示例代码使用 `while` 循环：

public class WhileLoopDemo {
    public static void main(String[] args) {
        int count = 0;

        // 使用 while 循环打印数字 0 到 4
        while (count < 5) {
            System.out.println("Count: " + count);
            count++;
        }
    }
}

这个示例展示了如何使用 while 循环来重复执行一段代码，直到条件不再满足。

5. 示例代码使用 `while` 循环读取用户输入：

import java.util.Scanner;

public class WhileInputDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input;

        // 使用 while 循环读取用户输入，直到用户输入 "exit"
        while (true) {
            System.out.print("请输入内容（输入 'exit' 退出）: ");
            input = scanner.nextLine();
            
            if (input.equals("exit")) {
                System.out.println("退出循环。");
                break;
            }
            
            System.out.println("你输入的是: " + input);
        }
        
        scanner.close();
    }
}

这个示例演示了如何使用 while 循环来读取用户输入，直到用户输入 “exit” 为止。

6. 示例代码使用 `for` 循环遍历数组：

public class ForArrayDemo {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        // 使用 for 循环遍历数组并打印每个元素
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Element at index " + i + ": " + numbers[i]);
        }
    }
}

这个示例展示了如何使用 for 循环来遍历数组并访问数组的元素。

7. 示例代码使用 `try` 和 `catch` 处理异常：

public class ExceptionHandlingDemo {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.err.println("除法运算出错: " + e.getMessage());
        }
    }

    public static int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("除数不能为零");
        }
        return a / b;
    }
}

这个示例演示了如何使用 try 和 catch 来处理异常，以避免程序崩溃。

8. 示例代码使用 `static` 定义静态方法：

public class StaticMethodDemo {
    public static void main(String[] args) {
        int sum = add(5, 3);
        System.out.println("Sum: " + sum);
    }

    public static int add(int a, int b) {
        return a + b;
    }
}

这个示例演示了如何定义和调用静态方法。

9. 示例代码使用 `public`、`private` 和 `protected` 访问修饰符：

public class AccessModifiersDemo {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.publicMethod();
        // myClass.privateMethod(); // 私有方法无法在外部访问
        // myClass.protectedMethod(); // 受保护方法无法在不同包的外部访问
    }
}

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

    private void privateMethod() {
        System.out.println("这是一个私有方法");
    }

    protected void protectedMethod() {
        System.out.println("这是一个受保护方法");
    }
}

这个示例演示了如何使用不同的访问修饰符来控制方法的访问权限。

10. 示例代码使用 `enum` 枚举类型：

public class EnumDemo {
    public static void main(String[] args) {
        DayOfWeek day = DayOfWeek.WEDNESDAY;

        switch (day) {
            case MONDAY:
                System.out.println("星期一");
                break;
            case TUESDAY:
                System.out.println("星期二");
                break;
            case WEDNESDAY:
                System.out.println("星期三");
                break;
            default:
                System.out.println("其他");
        }
    }
}

enum DayOfWeek {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

这个示例展示了如何使用 enum 枚举类型来表示一组命名的常量。

11. 示例代码使用 `try`、`catch` 和 `finally` 处理异常：

public class ExceptionHandlingFinallyDemo {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.err.println("除法运算出错: " + e.getMessage());
        } finally {
            System.out.println("无论是否发生异常，都会执行这里的代码块");
        }
    }

    public static int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("除数不能为零");
        }
        return a / b;
    }
}

这个示例演示了如何使用 try、catch 和 finally 来处理异常，确保无论是否发生异常，finally 中的代码都会执行。

12. 示例代码使用 `interface` 接口：

public class InterfaceDemo {
    public static void main(String[] args) {
        MyInterfaceImpl myObj = new MyInterfaceImpl();
        myObj.display();
        myObj.show();
    }
}

interface MyInterface {
    void display();
}

class MyInterfaceImpl implements MyInterface {
    public void display() {
        System.out.println("实现了 display() 方法");
    }

    void show() {
        System.out.println("自定义方法");
    }
}

这个示例演示了如何定义接口和实现接口，以及如何使用接口的方法。

13. 示例代码使用 `extends` 关键字继承类：

public class InheritanceDemo {
    public static void main(String[] args) {
        ChildClass child = new ChildClass();
        child.printMessage();
    }
}

class ParentClass {
    void printMessage() {
        System.out.println("这是父类的消息");
    }
}

class ChildClass extends ParentClass {
    @Override
    void printMessage() {
        System.out.println("这是子类的消息");
    }
}

这个示例演示了如何使用 extends 关键字来创建类的继承关系，子类可以覆盖父类的方法。

14. 示例代码使用 `static` 关键字创建静态成员：

public class StaticDemo {
    public static void main(String[] args) {
        Employee emp1 = new Employee("Alice");
        Employee emp2 = new Employee("Bob");
        Employee.displayTotalEmployees();
    }
}

class Employee {
    private static int totalEmployees = 0;
    private String name;

    public Employee(String name) {
        this.name = name;
        totalEmployees++;
    }

    public static void displayTotalEmployees() {
        System.out.println("总员工数: " + totalEmployees);
    }
}

这个示例展示了如何使用 static 关键字来创建静态成员变量和方法，静态成员与类相关联而不是实例。

15. 示例代码使用 `return` 语句返回值：

public class ReturnDemo {
    public static void main(String[] args) {
        int result = addNumbers(5, 3);
        System.out.println("和为: " + result);
    }

    public static int addNumbers(int a, int b) {
        return a + b;
    }
}

这个示例演示了如何使用 return 语句从方法中返回值。

16. 示例代码使用 `volatile` 关键字：

public class VolatileDemo {
    private static volatile boolean flag = false;

    public static void main(String[] args) {
        Thread writerThread = new Thread(() -> {
            flag = true;
            System.out.println("标志位已设置为 true");
        });

        Thread readerThread = new Thread(() -> {
            while (!flag) {
                // 等待标志位变为 true
            }
            System.out.println("标志位已变为 true");
        });

        writerThread.start();
        readerThread.start();
    }
}

这个示例演示了如何使用 volatile 关键字来保证多个线程之间的可见性。

17. 示例代码使用 `break` 和 `continue` 关键字：

public class BreakContinueDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("遇到 3，跳过");
                continue;
            }
            if (i == 4) {
                System.out.println("遇到 4，终止循环");
                break;
            }
            System.out.println("Number: " + i);
        }
    }
}

这个示例演示了如何使用 break 和 continue 关键字来控制循环的执行流程。

18. 示例代码使用 `assert` 关键字：

public class AssertDemo {
    public static void main(String[] args) {
        int age = 15;

        // 使用 assert 断言条件是否为真
        assert age >= 18 : "年龄必须大于等于 18";

        System.out.println("年龄合法");
    }
}

这个示例演示了如何使用 assert 关键字来进行断言检查，用于调试和验证条件是否成立。

19. 示例代码使用 `native` 关键字：

public class NativeDemo {
    public static native void nativeMethod();

    public static void main(String[] args) {
        System.loadLibrary("NativeLibrary"); // 加载本地库
        nativeMethod(); // 调用本地方法
    }
}

这个示例演示了如何使用 native 关键字来声明并调用本地方法，通常与本地库一起使用。

16. 示例代码使用 `goto` 关键字：

// Java 不支持 goto 关键字，这里提供一个示例以展示 Java 中的标签和 break 用法
public class GotoDemo {
    public static void main(String[] args) {
        outerLoop:
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    break outerLoop; // 使用标签和 break 模拟 goto
                }
                System.out.println("i=" + i + ", j=" + j);
            }
        }
    }
}

在 Java 中，没有 goto 关键字，但可以使用标签和 break 语句模拟跳转到指定位置。

17. 示例代码使用 `strictfp` 关键字：

public class StrictfpDemo {
    public strictfp static void main(String[] args) {
        double result = divide(10.0, 3.0);
        System.out.println("Result: " + result);
    }

    public strictfp static double divide(double a, double b) {
        return a / b;
    }
}

strictfp 关键字用于声明浮点数表达式必须遵循 IEEE 754 标准，以确保在不同平台上的一致性。

18. 示例代码使用 `this` 关键字：

public class ThisKeywordDemo {
    private String name;

    public ThisKeywordDemo(String name) {
        this.name = name; // 使用 this 关键字区分成员变量和构造函数参数
    }

    public void printName() {
        System.out.println("Name: " + this.name); // 使用 this 关键字访问成员变量
    }

    public static void main(String[] args) {
        ThisKeywordDemo obj = new ThisKeywordDemo("Alice");
        obj.printName();
    }
}

this 关键字用于区分成员变量和局部变量，以及在构造函数中引用当前对象。

19. 示例代码使用 `super` 关键字：

class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("狗发出汪汪声");
    }

    void display() {
        super.makeSound(); // 使用 super 关键字调用父类方法
    }
}

public class SuperKeywordDemo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // 调用子类方法
        dog.display(); // 调用子类中使用 super 调用的父类方法
    }
}

super 关键字用于调用父类的方法或访问父类的成员。

20. 示例代码使用 `instanceof` 关键字：

public class InstanceOfDemo {
    public static void main(String[] args) {
        Object obj = "Hello, Java";

        if (obj instanceof String) {
            System.out.println("obj 是 String 类型");
        } else {
            System.out.println("obj 不是 String 类型");
        }
    }
}

instanceof 关键字用于测试一个对象是否是指定类型的实例。

在这里插入图片描述

二、Java 标识符

标识符是由程序员定义的名称，用于表示类、方法、变量等。命名标识符时需要遵循一些规则：

由字母、数字、下划线(_)和美元符号($)组成。
不能以数字开头。
区分大小写。
不能使用Java关键字或保留字作为标识符。

以下是一些有效的标识符示例：

int age;
String firstName;
double accountBalance;

三、命名规范

3.1 基本命名规范

为了使代码清晰易读，我们应该遵循以下基本命名规范：

类名和接口名：每个单词首字母大写，采用驼峰命名法，例如：StudentRecord。
包名：小写字母，多个单词用点分隔，例如：com.example.myapp。
变量名和方法名：采用驼峰命名法，首字母小写，例如：studentAge。
常量名：全大写字母，用下划线分隔多个单词，例如：PI_VALUE。

以下是符合基本命名规范的示例：

class StudentRecord {
    int studentAge;
    final double PI_VALUE = 3.14159;
}

3.2 高级命名规范

高级命名规范是为了提高代码可读性和维护性而制定的，根据开发经验指定的，建议遵守。

3.2.1 类名

通常使用名词，具有清晰的含义，采用驼峰命名法。
避免使用中文缩写或不清晰的命名。

3.2.2 方法名

通常使用动词或动词短语，采用驼峰命名法，首字母小写。
常见的命名约定包括get前缀用于返回数据，set前缀用于设置数据，is前缀用于布尔值的方法等。
通常情况下，我们采用见名知意的名词，并使用驼峰命名法，首字母小写。

获取数据的方法通常以 “get” 作为前缀，例如 “getUserList”、“getMyData”。
设置数据的方法通常以对应的动词作为前缀，例如 “addUser”、“updateUser”。
查询数据的方法通常以 “select” 或 “find” 作为前缀。
删除数据的方法通常以 “delete” 作为前缀，例如 “deleteUser”。
具备条件的方法通常使用 “by” 作为前缀进行命名。
具备判断性质的方法通常以 “is” 作为前缀进行命名。
具备测试性质的方法通常以 “test” 作为前缀进行命名。
在命名方法时，尽量使用具体而清晰的词汇，避免使用缩写或过于简略的命名，以确保代码的可理解性。
如果一个方法用于验证或检查某些条件，可以使用 “check” 作为前缀，例如 “checkPermission”。
对于涉及时间的操作，可以使用 “calculate” 作为前缀，例如 “calculateAge”。
如果一个方法执行复杂的操作，可以使用描述性的动词，例如 “processData” 或 “generateReport”。
在命名时，避免使用保留字或关键字，以免引发潜在的问题。

3.2.3 变量名

使用有意义的名词，采用驼峰命名法。
避免使用中文缩写或下划线作为连接符。

3.2.4 常量名

使用全大写字母，用下划线分隔多个单词。
常量名应具有清晰的含义。

3.2.5 包命名

包名应使用小写字母，多层包之间用点分隔。
通常采用域名倒写的方式进行命名，例如：com.example.myapp。

3.2.6 泛型命名

泛型类型通常使用单个大写字母表示，例如：

T：通常表示类型。
K：通常表示键。
V：通常表示值，有时候会使用 U 或 S 表示通用类型。
?：通常表示不确定的 Java 类型。
N：通常表示 Number，常用于表示数值类型。
T：通常表示 Type（类型），通常指代类。
K：通常表示 Key（键），常用于 Map 中。
V：通常表示 Value（值），常用于 Map 中，通常与 K 成对出现。
X：通常表示异常的类型。。

结论

遵守Java的关键字、标识符和命名规范是编写清晰、可维护代码的关键。通过正确使用这些概念，您可以提高代码的可读性和可维护性，从而更轻松地开发和维护Java应用程序。希望本文提供的信息对您有所帮助，让您更好地理解和应用Java编程中的这些基本概念。

如对本文内容有任何疑问、建议或意见，请联系作者，作者将尽力回复并改进📓；(联系微信:Solitudemind )

点击下方名片，加入IT技术核心学习团队。一起探索科技的未来，共同成长。

在这里插入图片描述

【JAVA-Day04】Java关键字和示例：深入了解常用关键字的用法

Java关键字和示例：深入了解常用关键字的用法

摘要

Java 关键字、标识符和命名规范

一、Java 关键字

常用关键字DEMO

1. 示例代码使用 if 和 else 关键字：

2. 示例代码使用 for 循环：

3. 示例代码使用 switch 关键字：

4. 示例代码使用 while 循环：

5. 示例代码使用 while 循环读取用户输入：

6. 示例代码使用 for 循环遍历数组：

7. 示例代码使用 try 和 catch 处理异常：

8. 示例代码使用 static 定义静态方法：

9. 示例代码使用 public、private 和 protected 访问修饰符：

10. 示例代码使用 enum 枚举类型：

11. 示例代码使用 try、catch 和 finally 处理异常：

12. 示例代码使用 interface 接口：

13. 示例代码使用 extends 关键字继承类：

14. 示例代码使用 static 关键字创建静态成员：

15. 示例代码使用 return 语句返回值：

16. 示例代码使用 volatile 关键字：

17. 示例代码使用 break 和 continue 关键字：

18. 示例代码使用 assert 关键字：

19. 示例代码使用 native 关键字：

16. 示例代码使用 goto 关键字：

17. 示例代码使用 strictfp 关键字：

18. 示例代码使用 this 关键字：

19. 示例代码使用 super 关键字：

20. 示例代码使用 instanceof 关键字：

二、Java 标识符

三、命名规范

3.1 基本命名规范

3.2 高级命名规范

3.2.1 类名

3.2.2 方法名

3.2.3 变量名

3.2.4 常量名

3.2.5 包命名

3.2.6 泛型命名

结论

相关文章

常用关键字`DEMO`

1. 示例代码使用 `if` 和 `else` 关键字：

2. 示例代码使用 `for` 循环：

3. 示例代码使用 `switch` 关键字：

4. 示例代码使用 `while` 循环：

5. 示例代码使用 `while` 循环读取用户输入：

6. 示例代码使用 `for` 循环遍历数组：

7. 示例代码使用 `try` 和 `catch` 处理异常：

8. 示例代码使用 `static` 定义静态方法：

9. 示例代码使用 `public`、`private` 和 `protected` 访问修饰符：

10. 示例代码使用 `enum` 枚举类型：

11. 示例代码使用 `try`、`catch` 和 `finally` 处理异常：

12. 示例代码使用 `interface` 接口：

13. 示例代码使用 `extends` 关键字继承类：

14. 示例代码使用 `static` 关键字创建静态成员：

15. 示例代码使用 `return` 语句返回值：

16. 示例代码使用 `volatile` 关键字：

17. 示例代码使用 `break` 和 `continue` 关键字：

18. 示例代码使用 `assert` 关键字：

19. 示例代码使用 `native` 关键字：

16. 示例代码使用 `goto` 关键字：

17. 示例代码使用 `strictfp` 关键字：

18. 示例代码使用 `this` 关键字：

19. 示例代码使用 `super` 关键字：

20. 示例代码使用 `instanceof` 关键字：