第十五章 JavaSE专题之面向对象高级二 - 代码块详述

1、代码块概述

• 代码块：又称为初始化块，属于类的成员，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来；
• 和方法的不同：
  • 1、没有方法名，没有返回值，没有参数，只有方法体；
  • 2、不通过对象或者类显式调用，而是在加载类时，或创建对象时隐式调用
• 基本语法

[修饰符] {
    代码
}

• 注意事项：

  • 1、修饰符可选，要写的话，也只能写static；
  • 2、代码块分为两种，使用static修饰的称为静态代码块，没有static，叫普通代码块；
  • 3、逻辑语句可以为任意的逻辑语句（输入、输出、方法调用、循环、判断等）；
  • 4、；号可以写上，也可以省略；

• 范例

/*
1、下面三个构造器都有相同的语句;
2、这样看起来代码有点荣冗余;
3、这时我们可以把相同的语句，放入到一个代码块中即可;
4、这样不管我们调用哪个构造器，创建对象，都会先调用代码块的内容;
5、代码块的调用顺序优先于构造器...
*/

//1、创建Child类
public class Child {

    {
        System.out.println("代码块广告投放！！！");
    }

    private String school;
    private String name;
    private double age;

    public Child(String name){
        System.out.println("一个参数广告投放！！！");
        this.name = name;
    }

    public Child(String school, String name) {
        System.out.println("两个参数广告投放！！！");
        this.school = school;
        this.name = name;
    }

    public Child(String school, String name, double age) {
        System.out.println("三个参数广告投放！！！");
        this.school = school;
        this.name = name;
        this.age = age;
    }

    public void join(){
        System.out.println(name + "加入了游戏...");
    }
}

//2、创建main方法调用Child类
public class main {
    public static void main(String[] args) {
        Child child1 = new Child("li");

        Child child2 = new Child("li","小学");
        
        Child child3 = new Child("li","zhi",112);
    }
}

• 运行结果
  

• 代码块的好处

  • 1、相当于另外一种形式的构造器，可以做初始化操作;
  • 2、如果多个构造器都有相同的重复语句，可以抽取到代码块中，提高代码的复用性;

2、静态代码块和普通代码块的区别

• 范例

//1、创建Child类
public class Child {

    static {
        System.out.println("广告投放！！！");
    }
    
    private String school;
    private String name;
    private double age;

    public Child(String name){
        System.out.println("广告投放！！！");
        this.name = name;
    }

    public Child(String school, String name) {
        System.out.println("广告投放！！！");
        this.school = school;
        this.name = name;
    }

    public Child(String school, String name, double age) {
        System.out.println("广告投放！！！");
        this.school = school;
        this.name = name;
        this.age = age;
    }

    public void join(){
        System.out.println(name + "加入了游戏...");
    }
}


//2、创建main方法调用Child类
public class main {
    public static void main(String[] args) {
        Child child1 = new Child("li");

        Child child2 = new Child("li","小学");
        
        Child child3 = new Child("li","zhi",112);
    }
}

• 运行结果

3、静态代码块加载时机（重点）

• 1、创建对象实例时（new）；

• 2、创建子类对象实例（new），父类也会被加载；

• 3、使用类的静态成员时（静态属性和静态方法）

• 范例

//1、创建父类Child
public class Child {
	
    //静态代码块
     static {
        System.out.println("广告投放！！！");
    }

    public static double fee = 0;
    private String name;


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

    public static void join(){
        fee += fee;
        System.out.println(fee);
    }
}


//2、创建子类Son - Son继承Child
public class Son extends Child {

    public Son(String name) {
        super(name);
    }

    public void showOut(){
        System.out.println("子类被加载");
    }
}


//3、创建main方法加载父类
public class main {
    public static void main(String[] args) {
        //1、创建父类实例时被加载
        //Child child1 = new Child("li");

        //2、创建子类实例时被加载
        //Son son = new Son("li");

        //3、使用父类的静态成员
        //System.out.println(Child.fee);

        //4、使用子类的静态成员
        //System.out.println(Son.fee);

        //5、使用父类的静态方法
        //Child.join();

        //6、使用子类的静态方法
        Son.join();

    }
}
//以上六种情况都可以加载静态代码块，但是要记住静态代码块仅仅会被加载一次！！！

4、普通代码块加载时机

• 普通代码块在创建对象实例时，会被隐式调用，被创建一次则加载一次；
  • 注意事项：如果只是使用类的静态成员时，普通代码块并不会被执行；

//1、创建父类 - Father类
public class Father {
	//创建普通代码块
    {
        System.out.println("广告投放！！！");
    }

    public static double fee = 0;
    private String name;


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

    public static void join(){
        fee += fee;
        System.out.println(fee);
    }
}

//2、创建一个子类继承父类 -- Son类继承Child类
public class Son extends Father {

    public Son(String name) {
        super(name);
    }

    public void showOut(){
        System.out.println("子类被加载");
    }
}

//3、创建main方法调用父类和子类
public class hello {
    public static void main(String[] args) {
        //1、创建父类实例时被加载
        Father father = new Father("li");

        //2、创建子类实例时被加载
        Son son = new Son("li");
    }
}

• 运行结果

5、创建一个对象时一个类调用顺序（重点、难点）

Ⅰ、调用静态代码块和静态属性初始化

​ 注意：静态代码块和静态变量初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用；

Ⅱ、调用普通代码块和普通属性的初始化

​ 注意：普通代码块和普通初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用；

Ⅲ、调用构造方法

• 范例

//1、创建Child类
public class Child {
    //1、静态代码块
    static {
        System.out.println("静态代码块被调用！！！");
    }

    //4、普通代码块
    {
        System.out.println("普通代码块被调用！！！");
    }

    //2、静态属性
    public static double fee = getfee();

    //5、普通变量
    private String name = getname();

    //7、创建构造器
    public Child(String name){
        System.out.println("构造器调用！！！");
        this.name = name;
    }
    //3、静态方法
    public static int getfee(){
        System.out.println("静态方法被调用！！！");
        return 100;
    }

    //6、普通方法
    public String getname(){
        System.out.println("普通方法被调用！！！");
        return "普通方法";
    }
}



//2、创建main方法调用Child类
public class main {
    public static void main(String[] args) {
        //1、创建父类实例时被加载
        Child child1 = new Child("li");
    }
}

• 运行结果