1. 对于局部变量的初始化,主要通过编译时错误来保证

void f()
  {
    int i;
    //i++;    //编译不能通过,因为i尚未初始化
  }

2. 对于类的 每一个 成员变量(即,字段), 在定义时可以不用初始化.

   如果没有初始化,则Java编译器会保证没有初始化的字段都有一个初始值.

   boolean -> false;char -> [],byte,short,int,long -> 0, float,double -> 0.0,对其他对象的引用 – > null

   参见p92.

   这种方式称为自动初始化,这个过程无法阻止.(p94)

   即使字段的定义遍布方法之间,它们仍然会在所有方法调用之前被初始化.

3. 在定义字段时,可以赋初始值(可以通过调用一个方法来赋初始值,p93).

4. 在初始化块中初始化

5. 在构造器中初始化字段.

6. 在静态初始化块中初始化静态变量(静态初始化块 只能初始化静态变量)

7. 静态字段的初始化

(1)静态字段没有被显示初始化,则根据上面2中的获得一个默认初始值

(2)静态初始化只在必要时进行.

(3)可以使用静态子句初始化,静态子句初始化也只在必要时才进行

(4)静态变量在类被加载的时候初始化一次,而且仅初始化一次

package test.mystatic;


class Bowl
{
  Bowl(int marker)
  {
    System.out.println("Bowl(" + marker +")");
  }
  
  void f1(int marker)
  {
    System.out.println("f1(" + marker + ")");
  }
}

class Table
{
  String ss;
  static
  {
    System.out.println("Table 中的显式静态初始化");
  }
  
  {
    System.out.println("Table 中的显示 非静态 初始化");
  }
  
  static Bowl bowl1 = new Bowl(1);
  
  Table()
  {
    System.out.println("Table()");
    bowl2.f1(1);
  }
  
  void f2(int marker)
  {
    System.out.println("f2(" + marker + ")");
  }
  
  static Bowl bowl2 = new Bowl(2);
}

class Cupboard
{
  static
  {
    System.out.println("Cupboard 中的显式静态初始化");
  }
  
  {
    System.out.println("Cupboard 中的显式 非静态 初始化");
  }
  
  Bowl bowl3 = new Bowl(3);
  static Bowl bowl4 = new Bowl(4);
  
  Cupboard()
  {
    System.out.println("Cupboard");
    bowl4.f1(2);
  }
  
  void f3(int marker)
  {
    System.out.println("f3(" + marker + ")");
  }
  
  static Bowl bowl5 = new Bowl(5);
}

public class TestStatic
{
  private static String strA = getStaticA();
  private static String strB = getStaticB();
  
  private static String  getStaticA()
  {
    System.err.println("现在初始化 Str A");
    return "Static A";
  }
  
  private static String  getStaticB()
  {
    System.err.println("现在初始化 Str B");
    return "Static B";
  }
  
  /**
   * main()方法实际上是静态方法,这里调用main导致静态字段strA和strB初始化
   * @param args
   */
  public static void main(String[] args)
  {
    /**
     * 这里main方法是静态方法,类加载时,就会初始化所有的static字段
     */
    System.out.println(strA);
    System.out.println("Create new Cupboard() in main");
    new Cupboard();
    System.out.println("Create new Cupboard() in main");
    new Cupboard();
    table.f2(1);
    cupboard.f3(1);
  }
  
  static Table table = new Table();
  static Cupboard cupboard = new Cupboard();
}
/**
 * 输出分析:
 *  现在初始化 Str A   //因为 调用main方法,初始化 静态变量strA
    现在初始化 Str B   //因为 调用main方法,初始化 静态变量strB
    Table 中的显式静态初始化  //静态初始化块 在 静态变量初始化之前调用
    Bowl(1)           //初始化 Table 中静态变量bowl1;
    Bowl(2)           //初始化 Table 中静态变量bowl2;
    Table 中的显示 非静态 初始化          //在构造函数调用之前掉用非 静态 初始化块
    Table()           //初始化Table
    f1(1)             //初始化Table 在构造函数中调用
    Cupboard 中的显式静态初始化 
    Bowl(4)           //初始化 Cupboard 中静态变量 bowl4
    Bowl(5)           //初始化 Cupboard 中静态变量 bowl5
    Cupboard 中的显式 非静态 初始化
    Bowl(3)           //调用 Cupboard 构造函数之前,初始化 非静态变量 bowl3
    Cupboard          //调用 Cupboard 构造函数
    f1(2)             //Cupboard 构造函数 中调用 bowl4.f1(2);
    Static A          //开始执行 main方法
    Create new Cupboard() in main  //继续执行那个main方法
    Cupboard 中的显式 非静态 初始化
    Bowl(3)           //main中 new 一个Cupboard,调用 Cupboard 构造函数之前,因为Cupboard的静态变量已经初始化过一次,这里只初始化了非静态变量
    Cupboard          //调用 Cupboard 构造函数
    f1(2)             //调用 Cupboard 构造函数 中的bowl4.f1(2);方法
    Create new Cupboard() in main
    Cupboard 中的显式 非静态 初始化
    Bowl(3)           //main中 再次 new 一个Cupboard,调用 Cupboard 构造函数之前,因为Cupboard的静态变量已经初始化过,这里只初始化了非静态变量
    Cupboard          //调用 Cupboard 构造函数
    f1(2)             //调用 Cupboard 构造函数 中的bowl4.f1(2);方法
    f2(1)             //table.f2(1);
    f3(1)             //cupboard.f3(1); 
 * 
 */

本文固定链接: https://www.jack-yin.com/coding/thinking-in-java/2389.html | 边城网事