初识设计模式（一）

😄

#一、简单工厂模式

简单工厂模式又叫静态工厂方法，实质上是由一个工厂类根据传入参数，动态决定（判断）创建多个产品类的实例，这些产品类继承于一个父类或接口。

例：
public class operationFactory{
    public static Operation createOperation(String operation){
        Operation oper = null;
        switch(operation){
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

如示例中，Operation是运算接口，通过工厂类来产出具体的产品实例（加减乘除）。

所属：创建型模式。

缺点：所有的实例创建都集中在工厂类中，它创建的类是只能是事先考虑到的，如果需要添加新的类，就要改变工厂类。

😂

#二、策略模式

官方：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

它定义一系列算法，从概念上看所有算法完成相同的工作，以相同的方式调用算法，减少了算法间的耦合。

例：
class CashContext{
    CashSuper cs = null;                
    public CashContext(String type){    
        switch(type){
            case "正常收费":
                cs = new CashNormal();
                break;
            case "满300返100":
                cs = new CashReturn("300","100");
                break;
            case "打8折":
                cs = new CashRebate("0.8");
                break;
        }
    }
    public double GetResult(double money){  //根据不同的策略，调用其算法的方法
        return cs.acceptCash(money);
    }
}

如示例是简单工厂模式与策略模式的结合，单纯的策略模式的Context类如下：

例：
class Context{
    Strategy strategy = null;
    public Context(Strategy strategy){          //初始化时传入具体的策略对象
        this.strategy = strategy;
    }
    public void ContextInterface(){
        strategy.AlgorithmInterface();          //根据具体的策略对象，调用其方法
    }
}

主要解决：算法多且相似，用if...else复杂难维护。

何时使用：系统有许多类，区分它们的只是它们的直接行为。

如何解决：将算法封装成多个类，可以任意地替换。

实例：诸葛亮的锦囊妙计，出行方式的选择。

😁

#三、单一职责原则

面向对象的五大原则之一。

官方：就一个类而言，应该仅有一个引起它变化的原因。

如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。

软件设计要做的就是发现职责并把那些职责相互分离。

如何判断是否该分离：如果你能够想到多余一个的动机去改变一个类，那么这个类就具有多于一个的职责。

😆

#四、开放-封闭原则

面向对象的五大原则之二，面向对象的核心。

官方：是说软件实体（类、模块、函数等等）应该可以扩展，但是不可修改。也就是说对于扩展是开放的，对于修改是封闭的。

在我们最初编写代码时，假设变化不发生。当变化发生时，我们就创建抽象来隔离以后发生的同类变化。对程序的改动是通过增加新代码进行的，而不是更改现有代码。

---