设计模式-创建型

Posted 2023-02-24 极客学伟

设计模式-创建型

创建型设计模式包含：单例模式、原型模式、工厂方法模式、抽象工厂模式、建造者模式

单例模式

单例模式在开发中也是最常见的一种设计模式之一，系统原生提供的很多类的设计都采用了单例模式，例如：

FileManager.default
UserDefaults.standard
NotificationCenter.default
UIApplication.shared
URLSession.shared

其目的是为了节省内存资源并保证数据内容的一致性，需要让某些类只能创建一个实例。单例模式有如下特点：

• 单例类只有一个实例对象
• 单例类的实例对象由自己创建
• 需要对外提供一个访问其实例对象的接口

在软件设计中，有关全局共享的资源数据，大型通用的管理类等都可以使用单例模式，例如登录用户的用户信息类、全局的计时器、程序的日志管理类

Swift 单例

class ClassA 
    static let share = ClassA()

Objective-C 单例

static XXClassManager *_defaultManager;
+ (instancetype)shareInstance 
    if (!_defaultManager) 
        _defaultManager = [[self alloc] init];
    
    return _defaultManager;

+ (instancetype)allocWithZone:(struct _NSZone *)zone 
    if (!_defaultManager) 
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^
            _defaultManager = [super allocWithZone:zone];
        );
    
    return _defaultManager;

- (id)copyWithZone:(NSZone *)zone
    return _defaultManager;

- (id)mutableCopyWithZone:(NSZone *)zone
    return _defaultManager;

原型模式

以一个已经创建的实例作为原型，通过复制该原型对象来创建出对象，在使用对象时，使用者无需关心对象创建的细节。在ios开发中：copy 方法就是对原型设计模式的一种实现。主要是提供了一种大量创建复杂对象的方法。

重构前

import Foundation
class Computer 
    var cpu: String
    var host: String
    var screen: String
    var uuid: String
    init(cpu: String, host: String, screen: String) 
        self.cpu = cpu
        self.host = host
        self.screen = screen
        self.uuid = UUID().uuidString
    
    func logUUID() 
        print(uuid)
    

let computer1 = Computer(cpu: "Intel core i7 7700K", host: "GY088-GDF-60", screen: "3008 x 1692")
computer1.logUUID()

此时若希望创建一台相同配置的电脑则只能使用重复的创建方法

let computer2 = Computer(cpu: "Intel core i7 7700K", host: "GY088-GDF-60", screen: "3008 x 1692")

重构后

import Foundation
class Computer 
    ...
    
    func copy() -> Computer 
        return Computer(cpu: self.cpu, host: self.host, screen: self.screen)
    

新增一个 copy() 方法，此时再创建相同配置的电脑只需调用原型的 copy() 方法即可，省去了配件的创建过程。
使用原型模式，一旦第一个对象被创建，后面的对象创建都将变得非常容易。其中，作为模板对象被称为原型，创建出来的对象拥有和模板对象一致的属性和方法。

工厂方法模式

工厂方法设计模式注重于将对象的创建过程封闭起来，通过定义抽象的工厂接口和商品接口来隐藏负责对象创建的具体类

对上述 Computer 类进行重构

重构后

enum Level 
    case low
    case high

protocol ComputerFactoryProtol 
    static func getComputer(level: Level) -> ComputerProtol

protocol ComputerProtol 
    var cpu: String  get 
    var host: String  get 
    var screen: String  get 
    var uuid: String  get 
    func logUUID()

class Computer: ComputerProtol 
    var cpu: String
    var host: String
    var screen: String
    var uuid: String
    init(cpu: String, host: String, screen: String) 
        self.cpu = cpu
        self.host = host
        self.screen = screen
        self.uuid = UUID().uuidString
    
    func logUUID() 
        print(uuid)
    

class ComputerFactory: ComputerFactoryProtol 
    static func getComputer(level: Level) -> ComputerProtol 
        switch level 
        case .low:
            return Computer(cpu: "Intel core i5 3300K", host: "GY088-GDF-10", screen: "1920 x 1080")
        case .high:
            return Computer(cpu: "Intel core i7 7700K", host: "GY088-GDF-60", screen: "3008 x 1692")
        
    

引入的 ComputerFactory 即工厂设计模式的具体体现，外界不再指明具体的配置信息，只需要根据 level 即可创建指定配置的 Computer，
创建高配电脑，例如：

let computer3 = ComputerFactory.getComputer(level: .high)

如果新增加了一种创建方式完全不同的计算机，我们只需要新建一个遵守 ComputerProtol 的计算机类，之后在 ComputerFactory 中统一处理这种新增的计算机类型即可，对使用者完全隐藏。

抽象工厂模式

抽象工厂是对工厂模式的一种升级，核心思路是为各种类型的对象提供一组统一的创建接口，使用者无需关心这些对象具体是如何创建的。

还是上述代码，若我们工厂方法即生产 Computer 又可以生产 TV

重构后

enum Level 
    case low
    case high

protocol ComputerFactoryProtol 
    static func getComputer(level: Level) -> ComputerProtol
    static func getTV() -> TVProtol

protocol TVProtol 
    var name: String  get 
    func logName()

class TV: TVProtol 
    var name: String
    init(name: String) 
        self.name = name
    
    func logName() 
        print(self.name)
    

protocol ComputerProtol 
    ...

class Computer: ComputerProtol 
    ...    

class ComputerFactory: ComputerFactoryProtol 
    static func getTV() -> TVProtol 
        return TV(name: "海尔")
    
    static func getComputer(level: Level) -> ComputerProtol 
        ...
    

重构后工厂类可以创建不同的对象，对于使用者无需关心创建的细节，抽象工厂将对象的创建和使用进行了完全分离。

建造者模式

建造者模式用于复杂对象的创建，使代码聚合性更强，逻辑更加清晰。建造者模式通常与工程模式配合使用，工厂着重于对象的创建，建造者着重于创建复杂对象过程中组成对象的每一部分创建和最终组装。
核心在于将复杂的对象拆解成多个简单对象，通过一步步构建简单对象最终组合成复杂对象。

重构后

enum Foodtype 
    case a
    case b

enum Drink 
    case cola
    case juice

enum Staple 
    case hamburger
    case chickenRoll

class FoodPackage 
    var drink: Drink?
    var staple: Staple?

class BuildA 
    var foodPackage = FoodPackage()
    func build() -> FoodPackage 
        foodPackage.drink = .cola
        foodPackage.staple = .hamburger
        return foodPackage
    

class BuildB 
    var foodPackage = FoodPackage()
    func build() -> FoodPackage 
        foodPackage.drink = .juice
        foodPackage.staple = .chickenRoll
        return foodPackage
    

class FoodFactory 
    static func buildFood(type: Foodtype) -> FoodPackage 
        switch type 
        case .a:
            return BuildA().build()
        case .b:
            return BuildB().build()
        
    

let foodPackage = FoodFactory.buildFood(type: .a)

其中，一个完整的套餐对象由饮料对象、主食对象组成，FoodFactory 为工厂方法，其中根据套餐类型创建不同的套餐对象，具体的套餐对象的组成则是由 BuildA 和 BuildB 来完成。 BuildA 和 BuildB 是建造者模式的核心类，充当建造者的角色。