深入了解PatternJava

一、PatternJava的概述

PatternJava是一款開源的Java編程庫，它提供了眾多設計模式的實現，使得Java開發工程師可以更加簡單、高效地實現複雜的軟件系統。PatternJava包含23個設計模式，涵蓋了創建型模式、結構型模式和行為型模式。在開發過程中，開發人員可以根據實際情況選擇合適的設計模式，從而提高代碼的可讀性、可維護性和可擴展性。

下面是PatternJava的包的結構圖：

com.pattern
├── creational
│   ├── abstractfactory
│   ├── builder
│   ├── factorymethod
│   ├── prototype
│   └── singleton
├── structural
│   ├── adapter
│   ├── bridge
│   ├── composite
│   ├── decorator
│   ├── facade
│   ├── flyweight
│   └── proxy
└── behavioral
    ├── chain
    ├── command
    ├── interpreter
    ├── iterator
    ├── mediator
    ├── memento
    ├── observer
    ├── state
    ├── strategy
    ├── template
    ├── visitor
    └── nullobject

上面的包結構圖說明了PatternJava包含的23個設計模式是如何被組織在一起的。下面將對這些設計模式進行更加詳細的介紹。

二、創建型模式

1. 工廠方法模式

工廠方法模式是一種常用的創建型模式，它的核心思想是將對象的創建過程抽象出來，通過工廠類來完成。在PatternJava中，工廠方法模式被定義在factorymethod包中。

package com.pattern.creational.factorymethod;

public interface Product {
    void operation();
}

Product接口是所有產品類的父接口，它定義了產品的基本操作方法。在工廠方法模式中，每個產品類都實現這個接口，並實現自己的具體操作邏輯。

package com.pattern.creational.factorymethod;

public class ConcreteProduct implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProduct.operation");
    }
}

ConcreteProduct是具體的產品類，它實現了Product接口，並定義了自己的操作邏輯。

package com.pattern.creational.factorymethod;

public abstract class Creator {
    public abstract Product factoryMethod();
}

Creator是工廠類的抽象父類，它定義了一個工廠方法factoryMethod，用於創建產品對象。在具體的工廠類中，需要重寫這個工廠方法，以返回具體的產品對象。

package com.pattern.creational.factorymethod;

public class ConcreteCreator extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}

ConcreteCreator是具體的工廠類，它重寫了factoryMethod方法，並返回一個具體的產品對象ConcreteProduct。

2. 抽象工廠模式

抽象工廠模式是一種可以創建一組相關對象的創建型模式，它通過抽象工廠類和具體工廠類來實現。在PatternJava中，抽象工廠模式被定義在abstractfactory包中。

package com.pattern.creational.abstractfactory;

public interface AbstractProductA {
    void operationA();
}

public interface AbstractProductB {
    void operationB();
}

AbstractProductA和AbstractProductB是抽象產品類接口，它們定義了一組產品族的操作方法。

package com.pattern.creational.abstractfactory;

public class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA1.operationA");
    }
}

public class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB1.operationB");
    }
}

ConcreteProductA1和ConcreteProductB1是產品族1的具體產品類，它們分別實現了AbstractProductA和AbstractProductB接口。

package com.pattern.creational.abstractfactory;

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

ConcreteFactory1是產品族1的具體工廠類，它實現了AbstractFactory接口，並分別創建了產品族1中的具體產品ConcreteProductA1和ConcreteProductB1。

3. 建造者模式

建造者模式是一種將複雜對象的構建過程與其表示分離的創建型模式。在PatternJava中，建造者模式被定義在builder包中。

package com.pattern.creational.builder;

public class Product {
    private String partA;
    private String partB;
    private String partC;

    // getter and setter
}

Product類是要被建造的產品類，它包含了多個組成部分。

package com.pattern.creational.builder;

public interface Builder {
    void buildPartA(String partA);
    void buildPartB(String partB);
    void buildPartC(String partC);
    Product getResult();
}

Builder是抽象的建造者接口，它定義了建造對象的各個部分的方法，並定義了一個getResult方法，用於返回最終建造完成的對象。

package com.pattern.creational.builder;

public class ConcreteBuilder implements Builder {
    private Product product;

    public ConcreteBuilder() {
        product = new Product();
    }

    @Override
    public void buildPartA(String partA) {
        product.setPartA(partA);
    }

    @Override
    public void buildPartB(String partB) {
        product.setPartB(partB);
    }

    @Override
    public void buildPartC(String partC) {
        product.setPartC(partC);
    }

    @Override
    public Product getResult() {
        return product;
    }
}

ConcreteBuilder是具體的建造者類，它實現了Builder接口，並實現了接口中定義的所有方法。在建造完成後，通過getResult方法返回最終建造完成的對象。

4. 原型模式

原型模式是一種創建型模式，它的核心思想是通過複製已有對象來創建新對象，避免了重新創建對象的開銷。在PatternJava中，原型模式被定義在prototype包中。

package com.pattern.creational.prototype;

public abstract class Prototype implements Cloneable {
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

Prototype是原型類抽象父類，它實現了Cloneable接口，並重寫了clone方法。在具體的原型類中，需要實現Cloneable接口，以便利用Object類的clone方法創建新的對象。

package com.pattern.creational.prototype;

public class ConcretePrototype extends Prototype {
    private String field;

    public ConcretePrototype(String field) {
        this.field = field;
    }

    public String getField() {
        return field;
    }

    public void setField(String field) {
        this.field = field;
    }
}

ConcretePrototype是具體的原型類，它繼承了Prototype父類，並在自己的構造函數中設置一個字段。在Clone方法中，則需要重寫Prototype的Clone方法，以返回ConcretePrototype的新對象。

5. 單例模式

單例模式是一種創建型模式，它的核心思想是確保一個類只有一個實例，將其實例化操作延遲到第一次使用時進行。在PatternJava中，單例模式被定義在singleton包中。

package com.pattern.creational.singleton;

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

Singleton是單例類，它的構造函數是私有的，外部無法通過new操作符創建實例。在getInstance方法中，通過判斷instance是否為空來執行實例化操作，保證一個類只有一個實例。

三、結構型模式

1. 適配器模式

適配器模式是一種將不兼容的接口轉換為兼容的接口的結構型模式。在PatternJava中，適配器模式被定義在adapter包中。

package com.pattern.structural.adapter;

public interface Target {
    void request();
}

Target是適配器的目標接口，它是客戶端所期望的接口。

package com.pattern.structural.adapter;

public class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee.specificRequest()");
    }
}

Adaptee是需要被適配的接口，它是不兼容Target接口的。

package com.pattern.structural.adapter;

public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

Adapter是適配器類，它實現了Target接口，並包含需要被適配的對象Adaptee。在Adapter的request方法中，通過Adaptee的specificRequest方法將Target接口的請求轉換為Adaptee接口的請求。

2. 橋接模式

橋接模式是一種將抽象部分與實現部分分離的結構型模式。在PatternJava中，橋接模式被定義在bridge包中。

package com.pattern.structural.bridge;

public interface Implementor {
    void operationImpl();
}

Implementor是實現部分接口，它定義了所有實現部分的操作方法。

package com.pattern.structural.bridge;

public class ConcreteImplementor implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("ConcreteImplementor.operationImpl");
    }
}

ConcreteImplementor是具體實現部分類，它實現了Implementor接口，並提供自己的具體實現邏輯。

package com.pattern.structural.bridge;

public abstract class Abstraction {
    protected Implementor implementor;

    public Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }

    public abstract void operation();
}

Abstraction是抽象部分類，它包含了對實現部分的引用，並定義了抽象部分的操作方法。

package com.pattern.structural.bridge;

public class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(Implementor implementor) {
        super(implementor);
    }

    @Override
    public void operation() {
        implementor.operationImpl();
    }
}

RefinedAbstraction是具體抽象部分類，它繼承了Abstraction父類，並實現了接口中的operation方法，並調用實現部分的operationImpl方法，完成對實現部分的調用。

3. 組合模式

組合模式是一種將對象組合成樹形結構以表示部分-整體的結構型模式。在PatternJava中，組合模式被定義在composite包中。

package com.pattern.structural.composite;

import java.util.List;

public interface Component {
    void operation();
    void add(Component component);
    void remove(Component component);
    List getChildren();
}

Component是組合部分的抽象類，它定義了組合部分的基本操作，包括operation方法、add方法、remove方法、getChildren方法。

package com.pattern.structural.composite;
import
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/253778.html