Java static和final关键字使用辨析

Java static和final关键字使用辨析

static关键字

static 是静态修饰关键字，可以修饰变量、程序块、方法和类：

• 当static修饰变量时，jvm会将其分配在内存堆上，所有程序对它的引用都会指向这个地址而不会重新分配内存；
• 当static修饰一个程序块时，虚拟机就会优先加载静态快中代码；
• 当static修饰一个方法时，可以直接通过类来调用而不需要新建对象；
• static还可以修饰类，如静态内部类

static变量

static变量也称为静态变量，静态变量和非静态变量的区别：

• 静态变量被所有对象共享，在内存中只有一个副本，在类初次加载的时候才会初始化
• 非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响

static成员变量初始化顺序按照定义的顺序来进行初始化

static方法

static方法也成为静态方法，由于静态方法不依赖于任何对象就可以直接访问( 类名.方法)，因此对于静态方法来说，是没有this的，因为不依附于任何对象，既然都没有对象，就谈不上this了，并且由于此特性，在静态方法中不能访问类的非静态成员变量和非静态方法，因为非静态成员变量和非静态方法都必须依赖于具体的对象才能被调用。

虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法和静态成员变量。
静态方法只能继承，不能被重写

public class Static_Test {
    public static void main(String[] args) {
        Father f = new Son();
        f.output();
    }
}

class Father{
    public static void output(){
        System.out.println("Father");
    }
}

class Son extends Father{
    public static void output(){
        System.out.println("Son");
    }
}

输入结果：Father

static块

构造方法用于对象的初始化。静态初始化块，用于类的初始化操作。在静态初始化块中不能直接访问非staic成员。

静态初始化块的作用就是：提升程序性能。

为什么说静态初始化块能提升程序性能，代码示例如下：

class Person{
    private Date birthDate;

    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }

    boolean isBornBoomer() {
        Date startDate = Date.valueOf("1946");
        Date endDate = Date.valueOf("1964");
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
    }
}

isBornBoomer是用来这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，都会生成startDate和birthDate两个对象，造成了空间浪费，如果改成这样效率会更好：

class Person{
    private Date birthDate;
    private static Date startDate,endDate;
    static{
        startDate = Date.valueOf("1946");
        endDate = Date.valueOf("1964");
    }

    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }

    boolean isBornBoomer() {
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
    }
}

因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行

静态初始化块可以置于类中的任何地方，类中可以有多个静态初始化块。
在类初次被加载时，会按照静态初始化块的顺序来执行每个块，并且只会执行一次。

final关键字

final关键字可以用来修饰引用、方法和类。

• final修饰的属性的初始化可以在编译期，也可以在运行期，初始化后不能被改变。
• final修饰的属性跟具体对象有关，在运行期初始化的final属性，不同对象可以有不同的值。
• final修饰的属性表明是一个常数（创建后不能被修改）。
• final修饰的方法表示该方法在子类中不能被重写；
• inal修饰的类表示该类不能被继承。

final修饰引用

• 如果引用为基本数据类型，则该引用为常量，该值无法修改；
• 如果引用为引用数据类型，比如对象、数组，则该对象、数组本身可以修改，但指向该对象或数组的地址的引用不能修改。
• 如果引用时类的成员变量，则必须当场赋值，否则编译会报错。

final class Person {
    String name ="person";    //3. 此处不赋值会报错
    //final int age;
    final int age = 10;  
}
public class Demo01 {
    public static void main(String[] args) {        //1. 基本数组类型为常量，无法修改
        final int i = 9;
        //i = 10;               //2. 地址不能修改，但是对象本身的属性可以修改
        Person p = new Person();
        p.name = "lisi";
        final int[] arr = {1,2,3,45};
        arr[3] = 999;
        //arr = new int[]{1,4,56,78};
    }
}

final修饰方法

当使用final修饰方法时，这个方法将成为最终方法，无法被子类重写。但是，该方法仍然可以被继承。

class Person {
    public final void say() {
        System.out.println("说....");
    }
    public void eat() {
        System.out.println("吃...");
    }
}
class Teacher extends Person {
    //1. final修饰的方法不能被重写，但此方法仍然被继承
    /*@Override
    public void say() {
        System.out.println("老师在一本正经的说...");
    }*/
    
    public void eat() {
        System.out.println("老师在大口大口的吃...");
    }
}
public class Demo02 {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.say();
    }    
}

final修饰类

当用final修改类时，该类成为最终类，无法被继承。简称为“断子绝孙类”。

// final用法3：修饰类，则该类成为最终类，无法被继承
final class Person02 {    
}
//class Teacher02 extends Person02 { } #报错
//class MyString extends String{} #String被final修饰
public class Demo03 {
}

static final

static修饰的属性强调它们只有一个，final修饰的属性表明是一个常数（创建后不能被修改）。static final修饰的属性表示一旦给值，就不可修改，并且可以通过类名访问。

static final也可以修饰方法，表示该方法不能重写，可以在不new对象的情况下调用。

参考：
https://blog.csdn.net/weixin_37404604/article/details/80424562
https://www.cnblogs.com/chhyan-dream/p/10685878.html
https://www.cnblogs.com/dxllp/p/10721871.html