Java编程思想学习笔记——初始化与清理（二）

成员初始化

Java尽力保证：所有变量在使用前都能得到适当的初始化。

• 方法的局部变量：未初始化，编译错误。

void f(){
        int i;
//        System.out.println(i);//编译错误
    }

• 类的数据成员（字段）是基本类型：保证都会有一个初始值。

public class InitialValues {
    boolean bl;
    char c;
    byte bt;
    short s;
    int i;
    long l;
    float f;
    double d;
    InitialValues reference;
    void printValues(){
        System.out.printf(
                "\nboolean:"+bl
                +"\nchar:"+c
                +"\nbyte:"+bt
                +"\nshort:"+s
                +"\nint:"+i
                +"\nlong:"+l
                +"\nfloat:"+f
                +"\ndouble:"+d
                +"\nreference:"+reference
        );
    }

    public static void main(String[] args) {
        new InitialValues().printValues();
    }
}

结果输出：

boolean:false
char:
byte:0
int:0
long:0
float:0.0
double:0.0
reference:null

• 指定初始化

在定义类成员变量的地方为变量赋值

public class InitialValues {
    boolean bl=true;
    char c='a';
    byte bt=22;
    short s=0xff;
    int i=1202;
    long l=1;
    float f=3.14f;
    double d=3.14159;
}

同样的方式初始化非基本类型的对象

class Apple{}
public class InitialValues {
    Apple apple = new Apple();
}

调用方法来初始值

    int i1 = getIntValue();
    int i2 = getDoubleValue(2);

    private int getDoubleValue(int i) {
        return i*2;
    }

    private int getIntValue() {
        return 2;
    }

构造器初始化

无法阻止自动初始化的进行，它将在构造器被调用之前发生。

public class ConstructorInitial {
    int i ;
    ConstructorInitial(){
        System.out.println(i);
        i=1;
        System.out.println(i);
    }

    public static void main(String[] args) {
        new ConstructorInitial();
    }
}

结果：

0
1

初始化顺序
在类的内部，变量定义的先后顺序决定了初始化的顺序。

静态数据的初始化
无论创建多少个对象，静态数据都只占用一份存储区域。
静态初始化只有在必要的时候才会进行。
初始化顺序是：静态对象－－>非静态对象。

对象创建的过程
假设有个名为Dog的类：

1. 首次创建Dog对象（构造器可以看成静态方法）或首次访问Dog类的静态方法或静态域时，Java解释器必须查找类路径，以定位Dog.class文件。
2. 然后载入Dog.class（这将创建一个Class对象），有关静态初始化的所有动作都会执行。因此，静态初始化只有在Class对象首次加载的时候进行一次。
3. 当用new Dog()创建对象的时候，首先在堆上为Dog对象分配足够的存储空间。
4. 这块存储空间会被清零，这就自动地将Dog对象中的所有基本类型数据都设置成了默认值（数字为0，布尔型，字符型类似），而引用被设置为null。
5. 执行所有出现于字段定义处的初始化动作。
6. 执行构造器。

显示的静态初始化
Java允许将多个静态初始化动作组织成一个特殊的"静态块"

class Cup{
    Cup(int marker){
        System.out.println("Cup("+marker+")");
    }
    void f(int marker){
        System.out.println("f("+marker+")");
    }
}
class Cups{
    //静态成员变量
    static Cup cup1;
    static Cup cup2;
    //显式的静态初始化
    //静态块
    static {
        System.out.println("static initialization");
        cup1 = new Cup(1);
        cup2 = new Cup(2);
    }
    Cups(){
        System.out.println("Cups()");
    }
}
public class Initialization {
    public static void main(String[] args) {
        Cups.cup1.f(100);
        /**
         *static initialization
         Cup(1)
         Cup(2)
         f(100)
         */
    }
//    static Cups cups = new Cups();
    /**
     * static initialization
     Cup(1)
     Cup(2)
     Cups()
     */
}

非静态实例初始化
实例初始化：用于初始化每一个对象的非静态变量。

class Cup{
    Cup(int marker){
        System.out.println("Cup("+marker+")");
    }
    void f(int marker){
        System.out.println("f("+marker+")");
    }
}
class Cups{
    //静态成员变量
    static Cup cup1;
    static Cup cup2;
    Cup cup3,cup4;
    //显式的静态初始化
    //静态块
    static {
        System.out.println("static initialization");
        cup1 = new Cup(1);
        cup2 = new Cup(2);
    }
    //非静态实例初始化
    {
        System.out.println("non-static initialization");
        cup3 = new Cup(3);
        cup4 = new Cup(4);
    }
    Cups(){
        System.out.println("Cups()");
    }
}
public class Initialization {
    public static void main(String[] args) {
        new Cups();
        /**
         *static initialization
         Cup(1)
         Cup(2)
         non-static initialization
         Cup(3)
         Cup(4)
         Cups()
         */
    }
}

原文地址：http://www.cnblogs.com/JohnTsai/p/4590503.html