揭秘殊途同归的设计模式：工厂、策略、模版方法共存之妙

2023-09-14 18:40:56

殊途同归的设计模式：工厂、策略、模版方法

在软件开发中，设计模式是常用的解决方案，用于解决经常遇到的问题。工厂模式、策略模式、模版方法模式是三种最常用的设计模式。

工厂模式：创建对象的通用方式

工厂模式是一种创建对象的通用方式。它将对象的创建过程与对象的实际实现分离。这使得我们可以很容易地改变对象的创建过程，而不影响对象的实现。

在工厂模式中，我们定义一个抽象工厂类，该类负责创建各种具体的对象。具体对象是由具体工厂类创建的。具体工厂类是抽象工厂类的子类。

public interface Factory {
    Product createProduct();
}

public class ConcreteFactory1 implements Factory {
    @Override
    public Product createProduct() {
        return new Product1();
    }
}

public class ConcreteFactory2 implements Factory {
    @Override
    public Product createProduct() {
        return new Product2();
    }
}

public class Product {
    // ...
}

public class Product1 extends Product {
    // ...
}

public class Product2 extends Product {
    // ...
}

策略模式：让算法和使用算法的对象分离

策略模式是一种让算法和使用算法的对象分离的设计模式。这使得我们可以很容易地改变算法，而不影响使用算法的对象。

在策略模式中，我们定义一个策略接口，该接口定义了算法的通用方法。具体策略类是策略接口的子类。具体策略类实现了算法的具体实现。

public interface Strategy {
    void algorithm();
}

public class ConcreteStrategy1 implements Strategy {
    @Override
    public void algorithm() {
        // ...
    }
}

public class ConcreteStrategy2 implements Strategy {
    @Override
    public void algorithm() {
        // ...
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.algorithm();
    }
}

模版方法模式：定义算法的骨架，允许子类重新定义算法的某些步骤

模版方法模式是一种定义算法的骨架，允许子类重新定义算法的某些步骤的设计模式。这使得我们可以很容易地改变算法的某些步骤，而不影响算法的整体结构。

在模版方法模式中，我们定义一个抽象模版类，该类定义了算法的骨架。具体模版类是抽象模版类的子类。具体模版类重新定义了算法的某些步骤。

public abstract class AbstractTemplate {
    public final void templateMethod() {
        step1();
        step2();
        step3();
    }

    protected abstract void step1();

    protected abstract void step2();

    protected abstract void step3();
}

public class ConcreteTemplate1 extends AbstractTemplate {
    @Override
    protected void step1() {
        // ...
    }

    @Override
    protected void step2() {
        // ...
    }

    @Override
    protected void step3() {
        // ...
    }
}

public class ConcreteTemplate2 extends AbstractTemplate {
    @Override
    protected void step1() {
        // ...
    }

    @Override
    protected void step2() {
        // ...
    }

    @Override
    protected void step3() {
        // ...
    }
}