在Java編程中，創(chuàng)建型模式是一種重要的設(shè)計模式，它關(guān)注對象的創(chuàng)建過程，通過抽象化和解耦對象的實例化過程，使得系統(tǒng)更加靈活、可擴展和易于維護。本文將詳細介紹Java中的創(chuàng)建型模式及其具體實現(xiàn)方式。
一、什么是創(chuàng)建型模式?
創(chuàng)建型模式是設(shè)計模式三大分類之一，主要解決對象創(chuàng)建的復(fù)雜性問題。它通過將對象的創(chuàng)建邏輯封裝在特定的類或方法中，避免直接使用new關(guān)鍵字來創(chuàng)建對象，從而實現(xiàn)代碼的解耦和靈活性。這種模式特別適用于以下場景：
系統(tǒng)需要控制對象的創(chuàng)建過程：例如，確保一個類只有一個實例，或者需要動態(tài)決定對象的類型。
對象的創(chuàng)建邏輯復(fù)雜：例如，需要通過多個步驟逐步構(gòu)建對象。
需要隱藏對象的創(chuàng)建細節(jié)：例如，封裝工廠類或抽象工廠類來管理對象的生成。
二、Java中的創(chuàng)建型模式有哪些?
根據(jù)不同的需求和使用場景，Java中的創(chuàng)建型模式可以分為以下五種：
1. 單例模式(Singleton Pattern)
單例模式確保一個類只有一個實例，并提供一個全局訪問點。這種模式適用于需要頻繁訪問且資源消耗較大的對象，如線程池、配置管理器等。
特點：
線程安全：通過雙重檢查鎖定(Double-Checked Locking)實現(xiàn)線程安全。
隱藏構(gòu)造函數(shù)：不允許外部直接實例化。
提高效率：避免重復(fù)創(chuàng)建對象。
實現(xiàn)方式：
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
運行
優(yōu)點：
確保全局唯一性。
提高性能。
缺點：
單例對象無法被垃圾回收。
不適合多線程環(huán)境下的動態(tài)創(chuàng)建。
2. 工廠方法模式(Factory Method Pattern)
工廠方法模式定義一個用于創(chuàng)建對象的接口，但由子類決定實例化哪一個類。這種模式將對象的實例化延遲到子類中完成。
特點：
接口統(tǒng)一：定義一個公共接口，由子類實現(xiàn)具體的創(chuàng)建邏輯。
擴展性強：可以通過擴展子類輕松添加新的產(chǎn)品類型。
實現(xiàn)方式：
// 抽象工廠類
public abstract class AbstractFactory {
public abstract Product createProduct();
}
// 具體工廠類
public class ConcreteFactory1 extends AbstractFactory {
@Override
public Product createProduct() {
return new ProductA();
}
}
// 產(chǎn)品接口
public interface Product {
void use();
}
// 具體產(chǎn)品類
public class ProductA implements Product {
@Override
public void use() {
System.out.println("Using Product A");
}
}
// 客戶端代碼
public class Client {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory1();
Product product = factory.createProduct();
product.use();
}
}
運行
優(yōu)點：
解耦：客戶端無需關(guān)心具體產(chǎn)品的創(chuàng)建邏輯。
擴展性好。
缺點：
創(chuàng)建多個相關(guān)產(chǎn)品時，工廠類數(shù)量較多。
[[Java工廠方法模式示意圖]]
3. 抽象工廠模式(Abstract Factory Pattern)
抽象工廠模式提供一個接口，用于創(chuàng)建一系列相關(guān)或相互依賴的對象，而無需指定它們具體的類。
特點：
提供統(tǒng)一的接口：定義一組工廠方法，用于創(chuàng)建一系列相關(guān)產(chǎn)品。
解耦：客戶端無需了解具體產(chǎn)品的實現(xiàn)細節(jié)。
實現(xiàn)方式：
// 抽象工廠接口
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具體工廠類
public class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ProductA1();
}
@Override
public ProductB createProductB() {
return new ProductB1();
}
}
// 產(chǎn)品接口
public interface ProductA {
void use();
}
// 具體產(chǎn)品類
public class ProductA1 implements ProductA {
@Override
public void use() {
System.out.println("Using Product A1");
}
}
// 客戶端代碼
public class Client {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory1();
ProductA productA = factory.createProductA();
productA.use();
}
}
運行
優(yōu)點：
提供統(tǒng)一的接口，方便擴展。
解耦性強。
缺點：
如果產(chǎn)品種類過多，抽象工廠類會變得復(fù)雜。
[[Java抽象工廠模式示意圖]]
4. 建造者模式(Builder Pattern)
建造者模式將一個復(fù)雜對象的構(gòu)建與它的表示分離，使得同樣的構(gòu)建過程可以創(chuàng)建不同的表示。
特點：
分離構(gòu)建和表示：允許逐步構(gòu)建復(fù)雜對象。
提高可讀性和可維護性。
實現(xiàn)方式：
public class Builder {
private String part1;
private String part2;
public Builder() {}
public Builder setPart1(String part1) {
this.part1 = part1;
return this;
}
public Builder setPart2(String part2) {
this.part2 = part2;
return this;
}
public Product build() {
return new Product(part1, part2);
}
}
public class Product {
private String part1;
private String part2;
public Product(String part1, String part2) {
this.part1 = part1;
this.part2 = part2;
}
@Override
public String toString() {
return "Product{" +
"part1='" + part1 + '\'' +
", part2='" + part2 + '\'' +
'}';
}
}
public class Client {
public static void main(String[] args) {
Builder builder = new Builder();
Product product = builder.setPart1("Part1")
.setPart2("Part2")
.build();
System.out.println(product);
}
}
運行
優(yōu)點：
提高代碼可讀性。
靈活性強。
缺點：
實現(xiàn)較為復(fù)雜。
[[Java建造者模式示意圖]]
5. 原型模式(Prototype Pattern)
原型模式通過復(fù)制現(xiàn)有的對象來創(chuàng)建新的對象，而不是重新實例化。
特點：
復(fù)用現(xiàn)有對象：避免重復(fù)創(chuàng)建相同類型的對象。
提高性能。
實現(xiàn)方式：
public class Prototype implements Cloneable {
private String state;
public Prototype(String state) {
this.state = state;
}
public Prototype clone() throws CloneNotSupportedException {
return (Prototype) super.clone();
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Prototype prototype = new Prototype("Initial State");
Prototype copyPrototype = (Prototype) prototype.clone();
System.out.println("Original: " + prototype.getState());
System.out.println("Copy: " + copyPrototype.getState());
}
}
運行
優(yōu)點：
性能高。
簡單易用。
缺點：
不適用于復(fù)雜對象的復(fù)制。
[[Java原型模式示意圖]]
Java中的創(chuàng)建型模式主要包括單例模式、工廠方法模式、抽象工廠模式、建造者模式和原型模式。這些模式通過不同的方式解決了對象創(chuàng)建過程中的問題，提高了代碼的靈活性和可維護性。開發(fā)者可以根據(jù)具體需求選擇合適的模式來優(yōu)化系統(tǒng)設(shè)計。
