JavaSE学习：第十三章、静态变量、代码块

一、静态变量：

---

1、定义：

static是java语言中的关键字，表示“静态的”，它可以用来修饰变量、方法、代码块等。
在java语言中凡是用static修饰的都是类相关的，不需要创建对象，直接通过“类名”即可访问，即使使用“引用”去访问，在运行的时候也和堆内存当中的对象无关。

1、如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。
2、static变量是同一个类所有对象共享。
3、static类变量，在类加载的时候就生成了。

1、 声明为static的方法称为静态方法或类方法。静态方法可以直接调用静态方法，访问静态变量，但是不能直接访问实例变量和实例方法。
2、== 静态方法中不能使用this关键字，因为静态方法不属于任何一个实例。==

2、细节：

1、什么时候使用？
需要让一个类的所有对象共享一个变量时。
2、静态变量和普通属性区别：
类变量是该类所有对象共享的，实例变量是每个对象独享的。
3、如何访问：
类名.静态变量名。
4、访问也需要遵守访问权限。
5、普通属性不可以通过类名.类变量名的方式访问。
6、类变量是在类加载的时候就初始化了，即使没有创建对象，只要类加载了，就可以使用类变量。
7、类变量的生命周期是随着类的加载开始，随着类的消亡而销毁。

package com.hsf.extends_.static_;

public class test {
    public static void main(String[] args) {
//        System.out.println(A.age);
        A tom = new A("tom");
        A.payFee(200);
        A mary = new A("mary");
        A.payFee(300);
        A.show();

    }
}

class A {
    public String name;
    public static double fee;


    public A(String name) {
        this.name = name;
    }

    public static double payFee(double fee) {
        return A.fee+=fee;
    }

    public static void show() {
        System.out.println(fee);
    }

}

3、静态方法使用场景：

1、当方法中不涉及到任何对象的相关成员的时候。
2、在实际开发中，可以将一些通用方法，设计成静态方法，这样就可以不创建对象类使用。

4、注意事项：

1、静态方法不能使用和对象有关的关键字，如this和super。
2、静态方法中只能访问静态方法或者静态变量。
3、普通方法可以访问普通成员也可以访问静态成员。

---

二、代码块：

---

1、定义：

代码块又称为初始化块，将逻辑语句封装在方法体中，通过{}包围起来。

2、结构：

【修饰符】{ }
1、修饰符只能写static。
2、有static修饰称为静态代码块。

3、好处：

1、相当于另外一种构造器（对构造器的补充机制），可以做初始化的操作。
2、如果多个构造器中有重复的代码，可以抽取到代码块中，提高代码复用性。

package com.hsf.extends_.static_;

public class code_block {
    public static void main(String[] args) {
        B b1 = new B("沙丘");
        B b2 = new B("钢铁侠", 200);
    }
}

class  B {
    private String name;
    private double money;
    private String director;

    {
        System.out.println("我是代码块中的内容");
    }

    public B(String name) {
        System.out.println("我是一个参数构造器");
        this.name = name;
    }

    public B(String name, double money) {
        System.out.println("我是两个参数构造器");
        this.name = name;
        this.money = money;
    }

    public B(String name, double money, String director) {
        System.out.println("我是三个参数构造器");
        this.name = name;
        this.money = money;
        this.director = director;
    }
}

4、细节：

1、静态代码块：随着类的加载而执行，只会执行一次，因为类加载也只会加载一次。
2、普通代码块：每创建一个对象执行一次。

4.1、类加载的时机：

1、创建对象实例时（new）。
2、创建子类对象实例时，父类也会被加载。
3、使用类的静态成员的时候。（普通代码模块不会被调用）

5、创建对象时，代码执行顺序：在一个类中

1、首先调用静态代码块和静态属性（静态代码块和静态属性优先级一致，谁写在前面先执行谁）。
2、然后调用普通代码块和普通属性（两者优先级一致，按书写顺序依次执行）。
3、接着调用构造方法：调用构造方法注意有隐藏的{}调用普通代码块。
小细节：
构造器中隐藏的两句代码：super()和{} 调用普通代码块。
public AA() {
super();
{};
}

package com.hsf.extends_.static_;

public class code_block {
    public static void main(String[] args) {
        Bb bb = new Bb();
    }
}


class  Bb{
    public Bb() {
        // {} 注意默认调用普通代码块
        /*
        *   {
                System.out.println("Bb普通代码块");
        *   }
        * */
        System.out.println("Bb的构造方法"); // 第三句输出
    }

    static {
        System.out.println("Bb静态代码块");  // 首先输出
    }
    {
        System.out.println("Bb普通代码块"); // 第二句输出
    }
}

5、创建对象时，代码执行顺序：有继承关系时：

可以结合对象创建过程来理解：
1、创建对象时，首先进行类加载：类加载时会执行静态代码块和静态属性。
先加载父类：执行父类的静态代码块和静态方法（如果静态方法被调用了的话）。
再加载子类：执行子类的静态代码块和静态方法（如果静态方法被调用了的话）。
2、创建对象：创建对象时执行子类的构造器：子类构造器有默认super和{}
（1）、先执行子类构造器的super（）：
a、进入父类，父类构造器也有super（）：指向object；
b、执行父类构造器中的{}：执行父类的普通代码块和普通属性。
c、执行完毕后执行父类的构造器。
（2）、执行子类{}：执行子类普通代码块和普通属性，最后执行子类普通代码块好普通属性。