java代码块

代码块

基本介绍：

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

基本语法

[修饰符]{

​ 代码

}

注意：

1. 修饰符可选，要写的化，只能写static
2. 嗲马快必须分为两类，使用static修饰的叫静态代码块，没有static修饰的叫普通代码块
3. 逻辑语句可以为任何逻辑局（输入，输出，方法调用，循环，判断）
4. ；可以写上，也可以省略

好处

1. 相当于另外一种形式的构造器（对构造器的补充机制），可以作初始化的操作
2. 如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

使用注意事项和细节讨论

1. static代码块也叫静态代码块，作用就是堆类进行初始化，而且它随着类的加载而执行，并且只执行一次。普通代码块，每创建一个对象，就执行一次

2. 类什么时候被加载

   • 创建对象实例时
   • 创建子类对象实例，父类也会被加载，父类的要优先于子类
   • 使用类的静态成员（静态方法，静态属性）时

3. 普通的代码块，在创建对象实例时，会被饮食的调用。被创建一次就会调用一次，如果知识使用类的静态成员时，普通代码块并不会执行

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

   • 调用静态代码块和静态属性初始化（注意：静态代码块个静态初始化调用的优先级一样，如果有多个静态代码块和多个静态代码初始化，则按他们定义顺序调用）
   • 调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用
   • 调用构造方法

5. 构造器的最前面其实隐含了super（）和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的

6. 我么看一下创建一个子类时（继承关系），他们的静态代码块，静态属性初始化，普通属性初始化，构造方法的调用顺序如下：

   • 父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
   • 子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
   • 父类的普通代码块和普通属性（优先级一样，按定义顺序执行）
   • 父类的构造方法
   • 子类的普通代码块和普通属性（优先级一样，按定义顺序执行）
   • 子类的构造方法

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

8. package com.shedu.static_.codeblock;
   
   public class CodeBlockDetails {
       public static void main(String[] args) {
           CC cc = new CC(1);
       }
   }
   class AA{
       public static int a = a();
       public int aa = aa();
       static {
           System.out.println("AA（）的静态代码块");
       }
       {
           System.out.println("AA的普代");
       }
   
       public static int a(){
           System.out.println("AA的静态方法");
           return AA.a;
       }
       public int aa(){
           System.out.println("AA的普通方法");
           return this.aa;
       }
   
       public AA(int a) {
           System.out.println("AA构造器");
       }
   }
   class BB extends AA{
       public static int b = b();
       public int bb = bb();
       static {
           System.out.println("bb（）的静态代码块");
       }
       {
           System.out.println("bb的普代");
       }
       public int bb(){
           System.out.println("bb的普通方法");
           return this.bb;
       }
       public static int b(){
           System.out.println("BB的静态方法");
           return BB.b;
       }
   
       public BB(int a) {
           super(a);
           System.out.println("bb构造器");
       }
   }
   class CC extends  BB{
       public static int c = c();
       public int cc = cc();
       static {
           System.out.println("cc（）的静态代码块");
       }
       {
           System.out.println("cc的普代");
       }
       public int cc(){
           System.out.println("cc的普通方法");
           return this.cc;
       }
       public static int c(){
           System.out.println("CC的静态方法");
           return CC.c;
       }
   
       public CC(int a) {
           super(a);
           System.out.println("cc构造器");
       }
   }
   
   /*输出结果：AA的静态方法
   AA（）的静态代码块
   BB的静态方法
   bb（）的静态代码块
   CC的静态方法
   cc（）的静态代码块
   AA的普通方法
   AA的普代
   AA构造器
   bb的普通方法
   bb的普代
   bb构造器
   cc的普通方法
   cc的普代
   cc构造器
   */