如何正確的創建和銷燬 Java 對象

一、介紹

Java 由 Sun Microsystems 發明並在 1995 年發佈，是世界上使用最廣泛的編程語言之一。Java 是一個通用編程語言。由於它擁有功能強大的庫、運行時、簡單的語法、平臺無關（Write Once, Run Anywhere - WORA）以及令人敬畏的社區從而吸引了很多的開發者。

本系列文章我們我們將會覆蓋一些高級的 Java 概念，我們假設你對 Java 語言已經有一些基礎知識。本系列文章並不是一個完整的參考，而是一個將您的 Java 技能提升到下一個級別的詳細指南。

本系列文章中將會看到一些代碼片段，在這些代碼片段裏面將會使用 java 7 的語法以及 java 8 的語法。

二、實例構造（Instance Construction）

Java 是面向對象的編程語言，所以新實例（objects）的創建可能是它最重要的概念之一。在新的類實例中構造器（Constructors）扮演了非常核心的角色，Java 對於構造器（Constructors）的定義提供了很多方案。

2.1 隱式（implicitly）構造器

Java 允許定義無任何構造器的類，但是這並不意味着此類沒有構造器。比如說，讓我們看一下下面這個類。

package com.javacodegeeks.advanced.construction;
public class NoConstructor {
}

此類沒有構造器，但是 Java 編譯器會隱式地（implicitly）生成一個構造器並且在使用 new 關鍵字創建新的類實例時會被調用。

final NoConstructor noConstructorInstance = new NoConstructor();

2.2 無參構造器（Constructors without Arguments）

無參構造器是顯式執行 Java 編譯器工作的最簡單的方法。

package com.javacodegeeks.advanced.construction;
public class NoArgConstructor {
    public NoArgConstructor() {
        // Constructor body here
    }
}

在使用 new 關鍵字創建此類的新實例時會此構造器將會被調用。

final NoArgConstructor noArgConstructor = new NoArgConstructor();

2.3 有參構造器（Constructors with Arguments）

有參構造器是參數化創建類實例的一個非常有意思和有用的方法。下面這個類定義了一個具有兩個參數的構造器。

package com.javacodegeeks.advanced.construction;
public class ConstructorWithArguments {
    public ConstructorWithArguments(final String arg1,final String arg2) {
        // Constructor body here
    }
}

在這種情況下，當使用 new 關鍵字創建類實例時，兩個構造參數都必須提供。

final ConstructorWithArguments constructorWithArguments = new ConstructorWithArguments( "arg1", "arg2" );

非常有意思的是，使用 this 關鍵字，構造器之間可以相互調用。這種連接構造函數的方式在作爲減少代碼重複方面是一個非常好的實踐，並且從跟本上說這樣做可以讓一個類只有一個初始化入口點。接上例，我們添加一個只有一個參數的構造器。

public ConstructorWithArguments(final String arg1) {
this(arg1, null);
}

2.4 初始化塊（Initialization Blocks）

Java 也提供了另外一種使用初始化塊的方式實現初始化邏輯。這個特性很少使用但是非常有必要了解一下它的存在。

package com.javacodegeeks.advanced.construction;
    public class InitializationBlock {
    {
        // initialization code here
    }
}

在某些情況下，初始化塊可以彌補匿名無參構造器的缺陷。有一些特殊的類可能會有很多個初始化塊並且他們會依次按照他們在代碼中定義的順序被調用，比如：

package com.javacodegeeks.advanced.construction;
public class InitializationBlocks {
    {
        // initialization code here
    } {
        // initialization code here
    }
}

初始化塊並不是替代構造器並且他們可以獨立於構造器而存在。但是需要提及的最重要的一點就是初始化塊會在任何構造器被調用之前被執行。

package com.javacodegeeks.advanced.construction;
public class InitializationBlockAndConstructor {
    {
        // initialization code here
    }
    public InitializationBlockAndConstructor() {
    }
}

2.5 構造保障（Construction guarantee）

Java 提供了一些開發者所依賴的初始化保障，未初始化的實例和類參數會自動初始化爲它們的默認值。

讓我們使用下面的例子來確認一下這些默認值。（搜索公衆號 Java 知音，回覆 “2021”，送你一份 Java 面試題寶典）

package com.javacodegeeks.advanced.construction;
public class InitializationWithDefaults {
    private boolean booleanMember;
    private byte byteMember;
    private short shortMember;
    private int intMember;
    private long longMember;
    private char charMember;
    private float floatMember;
    private double doubleMember;
    private Object referenceMember;

    public InitializationWithDefaults() {
        System.out.println( "booleanMember = " + booleanMember );
        System.out.println( "byteMember = " + byteMember );
        System.out.println( "shortMember = " + shortMember );
        System.out.println( "intMember = " + intMember );
        System.out.println( "longMember = " + longMember );
        System.out.println( "charMember = " +
        Character.codePointAt( new char[] { charMember }, 0 ) );
        System.out.println( "floatMember = " + floatMember );
        System.out.println( "doubleMember = " + doubleMember );
        System.out.println( "referenceMember = " + referenceMember );
    }
}

一旦使用 new 關鍵字實例化：

inal InitializationWithDefaults initializationWithDefaults = new InitializationWithDefaults();

將會在控制檯輸出如下結果：

booleanMember = false
byteMember = 0
shortMember = 0
intMember = 0
longMember = 0
charMember = 0
floatMember = 0.0
doubleMember = 0.0
referenceMember = null

2.6 可見性（Visibility）

構造器受 Java 可見性規則約束並且可以擁有訪問控制修飾符來決定是否其他類可以調用特定的構造函數。

2.7 垃圾回收（Garbage collection）

Java（特別是 JVM）使用自動垃圾回收機制。簡而言之，當新對象被創建，JVM 就會自動爲這些新創建的對象分配內存。於是，當這些對象沒有任何引用的時候，他們就會被銷燬並且他們所佔用的內存就會被回收。

Java 垃圾回收是分代的，基於這種假設（分代假設）大多數的對象在很年輕的時候就已經不可達（在他們被創建之後的很短的時間內就沒有任何引用並且被安全銷燬）。大多數開發者曾經相信在 Java 中創建對象是很慢的並且應該儘可能地避免新對象的實例化。

實際上，這並不成立：在 Java 中創建對象的開銷非常的小並且很快。雖然如此，但是沒有必要創建生命週期比較長的對象，因爲創建過多的長壽命對象最終可能會填滿老年代空間從而引發 stop-the-world 的垃圾回收，這樣的話開銷就會比較大。

2.8 終結器（Finalizers）

到目前爲止，我們已經談到了構造函數和對象初始化，但實際上並沒有提到任何關於對象銷燬的內容。這是因爲 Java 使用垃圾收集器去管理對象的生命週期，並且垃圾收集器的責任就是去銷燬無用對象並回收這些對象佔用的內存。

然而，在 Java 中有一個被稱爲終結器（Finalizers）的特殊特性，它有點類似於析構函數，但是在執行資源清理時它所解決的是不同的意圖。終結器（Finalizers）是被考慮用來解決一些危險的特徵（比如會導致無數的副作用和性能問題的問題）。

一般來說，他們是沒有必要的，應該避免（除了非常罕見的情況下，主要是有關本地對象）。Java 7 語言引入了一種名爲 try-with-resources 的更好的替代方法和 AutoCloseable 接口，它允許像如下的方式這樣乾淨的寫代碼：

try ( final InputStream in = Files.newInputStream( path ) ) {
    // code here
}

3、靜態初始化（Static initialization）

到目前爲止，，我們已經談到了構造函數和對象初始化。但是 Java 也支持類級別的初始化構造，我們稱之爲靜態初始化（Static initialization）。

靜態初始化（Static initialization）有點類似於初始化塊，除了需要添加 static 關鍵字之外。注意靜態初始化在每次類加載的時候它只執行一次。比如：

package com.javacodegeeks.advanced.construction;
public class StaticInitializationBlock {
    static {
        // static initialization code here
    }
}

和初始化塊類似，在類定義時你可以包含任意數量的初始化塊，它們會根據在類代碼中出現的順序依次執行，比如：

package com.javacodegeeks.advanced.construction;
public class StaticInitializationBlocks {
    static {
        // static initialization code here
    }
    static {
        // static initialization code here
    }
}

因爲靜態初始化（Static initialization）塊可以從多個並行線程中觸發（第一次類加載發生），Java 運行時保證在線程安全的前提下僅僅被執行一次。

4、構造模式（Construction Patterns）

過去這幾年很多易於理解和廣泛應用的構造模式在 Java 社區出現。我們將會介紹幾個比較常用的：單例模式（singleton）、幫助器（helpers）、工廠模式（factory）、依賴注入（dependency injection ）——大家熟知的控制反轉（inversion of control）。

4.1 單例模式（Singleton）

單例模式是軟件開發者社區中最老也是最具爭議性的模式之一。基本來說，它的主要思想就是確保在任何時候類僅僅只有一個實例被創建。思想就是如此簡單，然而單例模式引發了很多關於如何使之正確的討論，特別是線程安全的討論。下面是單例模式原生版本的例子：

package com.javacodegeeks.advanced.construction.patterns;
public class NaiveSingleton {
    private static NaiveSingleton instance;

    private NaiveSingleton() {
    }

    public static NaiveSingleton getInstance() {
        if( instance == null ) {
            instance = new NaiveSingleton();
        }
        return instance;
    }
}

這段代碼至少有一個問題就是如果多個線程同時調用，那麼此類就能夠創建多個實例。設計合適的單例模式的方法之一是使用類的 static final 屬性。

final property of the class.
package com.javacodegeeks.advanced.construction.patterns;
public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {
    }

    public static EagerSingleton getInstance() {
        return instance;
    }
}

如果你不想浪費資源並且希望在單例對象真正需要的時候才被延遲創建的話，這就要求顯示同步了（explicit synchronization），這就有可能導致多線程環境中的併發性降低（關於併發的詳細內容我們將會在後續的文章中討論）。

package com.javacodegeeks.advanced.construction.patterns;
public class LazySingleton {
private static LazySingleton instance;
    private LazySingleton() {
    }

    public static synchronized LazySingleton getInstance() {
        if( instance == null ) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

如今，在大多數的案例中單例模式並不被考慮作爲一個很好的選擇，主要是因爲單例模式將會導致代碼很難測試。依賴注入模式讓單例模式變得沒有必要。

4.2 Utility/Helper 類

utility 或者 helper 類是被許多開發者所使用的相當流行的一種模式。基本來說，它所代表的是無實例（ non-instantiable）類（構造器被定義成 private），僅僅可以選擇將方法定義成 final（後續會介紹如何定義類）或者 static。比如;

package com.javacodegeeks.advanced.construction.patterns;
public final class HelperClass {
    private HelperClass() {
    }

    public static void helperMethod1() {
        // Method body here
    }

    public static void helperMethod2() {
        // Method body here
    }
}

站在開發者的角度，helpers 類經常所扮演的是一個容器的角色，這個容器中放了很多在其他地方找不到但是其他類需要相互共享和使用的互相不相關的方法。這種設計決定了在很多情況下要避免使用：總能找到另一種重用所需功能的方式，保持代碼的簡潔和清晰。

4.3 工廠模式（Factory）

工廠模式被證明是軟件開發人員手中非常有用的技術。因此，Java 有幾種風格工廠模式，從工廠方法到抽象工廠。工廠模式最簡單的例子是返回特定類的新實例的靜態方法（工廠方法）。例如：

package com.javacodegeeks.advanced.construction.patterns;
public class Book {
    private Book( final String title) {
    }
    public static Book newBook( final String title ) {
        return new Book( title );
    }
}

有人可能會爭辯說，介紹 newBook 工廠方法並沒有什麼意義，但是使用這種模式通常會使代碼更具可讀性。工廠模式的另一個變化涉及接口或抽象類（抽象工廠）。例如，讓我們定義一個工廠接口：

public interface BookFactory {
    Book newBook();
}

依賴庫類型，完成幾種不同的實現：

public class Library implements BookFactory {
    @Override
    public Book newBook() {
        return new PaperBook();
    }
}

public class KindleLibrary implements BookFactory {
@Override
    public Book newBook() {
        return new KindleBook();
    }
}

現在，Book 的特定類被隱藏在 BookFactory 接口實現之後，BookFactory 仍然提供創建 book 的通用方式。

4.4 依賴注入（Dependency Injection）

依賴注入（一說控制反轉）被類設計者認爲是一個很好的做法：如果某些類的實例依賴其他類的實例，被依賴的實例應該通過構造（比如通過設置器——setters，或者策略——strategies 模式等）的思想提供給依賴的實例，而不是依賴的實例自行創建。看一下下面這種情況：

package com.javacodegeeks.advanced.construction.patterns;
import java.text.DateFormat;
import java.util.Date;
public class Dependant {
    private final DateFormat format = DateFormat.getDateInstance();

    public String format( final Date date ) {
        return format.format( date );
    }
}

類 Dependant 需要一個 DateFormat 的實例，並且它僅僅只是在構造時通過調用 DateFormat.getDateInstance() 創建。最好的設計方案應該是通過構造器參數的形式去完成相同的事情。

package com.javacodegeeks.advanced.construction.patterns;
import java.text.DateFormat;
import java.util.Date;
public class Dependant {
    private final DateFormat format;

    public Dependant( final DateFormat format ) {
        this.format = format;
    }


    public String format( final Date date ) {
        return format.format( date );
    }
}

按這種方案實現的話，類的所有依賴都是通過外部提供，這樣就很容易的修改 date format 和爲類寫測試用例。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/81wcw1YKf1EAuOkHmJvRAg