初始化对象

初始化对象#

初始化及类的加载#

每个类的编译代码都存在于它自己的独立的 .class 文件中，该文件只有在需要使用程序代码时才会被加载。

一般来说，”类的代码在初次使用时才加载”。这通常发生于创建类的第一个对象时，但是当访问 static 域或 static 方法时，也会发生加载。

先阅读一下代码，有一个直观的感受：

//: reusing/Beetle.java
// The full process of initialization.
import static net.mindview.util.Print.*;

class Insect {
    private int i = 9;
    protected int j;
    Insect() {
        print("i = " + i + ", j = " + j);                                   // 4
        j = 39;
    }
    private static int x1 = printInit("static Insect.x1 initialized");      // 1
    static int printInit(String s) {
        print(s);                                                           // 1, 2, 5
        return 47;
    }
}

public class Beetle extends Insect {
    private int k = printInit("Beetle.k initialized");                      // 5
    public Beetle() {
        print("k = " + k);                                                  // 6
        print("j = " + j);                                                  // 7
    }
    private static int x2 = printInit("static Beetle.x2 initialized");      // 2
    public static void main(String[] args) {
        print("Beetle constructor");                                        // 3
        Beetle b = new Beetle();
    }
} /* Output:
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 47
j = 39
*///:~

下面介绍一下一般的类的实例化流程：

基类构造总是先于导出类。按照继承关系，首先对基类进行加载，向上回溯，直到触及 Object。
按照从基类到导出类的顺序，对所有的 static 属性赋予人为设定的值（初始化顺序很重要，因为导出类 static 可能依赖于基类的 static，注意，main 方法也是 static 的，因此 main 也会在这一步执行）。
通过将内存设为二进制 0，一举完成对代码中出现的所有非 static 数据设置默认值。
按照从基类到导出类的顺序，首先对所有的非 static 属性赋予人为设定的值，然后执行构造器函数。
执行完构造器，对象的初始化就算完成了。

Note

注意，不管是 static 函数还是普通函数，都不会包含在实例化过程中，只有调用的时候才会执行。

this 关键字#

this 关键字指代当前对象的引用，因此，我们经常使用 this 关键字传递自身引用。使用 this 调用方法，表示调用当前对象的方法或属性（因为可能类的属性和方法内部的属性可能同名，这时候可以用 this 关键字来区分）。return this 表示返回当前对象的引用。

//: initialization/PassingThis.java

class Person {
    public void eat(Apple apple) {
        Apple peeled = apple.getPeeled(); // 给苹果削皮
        System.out.println("Yummy");
    }
}

class Peeler {  // 削皮刀
    static Apple peel(Apple apple) {
        // ... remove peel
        return apple; // Peeled
    }
}

class Apple {   // 苹果
    Apple getPeeled() { return Peeler.peel(this); }
}

public class PassingThis {
    public static void main(String[] args) {
        new Person().eat(new Apple());
    }
} /* Output:
Yummy
*///:~

上面代码高亮处表示 Apple 类用于生成剥皮后的苹果。

使用 this 关键字，可以在构造器中调用构造器，因为生命周期，不能在非构造器函数中调用构造器。

//: initialization/Flower.java
// Calling constructors with "this"
import static net.mindview.util.Print.*;

public class Flower {
    int petalCount = 0;
    String s = "initial value";
    Flower(int petals) {
        petalCount = petals;
        print("Constructor w/ int arg only, petalCount= " + petalCount);
    }
    Flower(String ss) {
        print("Constructor w/ String arg only, s = " + ss);
        s = ss;
    }
    Flower(String s, int petals) {
        this(petals);
//!     this(s); // Can't call two!
        this.s = s; // Another use of "this"
        print("String & int args");
    }
    Flower() {
        this("hi", 47);
        print("default constructor (no args)");
    }
    void printPetalCount() {
//!     this(11); // Not inside non-constructor!
        print("petalCount = " + petalCount + " s = "+ s);
    }
    public static void main(String[] args) {
        Flower x = new Flower();
        x.printPetalCount();
    }
} /* Output:
Constructor w/ int arg only, petalCount= 47
String & int args
default constructor (no args)
petalCount = 47 s = hi
*///:~

Note

使用 this(String[] args) 调用构造器时，只能调用一个。
构造器调用必须位于方法的最开始。

与 this(String[] args) 类似，使用 super(String[] args) 调用父类对象的某个构造器。

static 关键字#

static 关键字的适用场景：

想为某特定域只分配一份存储空间，而不去考虑究竟要创建多少对象，甚至根本就不创建对象。
希望某个方法不与包含它的类的任何对象关联在一起，即通过类名调用方法。

Note

static 方法内部不能调用非静态方法，是因为生命周期。
static 方法没有 this 方法，也是因为生命周期，static 方法先于对象创建。
static 方法其实是 Java 中的全局方法。

final 关键字#

final 可以用于修饰属性、方法和类，发生的效果是一致的，表示 “这是无法改变的”，细微之处略有差别。

被 final 声明的属性无法被修改。因此常用 final 用来修饰编译时常量。编译时常量可以在编译期直接带入计算式参与计算，减轻了运行时的负担。对于基本数据类型，final 使数值恒定不变。对于引用类型，final 使引用恒定不变，即一旦引用被初始化，无法再指向其他对象。参数列表中使用 final 时，表示无法更改参数引用的指向。按照惯例，既是 static 又是 final 的域（即编译器常量）用 大写字母 表示，使用下划线分隔各个单词。

Note

一个既是 static 又是 final 的域只占据一段不能改变的存储空间。
定义为 public 强调可以用于包之外。
定义为 static 强调只有一份。
定义为 final 强调是一个常量。

被 final 声明的方法无法重写。所有的 private 方法都 隐式地 指定为 final，因为无法改变。一个方法一旦被 final 声明，将不会发生动态绑定行为。

被 final 声明的类无法被继承。

finalize() 方法#

不是 new 出来的对象，会获得一块特殊的内存，垃圾回收器不会回收，需要使用 finalize() 方法来释放。

当某个对象处于某种状态时（例如文件处于打开状态），如果直接使用 finalize() 清理该对象占用的内存空间，可能会发生异常。因此 finalize() 可以用来发现异常。如下代码所示：

//: initialization/TerminationCondition.java
// Using finalize() to detect an object that
// hasn't been properly cleaned up.

class Book {
    boolean checkedOut = false;
    Book(boolean checkOut) {            // 设置 "图书已出库" 标志位
        checkedOut = checkOut;
    }
    void checkIn() {                    // 将 "图书入库"
        checkedOut = false;
    }
    protected void finalize() {
        if(checkedOut)                  // 检查 "图书是否已出库"
            System.out.println("Error: checked out");
        // 正常情况下，清理完导出类后，也应该对基类进行清理：
        // super.finalize(); // Call the base-class version
    }
}

public class TerminationCondition {
    public static void main(String[] args) {
        Book novel = new Book(true);    // 设置 "图书已出库"，清理库存
        // Proper cleanup:
        novel.checkIn();                // 设置 "图书入库"
        // Drop the reference, forget to clean up:
        new Book(true);                 // 设置 "图书出库"
        // Force garbage collection & finalization:
        System.gc();                    // 调用 finalize() 后发现没有库存，报错
    }
} /* Output:
Error: checked out
*///:~

那么如何保证 finalize() 代码一定会被执行呢？Java 中没有 C++ 中析构函数的概念。如果你想清理某些东西，需要显式地编写 finally 子句，将清理动作放在 finally 子句中，以防止异常的出现。

try {
    // 保护区代码
} finally {
    // 不管保护区发生什么，这段代码一定会执行
}

初始化对象

Contents

初始化对象#

初始化及类的加载#

this 关键字#

static 关键字#

final 关键字#

finalize() 方法#