java学习--代码块

package com.block.test01;
class Main{
    public static void main(String[] args) {
        Block block = new Block("你好，李焕英");
        new Block("你好",12,24);
    }
}
public class Block {
    String name;
    int begin_time;
    int end_time;
//如果在调用构造器时都需要打印那几句话，那么每个构造器都需要加入这几句代码
    //这样实在冗余，这个时候可以使用代码块
{
     System.out.println("电影正在加载----");
        System.out.println("电影加载成功");
        System.out.println("电影开始播放");
}
    public Block(String name) {
        System.out.println("第一个构造器");
//        System.out.println("电影正在加载----");
//        System.out.println("电影加载成功");
//        System.out.println("电影开始播放");
        this.name = name;
    }

    public Block(String name, int begin_time) {

//        System.out.println("电影正在加载----");
//        System.out.println("电影加载成功");
//        System.out.println("电影开始播放");
        this.name = name;
        this.begin_time = begin_time;
    }

    public Block(String name, int begin_time, int end_time) {
        System.out.println("最后一个构造器");
//        System.out.println("电影正在加载----");
//        System.out.println("电影加载成功");
//        System.out.println("电影开始播放");
        this.name = name;
        this.begin_time = begin_time;
        this.end_time = end_time;
    }
}

运行结果：

使用代码块，他会先运行代码块，再运行构造器内代码，并且跟代码块的位置美关系，放在后面也会先运行代码块内容

多了个父类时，会先加载父类

但是普通代码块，创建一次对象就执行一次

用类名直接调用静态属性时没有创建新对象这个动作，所以只会调运静态代码块，普通代码块就不会执行

package com.block.test02;
class Main{
    public static void main(String[] args) {
        Block_ block = new Block_();
    }
}
public class Block_ {
    int a=getA();
    static int b=getB();

    public Block_() {
        System.out.println("构造器被调用");
    }

    {
        System.out.println("普通代码块被执行");
    }
    static {
        System.out.println("静态代码块被执行");
    }
    int getA()
    {
        System.out.println("普通属性被执行");
        return 100;
    }
   static int getB()
    {
        System.out.println("静态属性被执行");
        return 100;
    }

}

运行结果：

静态先运行，有两种或多种静态的代码语句就按顺序依次执行，然后再执行普通代码语句，有两种或多种普通的代码语句就按顺序依次执行。最后再执行构造器

package com.block.test03;

public class Block_ {
    public static void main(String[] args) {
        B b = new B();

    }
}
class A{
    {
        System.out.println("a类代码块");
    }

    public A() {
        System.out.println("a类构造器");
    }
}
class B extends A{
    {
        System.out.println("b类代码块");
    }

    public B() {
        System.out.println("b类构造器");
    }
}

运行结果：

解析：

在创建对象B时会调用B的无参构造器（前会进行加载类的动作，在加载类的时候会开始执行static类型的数据，本段代码没有则直接忽略），于是乎进入B的无参构造器，但是在构造其中隐藏着两个动作，1.是会默认调用父类的无参构造器，2.是会默认调运（初始化）本类的代码块，普通参数.....

所以他会先到父类A中的默认构造器中，而A的默认构造器也会1.默认调用父类的无参构造器，2.是会默认调运（初始化）本类的代码块，普通参数.....但A类的父类时Object，所以调运其默认构造器是无事发生的，但A类是有代码块的，所以，会最执行代码块的内容再执行a的无参构造器内容再回到B类，B类调运完父类无参构造器就会开始调运本类的代码块了，所以再执行本类代码块内容，最后再执行构造器内容

package com.block.test04;

public class Black__ {
    public static void main(String[] args) {
        C c = new C();

    }
}
//加载类时A静态属性 A静态代码块  B静态属性 B静态代码块 C静态属性 C静态代码块
//创建对象时然后进入构造器，构造器默认执行两个动作，先是调用父类无参构造器再初始化代码块和属性等。。。
//于是再创建C对象时进入了C的无参构造器然后调用了他的父类B的无参构造器，而进入B也默认执行两个动作，先是调用父类无参构造器再初始化代码块和属性等。。。
//于是又调用了A类无参构造器，A类父类为objec所以调用其构造器无事发生，于是进入a类代码块属性的初始化，先后顺序由其位置决定的
//该类中属性在前所以先运行属性代码，所以此时打印出A普通属性，再就是A普通代码块最后A类构造器被执行
//然后回到了B类b类调用完A后开始初始化自己的属性代码块等，顺序按写的先后，于是打印出B普通属性B普通代码块最后B类构造器被执行
//最后再是C类同上C普通属性 C普通代码块  C类构造器被执行
class A{
    static int a=getA();
    int b=getB();
    static {
        System.out.println("A静态代码块");
    }
    {
        System.out.println("A普通代码块");
    }
    static int getA()
    {
        System.out.println("A静态属性");
        return 100;

    }
    int getB()
    {
        System.out.println("A普通属性");
        return 100;
    }

    public A() {
        System.out.println("A类构造器被执行");
    }
}
class B extends A{
    static int c=getC();
    int d=getD();
    static {
        System.out.println("B静态代码块");
    }
    {
        System.out.println("B普通代码块");
    }
    static int getC()
    {
        System.out.println("B静态属性");
        return 100;

    }
    int getD()
    {
        System.out.println("B普通属性");
        return 100;
    }

    public B() {
        System.out.println("B类构造器被执行");
    }

}
class C extends B{
    static int E=getE();
    int F=getF();
    static {
        System.out.println("C静态代码块");
    }
    {
        System.out.println("C普通代码块");
    }
    static int getE()
    {
        System.out.println("C静态属性");
        return 100;

    }
    int getF()
    {
        System.out.println("C普通属性");
        return 100;
    }

    public C() {

        System.out.println("C类构造器被执行");
    }
}
//A

解析：

在创建对象时会进行加载类的动作，加载类时会开始执行静态属性的代码，并按前后顺序进行于是就先输出了A静态属性 A静态代码块  B静态属性 B静态代码块 C静态属性 C静态代码块
再然后创建对象时进入构造器，构造器默认执行两个动作，先是调用父类无参构造器再初始化代码块和属性等。。。（谁在前谁先被执行）
于是再创建C对象时进入了C的无参构造器然后调用了他的父类B的无参构造器，而进入B也默认执行两个动作，先是调用父类无参构造器再初始化代码块和属性等。。。
于是又调用了A类无参构造器，A类父类为objec所以调用其构造器无事发生，于是进入a类代码块属性的初始化，先后顺序由其位置决定的，该类中属性在前所以先运行属性代码，所以此时打印出A普通属性，再就是A普通代码块最后A类构造器被执行
然后回到了B类b类调用完A后开始初始化自己的属性代码块等，顺序按写的先后，于是打印出B普通属性B普通代码块最后B类构造器被执行
最后再是C类同上C普通属性 C普通代码块  C类构造器被执行

例题：