不讲道理

static

1. 修饰成员变量，静态变量不属于对象，属于类变量，凡是这个类创建出来的对象，都可以共享这个变量
2. 修饰方法，也是属于类的方法

final

1. final 修饰的类不能被继承
2. final 修饰的对象，地址不能改变，对象属性值可以
3. final 修饰的方法不能被重写
4. final 修饰局部变量，不能二次赋值，申明时可以不赋值
5. final 修饰成员变量，不能二次赋值，申明时必须赋初值

代码块

1. 普通代码块，每次 new 对象时执行，先于构造方法执行
2. 静态代码块，只执行一次，先于普通代码块执行
   1. 无论 new 多少次，只会执行一次
   2. 适用场景：静态代码块中初始化一些数据，这个对象无论 new 对少个对象都会有这些初始化好的数据

初始化顺序

1. 不存在父类
   1. 静态变量
   2. 静态代码块
   3. 成员变量
   4. 普通代码块
   5. 构造方法
2. 存在父类的初始化顺序
   1. 父类(静态变量、静态语句块)
   2. 子类(静态变量、静态语句块)
   3. 父类(实例变量、普通语句块)
   4. 父类(构造函数)
   5. 子类(实例变量、普通语句块)
   6. 子类(构造函数）

缓存池

1. boolean 缓存池数据：true、false
2. short 缓存池数据：-128 至 127
3. int 缓存池数据：-128 至 127

Integer m = 123;
Integer n = 123;
System.out.println(m == n); // true

Integer m1 = 323;
Integer n1 = 323;
System.out.println(m1 == n1); // false

JAVA是值传递

1. 对于基本数据类型（如int、float等），传递的是它们的值的副本
2. 对于对象引用（如String、数组、自定义对象等），传递的是对象引用的副本

public class Main {
    public static void main(String[] args) {
        int x = 10;
        increment(x); // x仍然是10，没有改变

        int[] arr = {1, 2, 3};
        changeArray(arr); // arr[0]被改变为 100，此时 arr => 100，2，3
        
        changeArray(arr); // 不会变化，arr => 100，2，3
    }

    public static void increment(int num) {
        num++;
    }

    public static void changeArray1(int[] arr) {
        arr[0] = 100;
    }
    
    public static void changeArray2(int[] arr) {
        arr = {4, 5, 6};
    }
}