【Java笔记】13 代码块

一、基本介绍

代码化块又称为初始化块，属于类中的成员，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但没有方法名，没有返回，没有参数，只有方法体，且不用通过对象或类显式调用，而是加载类时，创建对象时隐式调用。

二、基本语法

1.语法

[修饰符]{

  1. 代码

};

  1. 修饰符可选，但写的话只能写static
  2. 代码块分两类，使用static修饰的交静态代码块，没有static修饰的，叫普通代码块/非静态代码块。
  3. 逻辑语句可以为任何逻辑语句 输入、输出、方法调用、循环、判断等
  4. ;可以写，也可以省略

2.用处

如果多个构造器中都有重复的语句，可以抽取到初始化块中。

  1. public class CodeBlock01 {
  2.     public static void main(String[] args) {
  3.         Movie movie = new Movie("xxx电影");
  4.         System.out.println("-----------");
  5.         new Movie("电影",50,"xx");
  6.     }
  7. }
  9. class Movie{
  10.     private String name;
  11.     private double price;
  12.     private String director;
  14.     // 把三个构造器的相同语句放入一个代码块中
  15.     // 不管调用那个构造器，创建对象，都会先调用代码块的内容
  16.     // 代码块调用的顺序优先于构造器
  17.     {
  18.         System.out.println("屏幕打开..");
  19.         System.out.println("广告开始..");
  20.         System.out.println("电影开始..");
  21.     }
  22.     public Movie(String name){
  23.         System.out.println("Movie(String name)被调用");
  24.         this.name = name;
  25.     }
  27.     public Movie(String name,double price){
  28.         System.out.println("Movie(String name,double price)被调用");
  29.         this.name = name;
  30.         this.price = price;
  31.     }
  33.     public Movie(String name,double price,String director){
  34.         System.out.println("Movie(String name,double price,String director)被调用");
  35.         this.name = name;
  36.         this.price = price;
  37.         this.director = director;
  38.     }
  39. }

输出：

屏幕打开..
广告开始..
电影开始..
Movie(String name)被调用 屏幕打开..
广告开始..
电影开始..
Movie(String name,double price,String director)被调用

3.注意事项

  1. static代码块也叫静态代码块，对类进行初始化，随着类的加载而执行，并且只会执行一次
    普通代码块，每创建一个对象，就执行
  2. 类什么时候被加载
    （1）创建对象实例时（new）
    （2）创建子类对象实例，父类也会被加载
    （3）使用类的静态成员时（静态属性，静态方法）
    ```java public class CodeBlockDetail { public static void main(String[] args) {
    1. A a = new A();
    } }

class A { static { System.out.println(“A的静态代码被执行”); } }

  1. > A的静态代码被执行
  3. ```java
  4. public class CodeBlockDetail {
  5.     public static void main(String[] args) {
  6.         // 父类先被加载，子类后被加载
  7.         A a = new A();
  8.     }
  9. }
  11. class B{
  12.     static {
  13.         System.out.println("B的静态代码被执行");
  14.     }
  15. }
  17. class A extends B {
  18.     static {
  19.         System.out.println("A的静态代码被执行");
  20.     }
  21. }

B的静态代码被执行
A的静态代码被执行

  1. public class CodeBlockDetail01 {
  2.     public static void main(String[] args) {
  3.         System.out.println(Cat.n1);
  4.     }
  5. }
  7. class Animal{
  8.     static {
  9.         System.out.println("Animal的静态代码被执行");
  10.     }
  11. }
  12. class Cat extends Animal{
  13.     public static int n1 = 10;
  14.     static {
  15.         System.out.println("Cat的静态代码被执行");
  16.     }
  17. }

Animal的静态代码被执行
Cat的静态代码被执行
10

  1. 普通的代码块，在创建对象实例时，会被隐式的调用
    被创建一次，就会调用一次
    如果知识使用类的静态成员时，普通代码块并不会执行 
  1. public class CodeBlockDetail01 {
  2.     public static void main(String[] args) {
  3.         // static代码块，在类加载时，执行的，而且只会执行一次
  4.         // 普通的代码块，在创建对象实例时会被隐式调用
  5.         // 被创建一次，就会调用一次
  6.         D d = new D();
  7.         D d1 = new D();
  8.         // 如果只是使用类的静态成员时，普通代码块并不会执行
  9.         System.out.println(D.n);
  10.     }
  11. }
  13. class D{
  14.     public static int n = 10; // 静态属性
  15.     // 静态代码块
  16.     static {
  17.         System.out.println("D的静态代码被执行");
  18.     }
  19.     // 普通代码块，在new对象时被调用，每创建一个对象，就调用一次
  20.     {
  21.         System.out.println("D的普通代码块");
  22.     }
  23. }

D的静态代码被执行
D的普通代码块
D的普通代码块
10

  1. 创建一个对象时，在一个类调用顺序是：
    （1）调用静态代码块和静态属性初始化
    静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，按定义的顺序调用。
    （2）调用普通代码块和普通属性的初始化
    普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，按定义顺序调用
    （3）调用构造方法
    ```java public class CodeBlockDetail02 { public static void main(String[] args) {
    1. AA aa = new AA();
    } }

class AA{ // 普通代码块 { System.out.println(“AA的普通代码块”); } private int n2 = getN2(); // 普通属性的初始化 // 静态代码块 static { System.out.println(“AA的静态代码块”); }

  1. // 静态属性的初始化
  2. private static int n1 = getN1(); // 静态属性初始化
  3. public static int getN1(){
  4.     System.out.println("getN1被调用");
  5.     return 100;
  6. }
  7. public int getN2(){
  8.     System.out.println("getN2被调用");
  9.     return 200;
  10. }
  11. public AA(){
  12.     System.out.println("AA()构造器被调用");
  13. }

}

  1. > AA的静态代码块<br />getN1被调用<br />AA的普通代码块<br />getN2被调用<br />AA()构造器被调用
  3. 5.  构造器的最前面隐含了super()和调用普通代码块，静态相关的代码块，属性初始化在类加载时就执行完毕，因此优先于构造器和普通代码块执行 
  5. ```java
  6. public class CodeBlockDetail03 {
  7.     public static void main(String[] args) {
  8.         new BBB();
  9.     }
  10. }
  12. class AAA{
  13.     {
  14.         System.out.println("AAA的普通代码块");
  15.     }
  16.     public AAA(){
  17.         //1.super()
  18.         //2.调用本类的普通代码块
  19.         System.out.println("AAA()构造器被调用");
  20.     }
  21. }
  23. class BBB extends AAA{
  24.     {
  25.         System.out.println("BBB的普通代码块");
  26.     }
  27.     public BBB(){
  28.         //1.super()
  29.         //2.调用本类的普通代码块
  30.         System.out.println("BBB()构造器被调用");
  31.     }
  32. }

AAA的普通代码块
AAA()构造器被调用
BBB的普通代码块
BBB()构造器被调用

  1. 创建一个子类对象时，顺序：
    （1）父类的静态代码块和静态属性（优先级一样，按定义顺序）
    （2）子类的静态代码块和静态属性（优先级一样，按定义顺序）
    （3）父类的普通代码块和普通属性初始化（优先级一样，按定义顺序）
    （4）父类的构造方法
    （5）子类的普通代码块和普通属性初始化（优先级一样，按定义顺序）
    （6）子类的构造方法
  2. 静态代码块只能直接调用静态成员，普通代码块可以调用任意成员。