java中代码块的定义以及练习

代码块

class Movie {
    private String name;
    private double price;
    private String director;

    public Movie(double price, String director) {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
        this.price = price;
        this.director = director;
    }

    public Movie(String name) {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
        this.name = name;
    }

    public Movie(String name, double price, String director) {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
        this.name = name;
        this.price = price;
        this.director = director;
    }
    // 三个构造器构成重载 
}

上述代码中三个构造器都有相同的语句，使函数看上去比较啰嗦，这是我们可以把相同语句放入一个代码块

class Movie {
    private String name;
    private double price;
    private String director;

    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    }// 这样当我们调用构造器 都会调用该代码块

    public Movie(double price, String director) {
        this.price = price;
        this.director = director;
    }

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

    public Movie(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
    }
    // 三个构造器构成重载
}

以上是利用代码块来简化代码 代码块是一种构造器的机制 可以在调用构造器是有限调用代码块

静态代码块

静态代码块随着类的加载而实行 且只会执行一次

代码演示

public class t1 {
    public static void main(String[] args) {
        // 1 类加载情况
        //AA aa = new AA();
        // 2 创建子类对象时父类的追加
        //BB bb = new BB();
        // 3 使用类的静态代码块是静态方法会被执行 加载子类时候会先把父类加载出来
       // System.out.println(cat.n1);
        //DD dd = new DD();
        //DD dd1 = new DD();
        // 类被加载了一次 所以静态代码块只会被执行一次
        // 非静态代码块调用一次 加载一次
        // 只有在每创建对象时 普通代码块才会被加载 加载类是 普通代码块不会被调用
        // 可以这样理解 1 static 静态代码块是被加载时执行 所以只会执行一次
        // 2 普通代码块是 创建对象时被加载的 创建一次加载一次
        // 类加载的三种情况需要记忆
        System.out.println(DD.n1);
    }
}
class DD{
    // 静态代码块
    public static int n1 = 8888;
    static {
        System.out.println("dd静态代码块");
    }
    {
        System.out.println("DD的普通代码块");
    }
}
class animals{
    // 静态代码块
    static {
        System.out.println("动物静态代码块");
    }
}
class cat extends animals{
    // 静态代码块
    public static int n1 = 999;// 静态属性

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

class BB extends AA {
    // 静态代码块
    static {
        System.out.println("子类静态代码块");
    }
}

class Movie {
    private String name;
    private double price;
    private String director;

    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    }// 这样当我们调用构造器 都会调用该代码块

    public Movie(double price, String director) {
        this.price = price;
        this.director = director;
    }

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

    public Movie(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
    }
    // 三个构造器构成重载
}

class AA {
    //静态代码块
    static {
        System.out.println("父类代码块1，被执行");
    }

    static {
        System.out.println("父类代码块2，被执行");
    }
}

public class t1 {
    public static void main(String[] args) {
        A a = new A();
        //输出顺序  从类的开始进行输出
        // 输出时 静态的执行优先级高
    }
}

class A {
    private static int n1 = getN1();
    {
        System.out.println("A的普通代码块被调用");
    }

    private int n2 = getN2();

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

    public static int getN1() {
        System.out.println("getN1被调用");
        return 100;
    }
    public int getN2(){// 非静态的普通方法
        System.out.println("getN2被调用");
        return 200;
    }

}

java的静态代码执行的优先级高 构造器的执行优先级最低 优先级相同按顺序执行

调用子类的时候，没有写super() 的话 默认有一个super() .

public class t1 {
    public static void main(String[] args) {
        new BBB();// A类 BBB普通 BBB构造器
    }
}

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

class BBB extends AAA{
    {
        System.out.println("BBB的普通代码块被调用");
    }
    public BBB(){
        // super()
        // 调用本类的普通代码块
        System.out.println("BBB()构造器被调用...");
    }
}