1. abstract

抽象类，不能实例化，只能被继承。

abstract class Animal {
    abstract void makeSound();

    public void sleep() {
        System.out.println("The animal is sleeping.");
    }
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("The dog barks.");
    }
}

Animal类是抽象类，不能实例化，只能被继承。Dog类是Animal类的子类，继承了Animal类的方法，并实现了makeSound()方法。

2. boolean

布尔类型，用于表示真或假的值。

boolean isStudent = true;

if (isStudent) {
    System.out.println("This person is a student.");
} else {
    System.out.println("This person is not a student.");
}

boolean类型的变量isStudent表示是否为学生，如果为true，则输出"This person is a student."，否则输出"This person is not a student."。

3. break

break语句用于跳出循环或switch语句。

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

for循环从0开始，每次迭代i加1，直到i等于5时，break语句跳出循环。循环结束后，输出"Loop ended."。

4. byte

byte类型，用于表示8位整数。

byte minByte = -128;
byte maxByte = 127;

5. case

case语句用于匹配switch语句中的值。

switch (day) {
    case 1: System.out.println("Monday");
    case 2: System.out.println("Tuesday");
    case 3: System.out.println("Wednesday");
    case 4: System.out.println("Thursday");
    case 5: System.out.println("Friday");
    case 6: System.out.println("Saturday");
    case 7: System.out.println("Sunday");
    default: System.out.println("Invalid day.");
    break;
}

switch语句中的day变量表示星期几，根据不同的值，输出相应的星期名称。如果day的值不在1到7之间，则输出"Invalid day."。

6. catch

catch语句用于捕获异常。

try {
    int num = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("Invalid number format");
}

try语句中，将字符串"abc"转换为整数，如果转换失败，则抛出NumberFormatException异常。catch语句中，捕获NumberFormatException异常，并输出"Invalid number format"。catch 块可以有多个，每个 catch 块可以捕获特定类型的异常。在 catch 块中，可以根据需要进行异常处理，例如输出错误信息、进行日志记录、恢复程序状态等。

7. char

char类型，用于表示一个字符,用单引号括起来表示。

char c = 'a';

8. class

class关键字用于定义类。

class Person {
    String name;
    int age;
    void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
        System.out.println("I am a person.");
    }
}

Person类定义了一个名为name的成员变量，和一个名为age的成员变量，还有一个名为sayHello()的方法，用于打印欢迎信息和自我介绍。

9. continue

continue语句用于跳过当前循环的剩余部分，并继续下一次循环。

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

当i为偶数时，执行continue语句，跳过当前循环的剩余部分，继续下一次循环，最终输出1,3,5,7,9。

10. default

default关键字用于匹配switch语句中的默认情况。

switch (day) {
    case 1: System.out.println("Monday"); break;
    case 2: System.out.println("Tuesday"); break;
    case 3: System.out.println("Wednesday"); break;
    case 4: System.out.println("Thursday"); break;
    case 5: System.out.println("Friday"); break;
    case 6: System.out.println("Saturday"); break;
    case 7: System.out.println("Sunday"); break;
    default: System.out.println("Invalid day.");break;
}

default关键字用于匹配switch语句中的默认情况，如果day的值不在1到7之间，则输出"Invalid day."。

11. do

通常和while语句一起使用，用于执行循环体至少一次。

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

do语句中，先执行循环体，然后再判断条件是否为真，如果为真，则继续执行循环体，直到条件为假。

12. double

double类型，用于表示64位浮点数。

double a = 3.14;
double b = 2.0;
double c = a + b;

13. else

else关键字用于匹配if语句中的条件为假时执行的代码。

int score = 75;
if (score >= 60) {
    System.out.println("及格了");
} else {
    System.out.println("挂科了");
}

if语句中的条件为真时，输出"及格了"，否则输出"挂科了"。

14. enum

enum关键字用于定义枚举类型。

public enum PlayerType {
    TENNIS,
    FOOTBALL,
    BASKETBALL
}

PlayerType是一个枚举类型，包含三个值TENNIS、FOOTBALL和BASKETBALL。

15. extends

extends关键字用于继承父类。

class Animal {
    public void eat() {
        System.out.println("动物正在吃东西");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("狗在汪汪叫");
    }
}

public class ExtendsDemo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.bark();
    }
}

Animal类定义了一个eat()方法，Dog类继承Animal类，并定义了一个bark()方法。在main()方法中，创建了一个Dog对象，并调用了eat()方法和bark()方法。

16. final

①表示一个常量，一旦被赋值，就不能再改变。

final double PI = 3.14159265359;

②表示一个方法，不允许被重写。

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

class Dog extends Animal {
    // 错误: 无法覆盖来自 Animal 的 final 方法
    // void makeSound() {
    //     System.out.println("狗吠叫.");
    // }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
    }
}

③表示一个类，不允许被继承。

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

// 错误: 类型 Dog 无法继承 final 类 Animal
// class Dog extends Animal {
//     void makeSound() {
//         System.out.println("狗吠叫.");
//     }
// }

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound();
    }
}

17. finally

与try-catch语句一起使用，用于执行清理工作，例如关闭文件、释放资源等。

try {
    int x = 10 / 0;  // 抛出异常
} catch (Exception e) {
    System.out.println("发生了异常：" + e.getMessage());
} finally {
    System.out.println("finally 块被执行");
}

18. float

float类型，用于表示单精度浮点数。

float f1 = 3.14f;   // 注意要在数字后面加上 f 表示这是一个 float 类型
float f2 = 1.23e-4f;   // 科学计数法表示小数

19. for

int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i < arr.length; i++) {
    System.out.println("arr[" + i + "] = " + arr[i]);
}

for循环用于遍历数组。

20. if

if语句用于判断条件，如果条件为真，则执行if语句中的代码块，否则执行else语句中的代码块。

int n = -3;
if (n > 0) {
    System.out.println(n + " 是正数");
} else if (n < 0) {
    System.out.println(n + " 是负数");
} else {
    System.out.println(n + " 是零");
}

21. implements

implements关键字用于实现接口。

public class MyThread implements Runnable {
    public void run() {
        // 线程执行的代码
    }
}

22. import

import关键字用于导入包或类。

import java.util.ArrayList;

23. instanceof

instanceof关键字用于判断一个对象是否属于某个类或接口。
例如，假设有一个 Person 类和一个 Student 类，Student 类继承自 Person 类，可以使用 instanceof 运算符来判断一个对象是否为 Person 类或其子类的实例：

Person p = new Student();
if (p instanceof Person) {
    System.out.println("p is an instance of Person");
}
if (p instanceof Student) {
    System.out.println("p is an instance of Student");
}

24. int

int类型，用于表示32位整数。

int a = 10;
int b = 20;
int c = a + b;
System.out.println("c = " + c);

25. interface

interface关键字用于定义接口。

public interface MyInterface {
    void method1();
    int method2(String param);
}

MyInterface是一个接口，包含两个方法method1()和method2()。

26. long

long类型，用于表示64位整数。

long x;           // 声明一个 long 类型的变量 x
x = 10000000000L; // 将长整数值 10000000000 赋给变量 x，需要在数字后面加上 L 或 l 表示这是一个 long 类型的值
long y = 20000000000L; // 声明并初始化一个 long 类型的变量 y，赋值为长整数值 20000000000

27. native

native关键字用于声明一个方法为本地方法，即调用Java虚拟机的本地方法。

public native void nativeMethod();

28. new

new关键字用于创建对象。

ClassName obj = new ClassName();

创建数组的方式：

int[] arr = new int[5];

29. null

null关键字用于表示空引用。

String str = null; // 声明一个字符串引用，初始化为 null
MyClass obj = null; // 声明一个 MyClass 类型的引用，初始化为 null

30. package

package关键字用于定义包。

package com.example.mypackage;

31. private

private关键字用于定义私有成员。

public class MyClass {
    private int x; // 私有属性 x，只能在当前类的内部访问

    private void foo() {
        // 私有方法 foo，只能在当前类的内部调用
    }
}

32. protected

protected关键字用于定义受保护的成员。

package com.example.mypackage;

public class MyBaseClass {
    protected int x; // 受保护的属性 x，可以被子类和同一包中的其他类访问

    protected void foo() {
        // 受保护的方法 foo，可以被子类和同一包中的其他类调用
    }
}

package com.example.mypackage;

public class MySubClass extends MyBaseClass {
    public void bar() {
        x = 10; // 可以访问 MyBaseClass 中的受保护属性 x
        foo(); // 可以调用 MyBaseClass 中的受保护方法 foo
    }
}

33. public

public关键字用于定义公共成员。

public class MyClass {
    public int x; // 公有属性 x，可以被任何类访问

    public void foo() {
        // 公有方法 foo，可以被任何类调用
    }
}

34. return

return关键字用于返回一个值。

public int add(int a, int b) {
    int sum = a + b;
    return sum; // 返回 sum 的值，并结束方法的执行
}

还可以在方法中直接返回：

public int add(int a, int b) {
    return a + b;
    // return 后面的代码不会被执行，因为方法已经返回了  
}

35. short

short类型，用于表示16位整数。

short x = 10; // 声明一个 short 类型的变量 x，赋值为 10
short y = 20; // 声明一个 short 类型的变量 y，赋值为 20

36. static

static关键字用于定义静态成员或静态方法。

public class MyClass {
    public static int x; // 静态变量 x，属于类的成员

    public static void foo() {
        // 静态方法 foo，属于类的成员
    }
}

37. strictfp

strictfp关键字用于表示严格模式，用于保证浮点运算的结果具有一致性。

public strictfp class MyClass {
    public static void main(String[] args) {
        double a = 0.1;
        double b = 0.2;
        double result = a + b;
        System.out.println("Result: " + result);
    }
}

在Java中，严格模式是指在浮点运算中，保证结果具有一致性。例如，在严格模式下，0.1 + 0.2的结果应该为0.3，而不会是0.30000000000000004。

38. super

super关键字用于访问父类的成员。

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name); // 调用父类的构造方法
    }

    public void bark() {
        System.out.println(name + " is barking.");
    }

    public void eat() {
        super.eat(); // 调用父类的方法
        System.out.println(name + " is eating bones.");
    }
}

39. switch

switch语句用于根据条件执行不同的代码块。

public class Main {
    public static void main(String[] args) {
        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;
            case 4: System.out.println("Thursday"); break;
            case 5: System.out.println("Friday"); break;
            case 6: System.out.println("Saturday"); break;
            case 7: System.out.println("Sunday"); break;
            default: System.out.println("Invalid day"); break;
        }
    }
}

40. synchronized

synchronized关键字用于同步访问共享资源。

public class MyClass {
    private int count;

    public synchronized void increment() {
        count++; // 同步方法
    }

    public void doSomething() {
        synchronized(this) { // 同步代码块
            // 执行一些需要同步的操作
        }
    }
}

41. this

this关键字用于引用当前对象的引用。

public class MyClass {
    private int num;

    public MyClass(int num) {
        this.num = num; // 使用 this 关键字引用当前对象的成员变量
    }

    public void doSomething() {
        System.out.println("Doing something with " + this.num); // 使用 this 关键字引用当前对象的成员变量
    }

    public MyClass getThis() {
        return this; // 返回当前对象本身
    }
}

42. throw

throw关键字用于抛出一个异常。

public class MyClass {
    public void doSomething(int num) throws Exception {
        if (num < 0) {
            throw new Exception("num must be greater than zero"); // 手动抛出异常
        }
        // 执行一些操作
    }
}

43. transient

transient关键字用于表示不参与序列化的成员。

public class MyClass implements Serializable {
    private int id;
    private String name;
    private transient String password;

    public MyClass(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    // 省略 getter 和 setter 方法

    @Override
    public String toString() {
        return "MyClass{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

44. try

try关键字用于执行可能抛出异常的代码块。

try {
    // 可能抛出异常的代码
    int result = 1 / 0;
} catch (Exception e) {
    // 异常处理代码
    e.printStackTrace();
}

45. void

void关键字用于定义一个没有返回值的方法。

public class MyClass {
    public void doSomething() {
        // 执行一些操作
        System.out.println("Doing something");
        return;
    }
}

46. volatile

volatile关键字用于表示变量的可见性。

public class MyThread extends Thread {
    private volatile boolean running = true;

    @Override
    public void run() {
        while (running) {
            // 线程执行的代码
        }
    }

    public void stopThread() {
        running = false;
    }
}

47. while

while循环用于重复执行一段代码，直到条件不满足为止。

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

48. goto和const

goto和const关键字在Java中已经不再使用，它们已被弃用。
const关键字用于定义常量，常量在编译时确定其值，不能在运行时改变。
goto关键字用于跳转到指定位置，但Java不支持goto语句。