Java 复习 【知识改变命运】第九章-代码块

时间：2024-11-21 16:55:48

1：代码块的基本介绍和基本语法

  • 代码块又被称为初始块，属于类中的成员，类似于方法把逻辑语句放在{}中，但是没有名字返回值，没有参数，也不能被调用，在加载类或者创建对象的时候被隐式调用。
  • 语法：
[修饰符] {
代码
};
  • 修饰符可选且只能是static
  • 代码块分两种一种是静态代码块，一种是实例代码块/普通代码/非静态代码块
  • ；可以写上也可以省略

2：体会代码块的用处

  • 相当于另外一种形式的构造体，可以进行初始化此操作
  • 当多个构造器中都有重复的语句，就可以抽取到初始代码块中，提高代码重用性
class CodeBlock01 {
    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;
//3 个构造器-》重载
//老韩解读
//(1) 下面的三个构造器都有相同的语句
//(2) 这样代码看起来比较冗余
//(3) 这时我们可以把相同的语句，放入到一个代码块中，即可
//(4) 这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
//(5) 代码块调用的顺序优先于构造器.. 
{
System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正是开始...");
};
public Movie(String name) {
        System.out.println("Movie(String name) 被调用...");
        this.name = name;
        }
public Movie(String name, double price) {
        this.name = name;
        this.price = price;
        }
public Movie(String name, double price, String director) {
        System.out.println("Movie(String name, double price, String director) 被调用...");
        this.name = name;
        this.price = price;
        this.director = director;
        }
}

3：代码块的细节

  • static代码块也叫静态代码块，作用是对类进行初始化，而且它之随着类的加载而执行，且只会执行一次，如果是普通代块，每创建一个对象，执行一次
  • 类加载的几种情况：创建对象实例的时候，创建子对象的实例，父类类也会被加载，使用静态成员时（静态属性，静态方法）
  • 普通代码块：在创建对象实例的时候，会被隐形调用，被创建一次就会调用一次，如果使用类的静态成员，普通代码块并不会执行。
  • static的=代码是类加载的时候，且只会被执行一次，普通代码块是创建对象的时候，创建一次对象执行一次
public class Code {
    public static void main(String[] args) {
//类被加载的情况举例
//1. 创建对象实例时(new)
// AA aa = new AA();
//2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
//AA aa2 = new AA();
//3. 使用类的静态成员时(静态属性，静态方法)
// System.out.println(Cat.n1);
//static 代码块，是在类加载时，执行的，而且只会执行一次.
// DD dd = new DD();
 //DD dd1 = new DD();
//普通的代码块，在创建对象实例时，会被隐式的调用。
// 被创建一次，就会调用一次。
// 如果只是使用类的静态成员时，普通代码块并不会执行
        System.out.println(DD.n1);//8888, 静态模块块一定会执行
    }
}
class DD {
    public static int n1 = 8888;//静态属性
    //静态代码块
    static {
        System.out.println("DD 的静态代码 1 被执行...");//
    }
//普通代码块, 在 new 对象时，被调用，而且是每创建一个对象，就调用一次
//可以这样简单的，理解 普通代码块是构造器的补充
{
    System.out.println("DD 的普通代码块...");
}
}
class Animal {
    //静态代码块
    static {
        System.out.println("Animal 的静态代码 1 被执行...");//
    }
}
class Cat extends Animal {
    public static int n1 = 999;//静态属性
    //静态代码块
    static {
        System.out.println("Cat 的静态代码 1 被执行...");//
    }
}
class BB {
    //静态代码块
    static {
        System.out.println("BB 的静态代码 1 被执行...");//1
    }
}
class AA extends BB {
//静态代码块
static {
    System.out.println("AA 的静态代码 1 被执行...");//2
}
}

4：创建一个对象时，在一个类中的调用顺序（难点）

  • 调用静态代码块和静态属性初始化：静态代码块和静态属性的调用优先级一样，如果有多个代码块和多个静态变量初始化，则按他们的顺序调用
  • 调用普通代码块和普通属性的初始化：两者调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按他们定义的顺序来调用
class A {
    { //普通代码块
        System.out.println("A 普通代码块 01");
    }
    private int n2 = getN2();//普通属性的初始化
    static { //静态代码块
        System.out.println("A 静态代码块 01");
    }
    //静态属性的初始化
    private static int n1 = getN1();
    public static int getN1() {
        System.out.println("getN1 被调用...");
        return 100;
    }
    public int getN2() { //普通方法/非静态方法
        System.out.println("getN2 被调用...");
        return 200;
    }
    //无参构造器
    public A() {
        System.out.println("A() 构造器被调用");
    }
}

在这里插入图片描述

  • 构造器的最前面其实隐含了super()和调用普通代码块，静态代码块和静态属性初始化，在类的加载时候，就执行完成，因此优于构造器和普通代码块执行的
class A {
	public A() {//构造器
	//这里有隐藏的执行要求
	//（1）super();
	// (2)调用普通代码块
	System.out.println("ok");
	}
}

public class Code{
    public static void main(String[] args) {
        new BBB();//(1)AAA 的普通代码块(2)AAA() 构造器被调用(3)BBB 的普通代码块(4)BBB() 构造器被调用
    }
}
class AAA { //父类 Object
    {
        System.out.println("AAA 的普通代码块");
    }
    public AAA() {
//(1)super()
//(2)调用本类的普通代码块
        System.out.println("AAA() 构造器被调用....");
    }
}
class BBB extends AAA {
    {
        System.out.println("BBB 的普通代码块...");
    }
    public BBB() {
//(1)super()
//(2)调用本类的普通代码块
        System.out.println("BBB() 构造器被调用....");
    }
}
  • 总结：创建一个子类父类对象时候（继承关系），他们的静态代码，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：
  • 1：父类的静态方法和的静态属性（优先级一样，按定义的顺序）
  • 2：子类的静态代码块和静态属性（优先级一样，按定义的顺序）
  • 3：父类的普通代码块和普通属性初始化（优先级一样，按定义的顺序执行）
  • 4：父类的构造方法
  • 5：子类的普通代码块和普通属性初始化（优先级一样，按定义的顺序执行）
  • 6：子类的构造方法
class Sample
{
    Sample(String s)
    {
        System.out.println(s);
    }
    Sample()
    {
        System.out.println("Sample 默认构造函数被调用");
    }
}
//====
public class Test{
    Sample sam1=new Sample("sam1 成员初始化");//
    static Sample sam=new Sample("静态成员 sam 初始化 ");//
    static{
        System.out.println("static 块执行");//
        if(sam==null)System.out.println("sam is null");
    }
    Test()//构造器
    {
        System.out.println("Test 默认构造函数被调用");//
    }
    //主方法
    public static void main(String str[])
    {
        Test a=new Test();//无参构造器
    }
}

//运行结果， 输出什么内容，并写出. 2min 看看
//1. 静态成员 sam 初始化
//        2. static 块执行
//        3. sam1 成员初始化
//        4. Test 默认构造函数被调用

相关文章