【技术累积】【点】【java】【20】static关键字

基础概念

• 是个修饰符；
• 修饰变量、常量、方法、代码块；
• 被修饰的为静态；
• 方便在没有创建对象的情况下来进行调用（方法/变量）；
• static修饰的成员被所有的对象所共享；
• static优先于对象存在，因为static的成员随着类的加载就已经存在了；
• static修饰的数据是共享数据，对象中的存储的是特有数据；

分别举例说明

import lombok.extern.slf4j.Slf4j;
import org.testng.annotations.Test;

import java.util.Date;

@Slf4j
public class TestStatic {
    static Date startDate;
    static{
        startDate = new Date();
    }

    static String str = "testStr";

    static void test(){
        log.info("static str={}",str);
    }

    String testSt(int n){
        String res = "";
        while (n > 0) {
            res = res + startDate.toString() + "|" + n + "——";
            n--;
        }
        return res;
    }

    @Test
    public void testU(){
        TestStatic.test();
        int n = 10;
        testSt(n);
        log.info("test {}:{}",n,testSt(n));
    }
}

静态方法

• 静态方法中没有this；
• 静态方法中不能访问非静态成员方法和非静态成员变量，反之可以；

静态变量/常量

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

静态代码块

• static块可以置于类中的任何地方；
• 一个类中可以有多个块；按顺序执行；
• 只会在类加载的时候执行一次；

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;
    }
}

注意在代码块外进行声明，在代码块中执行初始化等操作；

题目考察

这段代码输出什么

public class Test {
    Person person = new Person("Test");
    static{
        System.out.println("test static");
    }

    public Test() {
        System.out.println("test constructor");
    }

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

class Person{
    static{
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person "+str);
    }
}

class MyClass extends Test {
    Person person = new Person("MyClass");
    static{
        System.out.println("myclass static");
    }

    public MyClass() {
        System.out.println("myclass constructor");
    }
}

我们还是来想一下这段代码的具体执行过程。首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。

test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

参考文章

• Java中的static关键字解析
• static的特点及注意事项