java学习笔记：java所有关键字汇总、解析及应用

文章目录

- 一、java的所有关键字汇总、解析及应用
- - 1. abstract
  - 2. assert
  - 3. boolean
  - 4. break
  - 5. byte
  - 6. case
  - 7. catch
  - 8. char
  - 9. class
  - 10. const
  - 11. continue
  - 12. default
  - 13. do
  - 14. double
  - 15. else
  - 16. enum
  - 17. extends
  - 18. final
  - 19. finally
  - 20. float
  - 21. for
  - 22. goto
  - 23. if
  - 24. implements
  - 25. import
  - 26. instanceof
  - 27. int
  - 28. interface
  - 29. long
  - 30. native
  - 31. new
  - 32. package
  - 33. private
  - 34. protected
  - 35. public
  - 36. return
  - 37. short
  - 38. static
  - 39. strictfp
  - 40. super
  - 41. switch
  - 42. synchronized
  - 43. this
  - 44. throw
  - 45. throws
  - 46. transient
  - 47. try
  - 48. void
  - 49. volatile
  - 50. while

一、java的所有关键字汇总、解析及应用

1. abstract

抽象关键字，用于修饰类和方法。当修饰类时，表示该类是抽象类，不能被实例化；当修饰方法时，表示该方法是抽象方法，只有方法的声明，没有方法的实现，需要在子类中重写。

public abstract class Shape {public abstract void draw();}public class Circle extends Shape {public void draw() {System.out.println("Drawing a circle");}}

2. assert

断言关键字，用于在代码中进行断言，如果断言失败则抛出AssertionError异常。

int x = 10;assert x == 5 : "x should be 5";

3. boolean

布尔关键字，用于声明布尔类型变量，只能取true或false。

boolean isTrue = true;boolean isFalse = false;

4. break

跳出循环或switch语句的关键字。

for (int i = 0; i < 10; i++) {if (i == 5) {break;}System.out.println(i);}

5. byte

字节关键字，用于声明字节类型变量，范围为-128到127。

byte b = 100;

6. case

用于switch语句中的分支。

int day = 3;switch (day) {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");}

7. catch

用于捕获异常的关键字。

try {// 代码块} catch (Exception e) {// 异常处理}

8. char

字符关键字，用于声明字符类型变量，用单引号括起来。
char c = ‘A’;

9. class

类关键字，用于声明类。
public class MyClass {
// 类的成员和方法
}

10. const

已废弃的关键字，不再使用。

11. continue

跳过当前循环的剩余代码，继续下一次循环。

for (int i = 0; i < 10; i++) {if (i == 5) {continue;}System.out.println(i);}

12. default

switch语句中的默认分支。

int day = 7;switch (day) {case 1:System.out.println("Monday");break;case 2:System.out.println("Tuesday");break;default:System.out.println("Other day");}

13. do

循环关键字，用于执行循环体。

int i = 0;do {System.out.println(i);i++;} while (i < 5);

14. double

双精度浮点数关键字，用于声明双精度浮点数类型变量。

double d = 3.14;

15. else

条件语句中的否定分支。

int x = 5;if (x > 10) {System.out.println("x is greater than 10");} else {System.out.println("x is less than or equal to 10");}

16. enum

枚举关键字，用于声明枚举类型。

enum Day {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY}Day day = Day.MONDAY;

17. extends

继承关键字，用于声明类的继承关系。子类通过extends关键字继承父类的属性和方法，可以扩展父类的功能。

public class Animal {// 类的成员和方法}public class Dog extends Animal {// 类的成员和方法}

18. final

最终关键字，用于修饰类、方法和变量。当修饰类时，表示该类不能被继承；当修饰方法时，表示该方法不能被子类重写；当修饰变量时，表示该变量的值不能被修改。

final int x = 10;final void printMessage() {System.out.println("Hello");}final class MyClass {// 类的成员和方法}

19. finally

异常处理中的关键字，用于定义无论是否发生异常都会执行的代码块。

try {// 代码块} catch (Exception e) {// 异常处理} finally {// 无论是否发生异常都会执行的代码块}

20. float

单精度浮点数关键字，用于声明单精度浮点数类型变量。

float f = 3.14f;

21. for

循环关键字，用于执行循环。

for (int i = 0; i < 5; i++) {System.out.println(i);}

22. goto

已废弃的关键字，不再使用。

23. if

条件语句关键字，用于执行条件判断。

int x = 5;if (x > 10) {System.out.println("x is greater than 10");}

24. implements

实现关键字，用于实现接口。一个类可以实现多个接口，通过implements关键字实现接口中定义的方法。

public class MyClass implements MyInterface {// 类的成员和方法}

25. import

导入关键字，用于导入其他包中的类。

import java.util.ArrayList;import java.util.List;

26. instanceof

类型判断关键字，用于判断对象是否属于某个类或接口。

Animal animal = new Dog();if (animal instanceof Dog) {System.out.println("animal is a dog");}

27. int

整数关键字，用于声明整数类型变量。

int x = 10;

28. interface

接口关键字，用于声明接口。

public interface MyInterface {// 接口的方法}

29. long

长整数关键字，用于声明长整数类型变量。

long l = 1000000000L;

30. native

本地方法关键字，用于声明本地方法。

public native void myMethod();

31. new

创建对象关键字，用于创建新的对象。

MyClass obj = new MyClass();

32. package

包关键字，用于声明包。

package com.example.myapp;

33. private

私有关键字，用于声明私有成员或方法，只能在类内部访问。

private int x;private void printMessage() {System.out.println("Hello");}

34. protected

受保护关键字，用于声明受保护的成员或方法，只能在同一包内或子类中访问。

protected int x;protected void printMessage() {System.out.println("Hello");}

35. public

公共关键字，用于声明公共成员或方法，可以在任何地方访问。

public int x;public void printMessage() {System.out.println("Hello");}

36. return

返回关键字，用于从方法中返回值。

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

37. short

短整数关键字，用于声明短整数类型变量。

short s = 100;

38. static

静态关键字，用于修饰成员变量和方法。当修饰成员变量时，表示该变量属于类，而不是对象，所有对象共享同一个静态变量；当修饰方法时，表示该方法属于类，可以直接通过类名调用，无需创建对象。

public class MyClass {public static int x;public static void printMessage() {System.out.println("Hello");}}

39. strictfp

精确浮点数关键字，用于声明浮点数计算结果的精确性。

public strictfp class MyClass {// 类的成员和方法}

40. super

父类关键字，用于表示父类对象。可以通过super关键字调用父类的构造方法和方法。

public class Animal {public void eat() {System.out.println("Eating");}}public class Dog extends Animal {public void eat() {super.eat(); // 调用父类的eat方法System.out.println("Eating bones");}}

41. switch

条件语句关键字，用于执行多个分支中的一个。

int day = 3;switch (day) {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");}

42. synchronized

同步关键字，用于实现线程的同步，保证多个线程对共享资源的互斥访问。通过使用synchronized关键字修饰方法或代码块，可以确保同一时间只有一个线程执行该方法或代码块，其他线程需要等待。

public synchronized void myMethod() {// 代码块}

43. this

当前对象关键字，用于表示当前对象。可以通过this关键字访问当前对象的属性和方法。

public class MyClass {private int x;public void setX(int x) {this.x = x; // 使用this引用当前对象的成员变量}}

44. throw

抛出异常关键字，用于抛出异常。

throw new Exception("Something went wrong");

45. throws

声明异常关键字，用于声明方法可能抛出的异常。

public void myMethod() throws Exception {// 代码块}

46. transient

瞬态关键字，用于声明不需要序列化的成员变量。

public class MyClass implements Serializable {private transient int x; // 不需要序列化的成员变量}

47. try

异常处理关键字，用于定义可能发生异常的代码块。

try {// 代码块} catch (Exception e) {// 异常处理}

48. void

无返回值关键字，用于声明方法没有返回值。

public void printMessage() {System.out.println("Hello");}

49. volatile

修饰变量，表示该变量是易变的，即可能被多个线程同时访问和修改。使用volatile关键字修饰的变量，每次访问都会从主内存中读取最新的值，而不是使用线程的本地缓存。这样可以保证多个线程对该变量的操作是可见的，避免了数据不一致的问题。

public class MyClass {private volatile int x; // 声明易失变量}

50. while

循环关键字，用于执行循环。

int i = 0;while (i < 5) {System.out.println(i);i++;}

java学习笔记：java所有关键字汇总、解析及应用

文章目录

一、java的所有关键字汇总、解析及应用

1. abstract

2. assert

3. boolean

4. break

5. byte

6. case

7. catch

8. char

9. class

10. const

11. continue

12. default

13. do

14. double

15. else

16. enum

17. extends

18. final

19. finally

20. float

21. for

22. goto

23. if

24. implements

25. import

26. instanceof

27. int

28. interface

29. long

30. native

31. new

32. package

33. private

34. protected

35. public

36. return

37. short

38. static

39. strictfp

40. super

41. switch

42. synchronized

43. this

44. throw

45. throws

46. transient

47. try

48. void

49. volatile

50. while

相关文章

最新关注

热文推荐