Java（static - 静态的、abstract - 抽象的、final - 最终的）

static - 静态的

修饰 成员变量/成员方法，属于类的

1. 修饰成员变量
   属于类的, 所有对象共用
   通过（类名.）调用
   只有一个

2. 修饰方法

• 在静态方法中, 不能直接使用普通成员变量和成员方法（需要new对象）
• 在普通方法中, 可以直接使用静态变量和静态方法

3. 修饰代码块
   静态代码块 — 给类初始化
   在类加载时执行的
   作用: 用来执行消耗比较大的代码

/**
 * 静态的成员变量:
 *   1.属于类
 *   2.通过类名. 调用 例如 Child.money
 *   3.只有一个
 *
 * 普通成员变量:
 *   1.属于对象
 *   2.通过对象. 调用 例如 c1.name
 *   3.有几个对象, 就有几个成员变量
 *
 * 静态方法:
 *   1.属于类
 *   2.通过类. 调用 例如 Child.cry()
 *   3.在静态方法中, 不能直接使用普通成员变量和成员方法
 *   4.在普通方法中, 可以直接使用静态变量和静态方法
 */
public class Child {
    String name;
    int age;
    // 通常是声明的同时初始化
    static int money;
    // 静态代码块 -> 给类初始化 -> 类加载时执行的
    static {
        money = 1000;
    }
    // 代码块: 调用构造器之前
    // 给对象初始化, 提取所有构造方法中重复的代码
    {
        System.out.println("111");
    }
    Child(String name, int age) {
        this.name = name;
        this.age = age;
        // 通常静态成员变量不会在构造方法中初始化
        // money = 100;
    }
    static void cry() {
        System.out.println(/*name +*/ "在放声哭!");
//        this.sleep();
    }
    void sleep() {
        cry();
        System.out.println(name + "在睡觉觉!");
        System.out.println("抱着" + money + "的零花钱");
    }

结论：当使用静态成员变量/方法时, 对象不一定存在

abstract - 抽象的

– JDK 1.8以前，抽象类的方法默认访问权限为protected（可以是public和protected）
– JDK 1.8时，抽象类的方法默认访问权限变为default（可以是public和protected或者不写）

修饰 类/成员方法

• 抽象方法
  1、 方法没有方法体
  2、一个类中, 存在抽象方法, 那么这个类就必须也是abstract
• 抽象类:
  1、 用abstract修饰的类
  2、 抽象类不能直接new对象
  3、有构造方法, 为了给子类使用
  4、 抽象类的非抽象子类, 必须实现/重写抽象类的所有抽象方法
  5、抽象类就是有抽象方法的类 ×

//抽象类
public abstract class A extends Object {
    int x;
    int y;
    A() {
        System.out.println();
    }
    // 公共部分, 为了让所有的子类统一
    // 父类方法体没有意义 - 抽象方法
    abstract void move();
}

public class B extends A {
    int life;
    B() {
        super();
    }
    // 重写方法 -> 实现方法
    void move() {
        System.out.println("1111");
    }

final - 最终的

修饰 类/成员方法/成员变量/局部变量

• 修饰类: 类不能被继承
• 修饰方法: 方法不能被重写
• 成员变量: 变量不能被修改, 必须初始化

public class A {
    // final 修饰成员变量, 必须初始化: 声明的同时,每个构造方法中,代码块中
    final int b;
    {
        //b = 10;
    }
    A() {
        b = 10;
    }
    A(int a) {
        b = 30;
    }
    public static void main(String[] args) {
    A demo2 = new A();
    // b是常量, 不能修改
    System.out.println(demo2.b ++);
}

• 局部变量: 变量不能被修改, 必须初始化

// final修饰局部变量, 只能一次赋值, 不能修改
final int b; // --> 常量
b = 20;
//b = 30; //error

• 引用类型变量: 引用地址不能被修改, 内容可以修改

public static void main(String[] args) {
    final int[] a = {1, 2, 3, 4, 5};
    // final 修饰引用类型变量, 引用-地址不能改变, 对象内容可以改变
    a[0] = 3;
    //a = new int[4]; // error
}