Java基础代码块(静态/非静态)

package com.hspedu.codeblock_;

public class Course385 {
    public static void main(String[] args) {
        // 代码块
        Movie movie = new Movie("你好李焕英");
        System.out.println("========================");
        Movie movie2 = new Movie("唐探3", 100, "陈思诚");
    }
}


class Movie {

    private String name;

    private double price;

    private String director;

    // 代码块
    /*
     * 1、构造器都会执行相同的代码语句
     * 2、相同的部分可以提出到代码块
     * 3、不管调用哪一个构造器都会优先调用代码块
     * 4、代码块优先于构造器执行
     * 5、代码块可以用static修饰，也可以不修饰
     * */

    {
        System.out.println("广告开始..");
        System.out.println("电影开始..");
    }

    public Movie(String name) {
        System.out.println("《" + name + "》");
        this.name = name;
    }

    public Movie(String name, double price) {
        System.out.println(name + ", " + price);
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
        System.out.println("《" + name + "》" + ", " + price + ", " + director);
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

package com.hspedu.codeblock_;

public class Course386 {
    public static void main(String[] args) {
        // 代码块细节

        /*
         * 1、static代码块：静态代码块，作用是对类的初始化，随着类加载而执行
         *   并且只会执行一次。如果是非静态代码块则每次创建对象，就会执行一次
         * 2、类什么时候被加载？(重要)
         *   1）new创建对象实例
         *   2）new创建子类对象实例
         *   3）使用类的静态成员（静态属性、静态方法）
         * 3、非静态代码块，在创建对象实例时，会隐式调用，
         *  如果只使用类的静态成员则不会执行非静态代码块
         *
         * */

        // （1）new实例化对象加载
        AA aa = new AA();
        System.out.println("======================");

        // （2）new子类实例化加载，而且父类先加载，子类后加载
        AA aa2 = new AA();
        System.out.println("======================");

        // （3）调用静态成员，类加载，执行静态代码块(父类会先加载，先执行父类的静态代码块)
        System.out.println(Cat.n1);
        System.out.println("======================");

        // 静态代码块只会在类加载时执行一次，同AA类执行效果一样
//        DD d1 = new DD();
//        DD d2 = new DD();
        System.out.println(DD.n1);  // 只调用静态成员不会执行非静态代码块，静态代码块在第一次类加载时调用

    }
}

class Animal {

    static {
        System.out.println("Animal类的静态代码块");
    }
}

class Cat extends Animal {

    public static int n1 = 999;

    static {
        System.out.println("Cat类的静态代码块");
    }
}

class AA extends BB {

    // 静态代码块
    static {
        System.out.println("AA类的静态代码块1");
    }

    public AA() {
        System.out.println("AA对象创建");
    }
}

class BB {

    static {
        System.out.println("BB类的静态代码块1");
    }

    public BB() {
        System.out.println("BB对象创建");
    }
}

class DD {

    public static int n1 = 100;

    static {
        System.out.println("DD类的静态代码块");
    }

    // 类加载和非静态代码块的执行没有关系
    {
        System.out.println("DD类的非静态代码块");
    }
}

package com.hspedu.codeblock_;

public class Course387 {
    public static void main(String[] args) {
        // 代码块细节 2

        /*
         * 4、在同一个类中创建对象的调用顺序：
         *   （1）先调用静态代码块和静态属性的初始化：调用顺序按照代码定义的顺序执行
         *   （2）然后调用非静态代码块和非静态属性初始化：调用顺序同样按照定义的顺序执行
         *   （3）最后调用构造器方法
         * 原因分析：类加载在对象创建之前，静态成员在类加载时调用执行，非静态成员在创建对象执行
         * */

        //
        A a = new A();

    }
}


class A {
    // 非静态代码块
    {
        System.out.println("A类的非静态代码块");    // 3
    }

    // 静态属性初始化
    private static int n1 = getN1();

    // 非静态属性初始化
    private int n2 = getN2();

    // 静态代码块
    static {
        System.out.println("A类的静态代码块  static"); // 2
    }

    // 静态方法
    public static int getN1() {
        System.out.println("getN1方法被调用  static");   // 1
        return 100;
    }

    // 非静态方法
    public int getN2() {
        System.out.println("getN2方法被调用");   // 4
        return 200;
    }

    public A() {
        System.out.println("对象A创建");    // 5
    }
}

package com.hspedu.codeblock_;

public class Course388 {
    public static void main(String[] args) {
        // 代码块细节 3

        /*
        * 5、构造器前隐藏了super(..);和调用非静态代码块，先执行super再执行非静态代码块
        *   存在继承关系执行顺序：
        *       父类静态 => 子类静态 => 父类非静态 => 父类构造器 => 子类非静态 => 子类的构造器
        *
        * */

        new BBB();
    }
}


class AAA {

    {
        System.out.println("AAA非静态代码块");
    }

    static {
        System.out.println("AAA static block");
    }

    public AAA() {
        System.out.println("创建AAA类对象");
    }
}

class BBB extends AAA {

    {
        System.out.println("BBB非静态代码块");
    }

    static {
        System.out.println("BBB static block");
    }

    public BBB() {
        System.out.println("创建BBB类对象");
    }
}

package com.hspedu.codeblock_;

public class Course389 {
    public static void main(String[] args) {
        // 代码块细节 3

        /*
         * 6、创建子类对象时，代码块执行顺序：
         *  （1）先执行父类的静态代码块和静态属性初始化
         *  （2）再执行子类的静态代码块和静态属性初始化
         *  （3）父类的普通代码块和普通属性初始化（父类非静态成员）
         *  （4）父类的构造器
         *  （5）子类的普通代码块和普通属性初始化（子类非静态成员）
         *  （6）子类的构造器
         *
         * 7、静态代码块只能调用静态成员，非静态代码块可以调用任意成员
         * */

        /*
         * 创建对象：
         *   1、进行类的加载
         *       1.1先加载父类A02，再加载B02（静态代码块和静态属性初始化和类加载相关）
         *   2、创建对象
         *      2.1先执行非静态代码块和非静态属性初始化
         *      2.2再执行构造器内的语法
         *      (有继承会执行super()方法)
         * */
        new B02();

        System.out.println("====================");

        new C02();

    }
}

class A02 {

    private static int n1 = getVal01();

    static {
        System.out.println("A02静态代码块"); // 2
    }

    {
        System.out.println("A02非静态代码块");    // 5
    }

    public int n3 = getVal02();

    public static int getVal01() {
        System.out.println("getVal01"); // 1
        return 10;
    }

    public int getVal02() {
        System.out.println("getVal02"); // 6
        return 10;
    }

    public A02() {
        System.out.println("A02构造器执行"); // 7
    }
}

class B02 extends A02 {

    private static int n3 = getVal03();

    static {
        System.out.println("B02的静态代码块");    // 4
    }


    public int n5 = getVal04();

    {
        System.out.println("B02的非静态代码块");   // 9
    }

    public static int getVal03() {
        System.out.println("getVal03"); // 3
        return 10;
    }

    public int getVal04() {
        System.out.println("getVal04"); // 8
        return 10;
    }


    public B02() {
        System.out.println("B02构造器执行"); // 10
    }
}

class C02 {

    private int n1 = 100;

    private static int n2 = 200;


    private void m1() {

    }

    private static void m2() {

    }

    // 静态代码块只能使用静态成员
    static {
//        System.out.println(n1);
        System.out.println(n2);
//        m1();
        m2();
    }

    // 非静态代码块都可以调用
    {
        System.out.println(n1);
        System.out.println(n2);
        m1();
        m2();
    }
}