Java常用关键字详解

Bro_cat

于 2024-08-27 17:31:13 发布

阅读量611

点赞数 10

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/Broken_x/article/details/141607372

版权

Java 专栏收录该内容

34 篇文章 1 订阅

订阅专栏

在Java中，关键字是具有特殊含义的保留字，不能用作标识符（如变量名、类名、方法名等）。每个关键字都有其特定的作用、意义和用法。以下是一些常见Java关键字的详细解释：

1. `class`

作用：用于定义一个类。
意义：Java是面向对象的语言，类是对象的模板。
用法：

public class MyClass {
    // 类体
}

2. `public`

作用：表示公共的，可以被所有类访问。
意义：控制访问权限。
用法

public class MyClass {
    public int myField;
    public void myMethod() {
        // 方法体
    }
}

3. `private`

作用：表示私有的，只能被当前类访问。
意义：控制访问权限。
用法：

public class MyClass {
    private int myField;
    private void myMethod() {
        // 方法体
    }
}

4. `static`

作用：表示静态的，属于类而不属于类的实例。
意义：用于定义类级别的成员。
用法：

public class MyClass {
    static int myStaticField;
    static void myStaticMethod() {
        // 方法体
    }
}

5. `final`

作用：表示最终的，不可改变的。
意义：用于定义常量、不可继承的类或不可重写的方法。
用法：

public final class MyFinalClass {
    public static final int MY_CONSTANT = 10;
    public final void myFinalMethod() {
        // 方法体
    }
}

6. `void`

作用：表示方法没有返回值。
意义：定义方法的返回类型。
用法：

public void myMethod() {
    // 方法体
}

7. `if`

作用：用于条件判断。
意义：根据条件执行不同的代码块。
用法：

if (condition) {
    // 代码块
}

8. `else`

作用：与 if 一起使用，表示条件不成立时执行的代码块。
意义：提供备选执行路径。
用法：

if (condition) {
    // 代码块
} else {
    // 备选代码块
}

9. `for`

作用：用于循环。
意义：重复执行某段代码。
用法：

for (int i = 0; i < 10; i++) {
    // 循环体
}

10. `while`

作用：用于循环。
意义：当条件为真时重复执行某段代码。
用法：

while (condition) {
    // 循环体
}

11. `return`

作用：用于从方法中返回值。
意义：结束方法的执行并返回结果。
用法：

public int myMethod() {
    return 42;
}

12. `try`

作用：用于异常处理。
意义：尝试执行可能抛出异常的代码。
用法：

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 异常处理代码
}

13. `catch`

作用：用于捕获异常。
意义：处理 try 块中抛出的异常。
用法：

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 异常处理代码
}

14. `throw`

作用：用于手动抛出异常。
意义：在代码中显式地抛出异常。
用法：

if (condition) {
    throw new MyException("Something went wrong");
}

15. `throws`

作用：用于声明方法可能抛出的异常。
意义：告知调用者方法可能抛出的异常。
用法：

public void myMethod() throws MyException {
    // 方法体
}

16. `new`

作用：用于创建对象实例。
意义：分配内存并初始化对象。
用法：

MyClass obj = new MyClass();

17. `import`

作用：用于导入其他包中的类。
意义：简化类名的引用。
用法：

import java.util.ArrayList;

18. `package`

作用：用于声明类所在的包。
意义：组织和管理类文件。
用法：

package mypackage;

19. `interface`

作用：用于定义接口。
意义：定义一组抽象方法，供类实现。
用法：

public interface MyInterface {
    void myMethod();
}

20. `implements`

作用：用于实现接口。
意义：使类遵循接口定义的契约。
用法：

public class MyClass implements MyInterface {
    public void myMethod() {
        // 方法体
    }
}

21. `extends`

作用：用于继承类。
意义：使子类继承父类的属性和方法。
用法：

public class MySubClass extends MyClass {
    // 类体
}

22. `this`

作用：引用当前对象。
意义：用于区分局部变量和实例变量。
用法：

public class MyClass {
    private int myField;
    public void setMyField(int myField) {
        this.myField = myField;
    }
}

23. `super`

作用：引用父类对象。
意义：用于调用父类的方法或构造函数。
用法：

public class MySubClass extends MyClass {
    public MySubClass() {
        super();
    }
}

24. `abstract`

作用：用于定义抽象类或抽象方法。
意义：表示类或方法是抽象的，不能直接实例化。
用法：

public abstract class MyAbstractClass {
    public abstract void myAbstractMethod();
}

25. `synchronized`

作用：用于线程同步。
意义：确保方法或代码块在多线程环境下的安全性。
用法：

public synchronized void mySynchronizedMethod() {
    // 方法体
}

26. `volatile`

作用：用于声明变量。
意义：确保变量的修改对所有线程可见。
用法：

public class MyClass {
    private volatile int myVolatileField;
}

27. `transient`

作用：用于声明变量。
意义：表示变量在序列化时不会被保存。
用法：

public class MyClass implements Serializable {
    private transient int myTransientField;
}

28. `native`

作用：用于声明方法。
意义：表示方法是用其他语言（如C/C++）实现的。
用法：

public native void myNativeMethod();

29. `strictfp`

作用：用于声明类、接口或方法。
意义：确保浮点运算在不同平台上的一致性。
用法：

public strictfp class MyStrictfpClass {
    public strictfp void myStrictfpMethod() {
        // 方法体
    }
}

30. `assert`

作用：用于断言。
意义：在开发和测试阶段用于验证假设。
用法：

assert condition : "Message";

31. `enum`

作用：用于定义枚举类型。
意义：表示一组固定的常量。
用法：

public enum MyEnum {
    CONSTANT1, CONSTANT2
}

32. `instanceof`

作用：用于类型检查。
意义：判断对象是否是某个类的实例。
用法：

if (obj instanceof MyClass) {
    // 代码块
}

33. `default`

作用：用于接口中的默认方法。
意义：提供接口方法的默认实现。
用法：

public interface MyInterface {
    default void myDefaultMethod() {
        // 方法体
    }
}

34. `switch`

作用：用于多路选择。
意义：根据变量的值执行不同的代码块。
用法：

switch (variable) {
    case value1:
        // 代码块
        break;
    case value2:
        // 代码块
        break;
    default:
        // 默认代码块
}

35. `case`

作用：与 switch 一起使用，表示一个分支。
意义：根据变量的值执行相应的代码块。
用法：

switch (variable) {
    case value1:
        // 代码块
        break;
    case value2:
        // 代码块
        break;
    default:
        // 默认代码块
}

36. `break`

作用：用于终止循环或 switch 语句。
意义：提前结束循环或跳出 switch 语句。
用法：

for (int i = 0; i < 10; i++) {
    if (condition) {
        break;
    }
}

37. `continue`

作用：用于跳过当前循环的剩余部分。
意义：提前进入下一次循环。
用法：

for (int i = 0; i < 10; i++) {
    if (condition) {
        continue;
    }
    // 循环体
}

38. `do`

作用：用于循环。
意义：先执行循环体，再检查条件。
用法：

do {
    // 循环体
} while (condition);

39. `finally`

作用：用于异常处理。
意义：无论是否发生异常，都会执行的代码块。
用法：

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 异常处理代码
} finally {
    // 最终执行的代码
}

40. `goto`

作用：保留关键字，但未使用。
意义：用于无条件跳转，但Java不支持 goto。
用法：不适用。

41. `const`

作用：保留关键字，但未使用。
意义：用于定义常量，但Java不使用 const，而是使用 final。
用法：不适用。

42. `null`

作用：表示空值。
意义：表示对象引用为空。
用法：

Object obj = null;

43. `true`

作用：表示布尔值真。
意义：布尔类型的值之一。
用法：

boolean myBool = true;

44. `false`

作用：表示布尔值假。
意义：布尔类型的值之一。
用法：

boolean myBool = false;

45. `new`

作用：用于创建对象实例。
意义：分配内存并初始化对象。
用法：

MyClass obj = new MyClass();

46. `transient`

作用：用于声明变量。
意义：表示变量在序列化时不会被保存。
用法：

public class MyClass implements Serializable {
    private transient int myTransientField;

    public MyClass(int myTransientField) {
        this.myTransientField = myTransientField;
    }

    public int getMyTransientField() {
        return myTransientField;
    }
}

总结

Java中的关键字是具有特殊含义的保留字，每个关键字都有其特定的作用、意义和用法。以下是对常见Java关键字的简短总结：

类和访问控制：

class：定义类。
public、private、protected：控制访问权限。
static：定义类级别的成员。
final：定义常量、不可继承的类或不可重写的方法。

方法和返回类型：

void：表示方法没有返回值。
return：从方法中返回值。

条件和循环：

if、else：条件判断。
for、while、do：循环控制。
switch、case、default：多路选择。
break、continue：控制循环流程。

异常处理：

try、catch、finally：异常处理。
throw、throws：手动抛出异常和声明方法可能抛出的异常。

对象和实例：

new：创建对象实例。
this：引用当前对象。
super：引用父类对象。

继承和多态：

extends：继承类。
implements：实现接口。
abstract：定义抽象类或抽象方法。
interface：定义接口。

线程和同步：

synchronized：线程同步。
volatile：确保变量对所有线程可见。

其他：

import、package：导入包和声明类所在的包。
native：声明用其他语言实现的方法。
strictfp：确保浮点运算在不同平台上的一致性。
assert：断言，用于验证假设。
enum：定义枚举类型。
instanceof：类型检查。
default：接口中的默认方法。
transient：序列化时忽略该字段。
null、true、false：表示空值和布尔值。