深入了解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/n/253778.html