【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.");}}
}

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

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

public class ForLoopDemo {public static void main(String[] args) {// 使用 for 循环打印数字 1 到 5for (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 到 4while (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 {@Overridevoid 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 {@Overridevoid 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技术核心学习团队。一起探索科技的未来，共同成长。