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

)

博主 默语带您 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.");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

这个示例演示了如何使用 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);
        }
    }
}
1
2
3
4
5
6
7
8

这个示例展示了如何使用 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");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这个示例演示了如何使用 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++;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

这个示例展示了如何使用 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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这个示例演示了如何使用 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]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10

这个示例展示了如何使用 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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这个示例演示了如何使用 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;
    }
}
1
2
3
4
5
6
7
8
9
10

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

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("这是一个受保护方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

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
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这个示例展示了如何使用 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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这个示例演示了如何使用 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("自定义方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

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("这是子类的消息");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这个示例演示了如何使用 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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这个示例展示了如何使用 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;
    }
}
1
2
3
4
5
6
7
8
9
10

这个示例演示了如何使用 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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这个示例演示了如何使用 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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

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

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

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

        System.out.println("年龄合法");
    }
}
1
2
3
4
5
6
7
8
9
10

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

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

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

    public static void main(String[] args) {
        System.loadLibrary("NativeLibrary"); // 加载本地库
        nativeMethod(); // 调用本地方法
    }
}
1
2
3
4
5
6
7
8

这个示例演示了如何使用 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);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在 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;
    }
}
1
2
3
4
5
6
7
8
9
10

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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 调用的父类方法
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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 类型");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

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

二、Java 标识符

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

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

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

int age;
String firstName;
double accountBalance;
1
2
3

三、命名规范

3.1 基本命名规范

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

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

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

class StudentRecord {
    int studentAge;
    final double PI_VALUE = 3.14159;
}
1
2
3
4

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技术核心学习团队。一起探索科技的未来，共同成长。