【java笔记】java中static/final/abstract关键字的辨析

1. static关键字

static关键字在java中的主要用来修饰变量、方法名和形成静态代码块。

(1) 静态变量

• 变量可以分为实例变量和静态变量
• 被static修饰的属性（变量）被成为静态变量（类变量），其不依赖于类的特定实例，而是被类的所有实例所共享
• 在静态变量所在的类中，可以通过直接访问、类名访问或类的实例方法等进行方法，其他类中可以使用类名.静态变量来使用
• 静态变量是可以修改的（区别于final）

public class StaticVar {
    public static String str1 = "Hello";
    public static void main(String[] args) {
        String str2 = "World!";
        // 直接访问str1
        String accessVar1 = str1+str2;
        System.out.println("第 1 次访问静态变量，结果为："+accessVar1);
        // 通过类名访问str1
        String accessVar2 = StaticVar.str1+str2;
        System.out.println("第 2 次访问静态变量，结果为："+accessVar2);
        // 通过对象svt1访问str1
        StaticVar svt1 = new StaticVar();
        svt1.str1 = svt1.str1+str2;
        String accessVar3 = svt1.str1;
        System.out.println("第3次访向静态变量，结果为："+accessVar3);
        // 通过对象svt2访问str1
        StaticVar svt2 = new StaticVar();
        String accessVar4 = svt2.str1+str2;
        System.out.println("第 4 次访问静态变量，结果为："+accessVar4);
    }
}

(2) 静态方法

• 被static修饰的方法被称为静态方法（类方法），其他的被称为实例方法
• 静态方法不需要通过其所属类的实例就可以被调用，因此静态方法中不能使用this和super关键字，也不能直接访问所属类的实例变量和实例方法，但可以访问所属类的静态变量和静态方法
• 访问静态方法时，可以直接访问，也可以通过类名来访问，还可以通过实例化对象来访问

public class StaticMethod {
    public static int count = 1;    // 定义静态变量count
    public int method1() {    
        // 实例方法method1
        count++;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method1()中的 count="+count);    // 打印count
        return count;
    }
    public static int method2() {    
        // 静态方法method2
        count += count;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method2()中的 count="+count);    // 打印count
        return count;
    }
    public static void PrintCount() {    
        // 静态方法PrintCount
        count += 2;
        System.out.println("在静态方法 PrintCount()中的 count="+count);    // 打印count
    }
    public static void main(String[] args) {
        StaticMethod sft = new StaticMethod();
        // 通过实例对象调用实例方法
        System.out.println("method1() 方法返回值 intro1="+sft.method1());
        // 直接调用静态方法
        System.out.println("method2() 方法返回值 intro1="+method2());
        // 通过类名调用静态方法，打印 count
        StaticMethod.PrintCount();
    }
}public class StaticMethod {
    public static int count = 1;    // 定义静态变量count
    public int method1() {    
        // 实例方法method1
        count++;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method1()中的 count="+count);    // 打印count
        return count;
    }
    public static int method2() {    
        // 静态方法method2
        count += count;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method2()中的 count="+count);    // 打印count
        return count;
    }
    public static void PrintCount() {    
        // 静态方法PrintCount
        count += 2;
        System.out.println("在静态方法 PrintCount()中的 count="+count);    // 打印count
    }
    public static void main(String[] args) {
        StaticMethod sft = new StaticMethod();
        // 通过实例对象调用实例方法
        System.out.println("method1() 方法返回值 intro1="+sft.method1());
        // 直接调用静态方法
        System.out.println("method2() 方法返回值 intro1="+method2());
        // 通过类名调用静态方法，打印 count
        StaticMethod.PrintCount();
    }
}

(3) 静态代码块

• 静态代码块指 Java 类中的 static{ } 代码块，主要用于初始化类，为类的静态变量赋初始值
• 静态代码可类似于一个方法，可以位于类中的任意位置，一个类中也可以有多个静态代码块
• java虚拟机在加载类时按其出现的顺序执行一次静态代码块
• 静态代码块中不能访问类的实例变量和实例方法，而需要类的实例对象来访问

public class StaticCode {
    public static int count = 0;
    
    // 非静态代码块
    {
        count++;
        System.out.println("非静态代码块 count=" + count);
    }
    
    static {
        count++;
        System.out.println("静态代码块1 count=" + count);
    }
    
    static {
        count++;
        System.out.println("静态代码块2 count=" + count);
    }

    public static void main(String[] args) {
        System.out.println("*************** StaticCode1 执行 ***************");
        StaticCode sct1 = new StaticCode();
        System.out.println("*************** StaticCode2 执行 ***************");
        StaticCode sct2 = new StaticCode();
    }
}

上述代码中 { } 代码块为非静态代码块，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块。代码域中定义的变量都是局部的，只有域中的代码可以调用。

2. final关键字

final表示对象是最终形态的，不可改变的。可用作变量、方法和类。

(1) 修饰变量

• final修饰的变量即常量，其值不可改变（区别与不能赋值）
• final修饰的成员变量如果没有赋值时，需要在构造方法或者静态代码块中初始化
• final修饰的局部变量必须在使用前被赋值一次
• 对基本类型变量来说是其值不可变，而对对象引用类型变量来说其引用不可再变
• 使用 final 修饰的引用类型变量不能被重新赋值，但可以改变引用类型变量所引用对象的内容
• 在使用 final 声明变量时，要求全部的字母大写

public class FinalDemo {
    void doSomething() {
        // 没有在声明的同时赋值
        final int e;
        // 只能赋值一次
        e = 100;
        System.out.print(e);
        // 声明的同时赋值
        final int f = 200;
    }

    // 实例常量
    final int a = 5; // 直接赋值
    final int b; // 空白final变量
    // 静态常量
    final static int c = 12;// 直接赋值
    final static int d; // 空白final变量
    // 静态代码块
    static {
        // 初始化静态变量
        d = 32;
    }

    // 构造方法
    FinalDemo() {
        // 初始化实例变量
        b = 3;
        // 第二次赋值，会发生编译错误
        // b = 4;
    }
}

(2) 修饰方法

final 修饰的方法不可被重写，但可重载，若不希望子类重写父类的某个方法，则可以使用 final 修饰该方法。

public class FinalMethodTest {

    public final void test() {
    }
}

class Sub extends FinalMethodTest {

    // 下面方法定义将出现编译错误，不能重写final方法
    public void test() {
    }
}

(3) 修饰类

final 修饰的类不能被继承。

final class SuperClass {
}

class SubClass extends SuperClass {    //编译错误
}

3. abstract关键字

• java中有两种类，一种是具体类，另一个种是抽象类
• 用abstract修饰的类叫做抽象类，用abstract修饰的方法叫做抽象方法，抽象方法只有方法的声明，没有方法的实现
• abstract不能用于修饰静态方法和构造方法
• 抽象方法无方法体，必须存在于抽象类中，子类重写父类时，必须重写父类所有的抽象方法。
• 在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰，因为抽象方法必须被子类重写，而如果使用了 private 声明，则子类是无法重写的
• 抽象类中也可以有具体方法，抽象类不能实例化，即不能用new关键字创建对象

图形的抽象类：

public abstract class Shape {
    public int width; // 几何图形的长
    public int height; // 几何图形的宽

    public Shape(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public abstract double area(); // 定义抽象方法，计算面积
}

正方形类：

public class Square extends Shape {
    public Square(int width, int height) {
        super(width, height);
    }

    // 重写父类中的抽象方法，实现计算正方形面积的功能
    @Override
    public double area() {
        return width * height;
    }
}