设计模式（三）

4.2 工厂模式

        它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻 辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离，工厂模式 分为简单工厂、工厂方法、抽象工厂模式。

        创造一个工厂，通过该工厂来实例化需要的实例，如：在设计整个计算器时，会创建+，-，*，/各个运算类，当使用加法时，将“+”传给工厂有工厂实例化加法类，完成加法。

public class Test {
    public static void main(String[] args) throws Exception {
        Operation operation;
        operation = OperationFactory.createOperate("/");
        operation.setNumberA(1);
        operation.setNumberB(0);
        System.out.println(operation.getResult());
    }
}

class Operation {
    private double numberA;
    private double numberB;

    public double getNumberA() {
        return numberA;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    public double getResult() throws Exception {
        double result = 0;
        return result;
    }
}

class OperationAdd extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = super.getNumberA() + super.getNumberB();
        return result;
    }
}

class OperationSub extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = super.getNumberA() - super.getNumberB();
        return result;
    }
}

class OperationMul extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = super.getNumberA() * super.getNumberB();
        return result;
    }
}

class OperationDiv extends Operation {
    @Override
    public double getResult() throws Exception {
        double result = 0;
        if (super.getNumberB() == 0)
            throw new Exception("除数不能为0");
        result = super.getNumberA() / super.getNumberB();
        return result;
    }
}

class OperationFactory {
    public static Operation createOperate(String operate) {
        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
        }
        return operation;
    }
}

4.3 策略模式

        定义了一系列的算法或逻辑或相同意义的操作，并将每一个算法、逻辑、操作封装起来，而且使它们还可以相互替换（其实策略模式Java中用的非常非常广泛）。策略模式定义的一系列算法，完成的工作形同只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法的类与使用类之间的耦合。

        策略模式的用意是针对一组算法或逻辑，将每一个算法或逻辑封装到具有共同接口的独立的类中， 从而使得它们之间可以相互替换。例如：我要做一个不同会员打折力度不同的三种策略，初级会员，中级会员，高级会员（三种不同的计算）；我要一个支付模块，我要有微信支付、支付宝支付、银联支付等 。

        优点：策略模式有助于析出一系列算法的公共能力，比如上文提到的支付模块，各个支付方式共同点都是支付，不同在于使用的支付方式不同。除此之外，该模式简化了单元测试，每个算法都有自己的类，可以通过自己的接口单独测试。

        业务分析中一旦涉及到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式，处理这些变化。

        各类作用：

• Strategy：定义所有支持算法的公共接口

• ConcreteStrategyA等具体策略类，继承Strategy

• Context上下文，用ConcreteStrategy类来配置，维护对一个Strategy对象的引用

public class Test {
    public static void main(String[] args) {
        Context context;
        context =new Context(new ConcreteStrategyA());
        context.ContextInterface();

        context = new Context(new ConcreteStrategyB());
        context.ContextInterface();
    }
}

abstract class Strategy{
    public abstract void algorithmInterface();
}

class ConcreteStrategyA extends Strategy{

    @Override
    public void algorithmInterface() {
        System.out.println("算法A");
    }
}
class ConcreteStrategyB extends Strategy{

    @Override
    public void algorithmInterface() {
        System.out.println("算法B");
    }
}

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

    public void ContextInterface(){
        strategy.algorithmInterface();
    }
}