Java学习之代码块

目录

目录

一、代码块的基本介绍

二、基本语法

注意事项

三、代码块的好处和案例演示

 四、注意事项和使用细节

第一点

第二点

第三点

小结

第四点

第五点

第六点

第七点

五、练习题

第一题

第二题

考察知识点

结论

结果

一、代码块的基本介绍

        代码化块又称为初始化块,属于类中的成员[即 是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。
        但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用

二、基本语法

[修饰符]{

        代码

};

注意事项

1)修饰符 可选，要写的话，也只能写 static

2)代码块分为两类，使用static 修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块

3) 逻辑语句可以为任何逻辑语句 (输入、输出、方法调用、循环、判断等)
4)； 号可以写上，也可以省略。

三、代码块的好处和案例演示

1)相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作

2)场景: 如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

package com.hspedu.codeblock_;

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie1 = new Movie("你好李焕英");
        System.out.println("==========");
        Movie movie2 = new Movie("你好李焕英", 50);
        System.out.println("==========");
        Movie movie3 = new Movie("你好李焕英", 50, "贾玲");
    }
}
class Movie {
    private String name;
    private double price;
    private String director;

    //三个构造器构成了重载
    //观察可得：下面的三个构造器都有相同的语句，这样看起来比较冗余
    //这时我们可以把相同的语句放入到一个代码块中即可
    //不管调用哪个构造器，创建对象，都会先调用代码块的内容
    //代码块的调用顺序优先于构造器

    {
        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) {
        System.out.println("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;
    }
}

创建三个对象，分别调用三个构造器，但是在调用构造器之前都会首先调用代码块

 四、注意事项和使用细节

第一点

static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次（非常重要）。如果是普通代码块，每创建一个对象，就执行。

如果将上述代码块改成static代码块，那么运行结果就会不同

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
      
        //static 代码块，是在类加载时执行的,而且只会执行一次
        DD dd = new DD();
        DD dd1 = new DD();


    }
}

class DD {

    //静态代码块
    static {
        System.out.println("DD 的静态代码 1 被执行...");//
    }
}

第二点

承接第一点，类什么时候被加载[重要背!]
一、创建对象实例时(new)

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类加载的时候就会隐式调用代码块，
        // 类加载的三种情况：1)创建对象实例
        AA aa = new AA();

    }
}

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

二、创建子类对象实例，父类也会被加载

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类加载的时候就会隐式调用代码块，
        // 类加载的三种情况：1)创建对象实例
        //AA aa = new AA();

        //2.创建子类对象实例父类也会被加载, 而且,父类先被加载,子类后被加载
        AA aa = new AA();
    }
}
class BB {
    static {
        System.out.println("BB 的静态代码块1被执行...");
    }
}
class AA extends BB{
    //静态代码块
    static {
        System.out.println("AA 的静态代码块1被执行...");
    }
}

三、使用类的静态成员时(静态属性，静态方法)

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类加载的时候就会隐式调用代码块，
        // 类加载的三种情况：1)创建对象实例
        //AA aa = new AA();

        //2.创建子类对象实例父类也会被加载, 而且,父类先被加载,子类后被加载
       // AA aa = new AA();

        //3. 使用类的静态成员时(静态属性, 静态方法)
        System.out.println(Cat.n1);

    }
}

class Cat{
    public static int n1 = 999;//静态属性
    static {
        System.out.println("Cat 的静态代码块1被执行...");
    }
}
class BB {
    static {
        System.out.println("BB 的静态代码块1被执行...");
    }
}
class AA extends BB{
    //静态代码块
    static {
        System.out.println("AA 的静态代码块1被执行...");
    }
}

 如果调用子类的静态属性，父类也会被加载

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类加载的时候就会隐式调用代码块，
        // 类加载的三种情况：1)创建对象实例
        //AA aa = new AA();

        //2.创建子类对象实例父类也会被加载, 而且,父类先被加载,子类后被加载
       // AA aa = new AA();

        //3. 使用类的静态成员时(静态属性, 静态方法)
        System.out.println(Cat.n1);

    }
}
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被执行...");
    }
}
class AA extends BB{
    //静态代码块
    static {
        System.out.println("AA 的静态代码块1被执行...");
    }
}

类加载只和static代码块的执行有关，和普通代码块没有任何关系

第三点

普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次，就会调用一次 。见

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
       
        //static 代码块，是在类加载时执行的,而且只会执行一次
        DD dd = new DD();
        DD dd1 = new DD();

        //普通的代码块,在创建对象实例时,会被隐式的调用。
        // 被创建一次,就会调用一次。
        // 如果只是使用类的静态成员时,普通代码块并不会执行


    }
}

class DD {

    //静态代码块
    static {
        System.out.println("DD 的静态代码 1 被执行...");//
    }
    //普通代码块
    {
        System.out.println("DD 的普通代码 1 被执行...");//
    }
}

如果只是使用类的静态成员时，普通代码块并不会执行（普通代码块是构造器的补充，如果构造器被调用才会导致普通代码块被调用）

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
      
        // 如果只是使用类的静态成员时,普通代码块并不会执行
        System.out.println(DD.n1);
    }
}

class DD {
    public static int n1 = 888;//静态属性

    //静态代码块
    static {
        System.out.println("DD 的静态代码 1 被执行...");//
    }
    //普通代码块
    {
        System.out.println("DD 的普通代码 1 被执行...");//
    }
}

小结

1.static代码块是类加载时执行的，只会执行一次

2.普通代码块是在创建对象时调用的，创建一次，调用一次

3.类加载的3种情况，需要记住

第四点

创建一个对象时，在一个类 调用顺序是:(重点，难点)

1.调用静态代码块和静态属性初始化(注意: 静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)
2.调用普通代码块和普通属性的初始化(注意: 普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)

3.调用构造方法

package com.hspedu.codeblock_;

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        //创建对象实例时，会优先调用静态代码块和静态属性初始化
        //谁写在前面就先执行谁
        A a = new A();//输出：1)A 的静态代码块01 2) getN1被调用...3)getN2被调用...
                    // 4)A 的普通代码块01 //5)A构造器被调用...
    }
}
class A {

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


    //静态属性初始化
    private static int n1 = getN1();
    private int n2 = getN2();


    public static int getN1(){
        System.out.println("getN1被调用...");
        return 100;
    }

    public  int getN2(){
        System.out.println("getN2被调用...");
        return 200;
    }

    {//普通代码块
        System.out.println("A 的普通代码块01");
    }
    //无参构造器
    public A() {
        System.out.println("A构造器被调用...");
    }
}

第五点

1.构造器 的最前面其实隐含了 super()和 调用普通代码块和普通属性

2.静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于普通代码块和构造器执行的 

package com.hspedu.codeblock_;

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        //创建新的子类对象实例后，按照上述规则会依次输出以下四句
        //1)A01 的普通代码块1被调用
        //2)父类A01 构造器被调用
        //3)B01 的普通代码块1被调用
        //4)子类B01 构造器被调用
        B01 b01 = new B01();

    }

}
class A01{

    {
        System.out.println("父类A01 的普通代码块1被调用");
    }

    public A01(){
        //隐藏了super()和普通代码块
        super();//父类：Object类
        //普通代码块和普通属性
        System.out.println("父类A01 构造器被调用");
    }
}

class B01 extends A01{

    {
        System.out.println("子类B01 的普通代码块1被调用");
    }

    public B01() {
        //隐藏了super()和普通代码块
        super();
        //普通代码块和普通属性
        System.out.println("子类B01 构造器被调用");
    }
}

第六点

我们看一下创建一个子类对象时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下

1.父类的静态代码块和静态属性(优先级一样，按定义顺序执行)

2.子类的静态代码块和静态属性(优先级一样，按定义顺序执行)

3.父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

4.父类的构造方法

5.子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

6.子类的构造方法

总结：

1.在类加载的时候，会调用类中的静态成员，存在继承关系的时候，先加载父类再加载子类，所以是父类静态------>子类静态

2.创建对象实例的时候，会调用构造器，按照继承关系（细节五）

package com.hspedu.codeblock_;

public class CodeBlockDetail05 {
    public static void main(String[] args) {
        //1.类的加载
        //1.1 先加载父类A02; 1.2 加载子类 B02, 先执行静态相关的部分
        // 2.创建对象，执行构造器（构造器中隐藏super()和普通代码块和普通属性）

        //new C03();
        new B03();
    }
}

class A03 { //父类
    private static int n1 = getVal01();

    static {
        System.out.println("A03 的一个静态代码块..");//第二个输出
    }

    {
        System.out.println("A03 的第一个普通代码块..");//第五个输出
    }

    public int n3 = getVal02();//普通属性的初始化

    public static int getVal01() {
        System.out.println("getVal01");////第一个输出
        return 10;
    }

    public int getVal02() {
        System.out.println("getVal02");//第六个输出
        return 10;
    }

    public A03() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化......
        System.out.println("A03 的构造器");//第七个输出
    }
}


class B03 extends A03 { //子类，继承了父类A03
    private static int n3 = getVal03();//第三个输出

    static {
        System.out.println("B03 的一个静态代码块..");//第四个输出
    }

    public int n5 = getVal04();

    {
        System.out.println("B03 的第一个普通代码块..");//第九个输出
    }

    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }

    public int getVal04() {
        System.out.println("getVal04");//第八个输出
        return 10;
    }

    //一定要慢慢的去品..
    public B03() {//构造器
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化
        System.out.println("B03 的构造器");//第十个输出
        // TODO Auto-generated constructor stub
    }
}

第七点

静态代码块只能调用静态成员，普通代码块可以调用任意成员

package com.hspedu.codeblock_;

public class CodeBlockDetail06 {
    public static void main(String[] args) {
        new A04();
    }
}
class A04 {
    private static int n1 = 10;
    private int n2 = 20;

    private static void m1(){
        System.out.println("静态方法m1()被调用");
    }

    private void m2(){
        System.out.println("普通方法m2()被调用");
    }

    //静态代码块只能调用静态成员
    static {
        System.out.println(n1);
        m1();
        //System.out.println(n2);错误，静态只能调用静态
        //m2();错误，理由同上

    }

    //普通代码块可以调用任意成员
    {
        System.out.println(n1);
        m1();
        System.out.println(n2);
        m2();
    }
}

五、练习题

第一题

package com.hspedu.codeblock_;

public class CodeBlockExercise01 {
    public static void main(String[] args) {
        //调用静态属性，首先进行类加载，类加载的时候会执行静态属性初始化和静态代码块
        //静态属性初始化 :total = 0，
        //静态代码块: total = 100; 输出"in static block";
        //再次调用total，但是static代码块只能执行一次，所以只会输出100
        System.out.println("total = " + Person.total);
        System.out.println("total = " + Person.total);

    }
}
class Person {
    public static int total;
    static {
        total = 100;
        System.out.println("in static block");
    }
}

第二题

考察知识点

类的属性可以是基本数据类型，也可以是医用数据类型（对象、数组） 

创建对象时首先会进行类的加载，所以会首先执行静态代码块、完成静态属性初始化（按照位置）

然后执行普通代码块和普通属性（按照位置），最后调用构造器

结论

1）完成静态属性初始化，即：

static Sample sam = new Sample("静态成员sam初始化");

2）调用

Sample(String s) {//有参构造器
    System.out.println(s);
}

3）输出：静态成员sam初始化

4)执行静态代码块

static {//静态代码块
    System.out.println("static块执行");//
    if(sam == null)
        System.out.println("sam is null");
}

  输出：static块执行

5) 完成普通属性初始化

Sample sam1 = new Sample("sam1成员初始化");//

输出：sam1成员初始化

6)执行构造器

Test(){//构造器
    System.out.println("Test默认构造函数被调用");//
}

输出：Test默认构造函数被调用

package com.hspedu.codeblock_;

public class CodeBlockExercise02 {
    public static void main(String[] args) {
        Test a = new Test();//无参构造器
    }
}
class Sample{
    Sample(String s) {//有参构造器
        System.out.println(s);
    }
    Sample() {//无参构造器
        System.out.println("Sample默认构造函数被调用");
    }
}

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默认构造函数被调用");//
    }
}

结果