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