静态代码块&&非静态代码块

静态代码块&&非静态代码块--学习笔记

静态随类，非静态随对象
执行顺序
     1.在一个类中，初始化的时候，会直接执行静态代码块中的内容，初始化静态属性，以及方法
     2.当创建对象的时候，会优先执行非静态代码块中的内容，初始化类中的局部变量
     3.然后根据对象创建的类型，来调用是带参构造还是无参构造
     4.最后是调用的对象其他操作

在类中非静态方法，代码块可以调用非静态的方法属性吗？ 反之呢
    非静态可以调用静态，静态无法调用非静态，因为加载顺序已经决定了。反之肯定不行。

 package Block;

public class Black {
    private  String name;
    public static int init = 1001;

    // 非静态代码块
    {
        System.out.println("isnot static Block");
    }
    // 静态代码块
    static {
        System.out.println("static Block");
    }

    // 无参构造
    public Black(){
        System.out.println("no args constructor");
    }

    // 带参构造
    public Black(String name) {
        this.name = name;
    }

    // 静态方法
    public static void Show(){
        System.out.println("static method");
    }
}

测试类

package Block;

public class BlockTest {
    public static void main(String[] args) {

        Black black = new Black();
        Black black1 = new Black();
        Black.Show();
    }
}

执行结果
static Block
isnot static Block
no args constructor
isnot static Block
no args constructor
static method

可以看出，先执行静态代码块

当创建对象Black的时候，先执行非静态代码块，再是无参构造

再次创建对象black1的时候，又一次执行非静态代码块，其次是无参构造

最后调用了方法输出。

在一个类中，静态代码块只会执行一次，而非静态代码块，构造器则会随着对象的每一次创建而执行

 

在加上继承，可以看出先执行父类静态代码块，在执行子类静态代码块，其次是父类非静态代码块，父类构造器，子类非静态代码块，子类构造器

package Block;

public class Black extends Blackfather{
    private String name;
    public static int init = 1001;

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

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

    public Black() {
        System.out.println("Black 无参构造");
    }

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

    public static void Show() {
        System.out.println("Black 静态方法");
    }
}


class Blackfather {
    private String name;
    public static int init = 1001;

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

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

    public Blackfather() {
        System.out.println("Blackfather无参构造");
    }

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

    public static void Show() {
        System.out.println("Blackfather 静态方法");
    }
}

测试

package Block;

public class BlockTest {
    public static void main(String[] args) {
        System.out.println("Block and Blockfather Test");
        Black b = new Black();
       // Blackfather bf = new Blackfather();
    }
}


执行结果
Block and Blockfather Test
Blackfather 静态代码块
Black 静态代码块
Blackfather非静态代码块
Blackfather无参构造
Black 非静态代码块
Black 无参构造

如果main方法与Black类写在同一个方法中，则先执行静态代码块中的属性

 

显示赋值和代码块赋值无优先级，看先后顺序

package Block;

public class Demo {
    public static void main(String[] args) {
    Demo1 d = new Demo1();
        System.out.println(d.age);
    }


}

class Demo1 {
    {
        age = 18;
    }
    int age = 12;

    
/*    int age = 12;
    {
        age = 18;
    }*/
}

结果为 12 反过来为18