六大设计原则

• 单一职责原则
  一个类只承担一个职责
• 开闭原则
  对扩展开发，对修改关闭
• 里氏替换原则
  父类可以被子类无缝替换，且原有的功能不受影响。也就是说，最好不要重写，而是新增。
• 接口隔离原则
  使用多个专门的协议，而不是一个庞大臃肿的协议
• 依赖倒置原则
  抽象不应该依赖于具体的实现，而实现依赖于抽象。
  也就是说，调用接口感觉不到内部是如何操作的。
• 迪米特法则
  一个对象应该对其他对象尽可能少的了解，实现高内聚、低耦合

23种设计模式

• 创建型设计模式：主要用于创建对象
  • 原型模式
  • 单例模式
  • 工厂方法模式
  • 抽象工厂模式
  • 建造者模式
• 结构型设计模式：用于处理类或对象的组合
  • 适配器模式
  • 桥接模式
  • 组合模式
  • 装饰模式
  • 外观模式
  • 享元模式
  • 代理模式
• 行为型设计模式：用于描述类或对象怎么交互和怎么分配职责
  • 责任链模式
  • 命令模式
  • 解释器模式
  • 迭代器模式
  • 中介者模式
  • 备忘录模式
  • 状态模式
  • 策略模式
  • 模板方法模式
  • 访问者模式
  • 观察者模式

创建型设计模式

主要用于创建对象

原型模式

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
原型模式可以理解为一种深拷贝的行为。在OC中表示遵守NSCoping协议，在Swift中代表值类型。
角色分析：

• 克隆协议
• 产品协议
• 具体产品

//MARK: 产品协议
protocol ProductProtocol{
    var name: String { get set }
}
//MARK: 克隆协议
protocol CloneProtocol{
    func cloneProduct() -> ProductProtocol
}
//MARK: 具体产品
class Product: ProductProtocol,CloneProtocol{
    var name: String = "水煮肉片"
    func cloneProduct() -> ProductProtocol {
        let p = Product()
        p.name = name
        return p
    }
}

单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点。
我们常见的NSFileManager、UIApplication都有单例。

class SignleClass{
    let instance = SignleClass()
}

工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。
工厂方法模式是对单个产品进行抽象，多个工厂可实现各自的产品。

角色分析：

• 抽象工厂
• 具体工厂
• 抽象产品
• 具体产品

////抽象工厂
protocol FactoryProtocol{
    func createComputer() -> ProductProtocol
}

//抽象产品
protocol ProductProtocol{
    var name: String { get set }
}
//华为电脑
class HuaWeiComputer: ProductProtocol{
    var name: String = "华为电脑"
}
//华为工厂
class HuaWeiFactory: FactoryProtocol {
    func createComputer() -> ProductProtocol {
        HuaWeiComputer()
    }
}

//苹果电脑
class AppleComputer: ProductProtocol{
    var name: String = "苹果电脑"
}
//苹果工厂
class AppleFactory: FactoryProtocol{
    func createComputer() -> ProductProtocol {
        AppleComputer()
    }
}

Cocoa框架中的类簇完美的演绎了工厂方法模式，Foundation框架中NSString、NSData、NSDictionary、NSSet、NSArray中定义了类簇

id obj1 = [NSArray alloc]; // __NSPlacehodlerArray *
id obj2 = [NSMutableArray alloc];  // __NSPlacehodlerArray *
id obj3 = [obj1 init];  // __NSArrayI *
id obj4 = [obj2 init];  // __NSArrayM *

如以上代码所示，alloc后并非生成我们期望的实例，而是__NSPlacehodlerArray的中间类的对象，后面的init消息都是发送给这个中间对象，init方法就是其中的工厂方法，其结果是生成具体的类的对象。

抽象工厂模式

提供一个接口，用于创建与某些对象相关或依赖于某些对象的类家族，而又不需要制定它们的具体类。

抽象工厂是工厂方法模式的升级，它是对多个产品进行抽象。

角色分析：

• 抽象工厂
• 具体工厂
• 抽象产品
• 具体产品

//MARK: 抽象工厂
////抽象工厂
protocol FactoryProtocol{
    //造电脑
    func createComputer() -> ComputerProtocol
    //造手机
    func createPhone() -> PhoneProtocol
}
//MARK: 抽象产品
//抽象产品->电脑
protocol ComputerProtocol{
    var name: String { get set }
}
//抽象产品->手机
protocol PhoneProtocol {
    var name: String { get set }
}

//MARK: 具体产品
//华为电脑
class HuaWeiComputer: ComputerProtocol{
    var name: String = "华为电脑"
}
//苹果电脑
class AppleComputer: ComputerProtocol{
    var name: String = "苹果电脑"
}
//华为手机
class HuaWeiPhone: PhoneProtocol{
    var name: String = "华为手机"
}
//苹果手机
class ApplePhone: PhoneProtocol{
    var name: String = "iPhone"
}

//MARK: 具体工厂
//华为工厂
class HuaWeiFactory: FactoryProtocol {
    func createComputer() -> ComputerProtocol {
        HuaWeiComputer()
    }
    func createPhone() -> PhoneProtocol {
        HuaWeiPhone()
    }
}
//苹果工厂
class AppleFactory: FactoryProtocol{
    func createComputer() -> ComputerProtocol {
        AppleComputer()
    }
    func createPhone() -> PhoneProtocol {
        ApplePhone()
    }
}

建造者模式（生成器）

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
简单来讲，就是将创建复杂对象的算法独立于该对象的组成部分，让另外一个类来实现

//抽象建造者
protocol BuilderProtocol {
    func createProduct() -> ProductProtocol
}
//抽象产品
protocol ProductProtocol {
    var name: String { get }
}
//具体产品
class HouseProduct: ProductProtocol {
    var name: String = "房子"
}
//具体建造者
class RealBuilder: BuilderProtocol {//生产者
    func createProduct() -> ProductProtocol {
        return HouseProduct()
    }
}
//设计者，领导
class Director {
    var builder: BuilderProtocol = RealBuilder()
    
    func construct() -> ProductProtocol? {//指导生产
        return builder.createProduct()
    }
}