前言

定义：

定义一系列的算法，并且将每个算法封装起来，算法之间还可以互相替换。本模式使得算法可以独立于使用它的客户而变化。

• 不用修改源码或继承的方式扩展原类的方法。
• 行为型的设计模式。
• 自我认识，在实现上是visitor模式的一部分
  案例

class Sequence {
    private var numbers: [Int];
    init(_ numbers: Int ...) {
        self.numbers = numbers;
    }
    func addNumber(value: Int) {
        self.numbers.append(value)
    }
    func coumpute() -> Int {
        return numbers.reduce(0){ $0 + $1};
    }
}

let sequence = Sequence(1, 2, 3, 4);
sequence.addNumber(value: 10);
sequence.addNumber(value: 20);
print("sum: \(sequence.coumpute())");

需求新增 乘法等算法。
也许你会这样做：

enum ALGORITHM {
    case ADD;
    case MULTIPLY;
}
class Sequence {
    private var numbers: [Int];
    init(_ numbers: Int ...) {
        self.numbers = numbers;
    }
    func addNumber(value: Int) {
        self.numbers.append(value)
    }
    func coumpute() -> Int {
        return numbers.reduce(0){ $0 + $1};
    }
    func compute(algorithm: ALGORITHM) -> Int {
        switch algorithm {
        case .ADD:
            return numbers.reduce(0){ $0 + $1 };
        case .MULTIPLY:
            return numbers.reduce(1){ $0 * $1 };
        }
    }
}

缺点：

• 每次增加都会修改 Sequence

策略模式 实现

protocol Strategy {
    func execute(values:[Int]) -> Int;
}

class SumStrategy: Strategy {
    func execute(values: [Int]) -> Int {
        return values.reduce(0){ $0 + $1 };
    }
}

class MutiplayStrategy: Strategy {
    func execute(values: [Int]) -> Int {
        return values.reduce(1){ $0 * $1 }
    }
}

final class Sequence {
    private var numbers: [Int];
    init(_ numbers: Int ...) {
        self.numbers = numbers;
    }
    func addNumber(value: Int) {
        self.numbers.append(value)
    }
    func coumpute() -> Int {
        return numbers.reduce(0){ $0 + $1};
    }
    func compute(strategy: Strategy) -> Int {
        return strategy.execute(values: self.numbers);
    }
}

let sequence = Sequence(1, 2, 3, 4);
sequence.addNumber(value: 10);
sequence.addNumber(value: 20);

let sumStrategy = SumStrategy();
let multiPlyStrategy = MutiplyStrategy();

let sum = sequence.compute(strategy: sumStrategy);
let multiply = sequence.compute(strategy: multiPlyStrategy);
print("sum: \(sum)");
print("multiply: \(multiply)");

做法很简单。 所有的算法遵循统一的协议。