主要是java开发面试或笔试中常见或者常考的关键字特性介绍

类方法和变量修饰符

final关键字

用于声明不可变性，它可以应用于变量、方法和类。以下是 final 关键字在不同上下文中的用法。

final变量：
final 变量是常量，一旦赋值后，其值不可更改。
final 实例变量必须在对象的构造函数中进行初始化，或者在声明时直接初始化。
final 本地变量（在方法或代码块中声明的变量）必须在声明时初始化，不能再次赋值。

final int x = 10; // 声明并初始化一个final变量
final double PI = 3.14159;

public void exampleMethod() {
    final int y; // 声明一个final本地变量
    y = 20; // 初始化final本地变量
}

final方法：
final 方法是不可覆盖（override）的方法。子类不能重写父类中的 final 方法。
常用于确保方法的逻辑在子类中不被修改。

public class Parent {
    public final void finalMethod() {
        // 这个方法在子类中不能被重写
    }
}

final类：
final 类是不可继承的类，即不能有子类。
通常用于防止类被继承和修改，或者表示一个类已经完全实现，不能再被扩展。

public final class FinalClass {
    // 此类不能被继承
}

final 的主要作用是为了确保不可变性、安全性和稳定性。在多线程环境中，final 变量可以用来实现线程安全，因为它们保证了在构造过程中的可见性，并且一旦初始化后，其值不会发生改变。final 方法和类则用于确保不变的行为和避免子类对其进行不当修改。

abstract关键字

java中，抽象类（Abstract class）是一种特殊的类，它不能被实例化，一般作为其他类的基类（父类）,它定义了一些方法的声明，但不提供方法的实现，留给它的子类来完成实现。

1. 声明抽象类

public abstract class AbstractClass{
	// 抽象方法，没有方法体
	public abstract void abstractMethod();
	// 普通方法，有方法体
	public void regularMethod()
	{
		System.out.print("这是一个普通方法");
	}
}

2. 继承抽象方法
   子类继承抽象类，并实现其中的抽象方法。

public class ConcreteClass extends AbstractClass{
	// 实现抽象方法
	public void abstractMethod()
	{
		System.out.print("这是抽象方法的实现");
	}
}

3. 实例化子类

AbstractClass obj = new ConcreteClass()
obj.abstractMethod();  // 调用子类的实现

注意！

1. 一个类包含抽象方法，他必须被声明为抽象类
2. 子类必须实现所有父类的抽象方法

static 关键字

static 用于定义静态成员（静态变量和静态方法）以及静态代码块。
static 关键字的主要作用是使成员与类相关，而不是与类实例相关。

1. 静态变量
   静态变量也被称为类变量，它属于类而不是类的实例，在类加载时分配内存，并且只有一份副本，所有实例对象共享相同的静态变量。

public class Myclass{
	public static int staticVartiable = 10;
	// 类的其他实现
}

2. 静态方法
   静态方法属于类而不是实例对象，可以通过类名直接调用，而不需要创建类的实例。

public class Myclass{
	public static void staticMethod()
	{
		System.out.println("这是静态方法");
	}
	// 类的其他实现
}

3. 静态代码块
   静态代码块是在类加载时就执行的代码块，用于初始化静态变量或者执行一些静态操作。在类中他只执行一次。

public class Myclass{
	static {
	Sytem.out.print("static block");
}
}

关于static执行顺序

无继承关系：

public class Example {
    static {
        // 静态代码块
        System.out.println("Static block");
    }

    {
        // 代码块
        System.out.println("Non-static block");
    }

    public Example() {
        // 构造函数
        System.out.println("Constructor");
    }

    public static void main(String[] args) {
        new Example();
        new Example();
    }
}

输出结果如下：
-------------------------------------
Static block
Non-static block
Constructor
-------------------------------------
Non-static block
Constructor

有继承关系

// 父类
public class FatherExample {
    {
        System.out.println("Father Non-static block");
    }
    static
    {
        System.out.println("Father Static block");
    }
    public void Example()
    {
        System.out.println("Father Constructor");
    }
}

// 子类
public class Example extends FatherExample{
    static {
        System.out.println("Son Static block");
    }
    {
        System.out.println("Son Non-static block");
    }
    public void Example()
    {
        System.out.println("Son Constructor");
    }
    public static void main(String[] args)
    {
        new Example();
        new Example();
    }
}

执行结果：
-------------------------------------
Father Static block
Son Static block
Father Non-static block
Son Non-static block
-------------------------------------
Father Non-static block
Son Non-static block

implements 和 interface 关键字

implements是java中的一个关键字，用于实现接口，接口是java中的一种抽象类型，定义了一组抽象方法，而类可以实现implements这些接口来提供具体的实现。

1.接口定义
接口通过interface关键字定义，接口中的方法默认是抽象的，没有方法体，接口中通常包含常量

interface MyInterface{
	// 两个抽象方法，一般接口中不定义成抽象方法，依靠写作规范约束
	void method1() 
	void method2()
}

2. 类实现接口
   类可以使用implements关键字来实现一个或多个接口。实现接口类中必须提供接口中所有声明的首相方法的具体实现。

public class MyClass implements MyInterface,MyInterface2
{
	@Override  //重写的意思
	public void method1(){
		// 具体实现
	}
	@Override  //重写的意思
	public void method2(){
		// 具体实现
	}
}