设计模式

原型

它通过克隆已有对象来创建新对象。原型模式通过复制已有对象的状态来创建新对象，避免了从头开始创建对象的过程。 新对象与原对象之间是相互独立的，它们具有相同的状态，但不共享任何属性和方法。

场景：

1. 对象的创建过程比较复杂，例如需要进行多次数据库操作或网络请求等，使用原型模式可以避免这些操作的重复执行。

2. 需要创建<u>多个相似对象的场景</u>，例如对于大量具有相同属性的对象，使用原型模式可以避免重复设置这些属性。

3. 需要保护对象的状态，避免外部对象对其进行修改，使用原型模式可以通过复制已有对象来创建新对象，从而避免对原对象的修改。

实现例子

// Prototype.h
#import <Foundation/Foundation.h>

@protocol Prototype <NSObject>

- (id<Prototype>)clone;

@end


// Person.h
#import <Foundation/Foundation.h>
#import "Prototype.h"

@interface Person : NSObject <Prototype>

@property (nonatomic, copy) NSString *name
@property (nonatomic, assign) NSInteger age;

@end

// Person.m
#import "Person.h"

@implementation Person

- (id<Prototype>)clone {
    Person *person = [[Person alloc] init];
    person.name = self.name;
    person.age = self.age;
    return person;
}

@end


// main.m
#import <Foundation/Foundation.h>
#import "Person.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 创建原型对象
        Person *prototype = [[Person alloc] init];
        prototype.name = @"张三";
        prototype.age = 18;

        // 创建新对象
        Person *person1 = [prototype clone];
        person1.name = @"李四";

        Person *person2 = [prototype clone];
        person2.name = @"王五";

        NSLog(@"原型对象：%@", prototype);
        NSLog(@"新对象1：%@", person1);
        NSLog(@"新对象2：%@", person2);
    }
    return 0;
}


//输出结果
原型对象：<Person: 0x6000039b4f40>
新对象1：<Person: 0x6000039b5000>
新对象2：<Person: 0x6000039b50c0>

通俗场景

• 假设我们需要开发一个图形编辑器，其中包含多个形状（如矩形、圆形等）。这些形状除了颜色、位置等基本属性外，还有很多其他的属性和方法。如果每次创建一个新的形状对象时都要重新构造所有的属性和方法，那么将会非常繁琐和浪费资源。

• 在游戏开发中，我们可能需要创建多个相似但不完全相同的角色或敌人。通过使用原型模式，我们可以在游戏开始前创建一个基本的角色或敌人对象，并初始化其基本属性和方法，然后通过克隆它来创建新的角色或敌人对象。这样，我们可以快速创建多个相似的角色或敌人，同时还可以根据需要对每个角色或敌人进行个性化定制。

场景使用

假设我们需要开发一个在线教育平台，其中包含多个课程、教师和学生对象，它们都具有相同的基本属性和方法，但也有一些特有的属性和方法。此时，我们可以使用原型模式来实现对象的快速创建。

//Person.h

#import <Foundation/Foundation.h>

@protocol Prototype <NSObject>

- (id)clone;

@end

@interface Person : NSObject <Prototype>

@property (nonatomic, copy) NSString *ne;
@property (nonatomic, assign) NSInteger age;

- (instancetype)initWithName:(NSString *)name age:(NSInteger)age;

@end


//Person.m

#import "Person.h"

@implementation Person

- (instancetype)initWithName:(NSString *)name age:(NSInteger)age {
    if (self = [super init]) {
        _name = [name copy];
        _age = age;
    }
    return self;
}

- (id)clone {
    Person *person = [[self class] allocWithZone:NULL];
    person.name = [self.name copy];
    person.age = self.age;
    return person;
}

@end



//使用

Person *person1 = [[Person alloc] initWithName:@"Tom" age:18];
Person *person2 = [person1 clone];
NSLog(@"person1: %@, %ld", person1.name, (long)person1.age); // 输出：person1: Tom, 18
NSLog(@"person2: %@, %ld", person2.name, (long)person2.age); // 输出：person2: Tom, 18

person2.name = @"Jerry";
person2.age = 20;
NSLog(@"person1: %@, %ld", person1.name, (long)person1.age); // 输出：person1: Tom, 18
NSLog(@"person2: %@, %ld", person2.name, (long)person2.age); // 输出：person2: Jerry, 20

工厂模式

工厂模式可以理解为一种生产线模式，根据不同的需求来生产不同的产品。工厂模式的主要目的是将创建对象的过程和使用对象的过程分离开来，从而解耦。就是继承。

实现例子

//Animal.h 
#import <Foundation/Foundation.h>

@interface Animal : NSObject

@property (nonatomic, copy) NSString *name;

- (void)eat;
- (void)move;

@end


//Animal.m 
#import "Animal.h"

@implementation Animal

- (void)eat {
    NSLog(@"%@ is eating.", self.name);
}

- (void)move {
    NSLog(@"%@ is moving.", self.name);
}

@end


//Dog.h
#import "Animal.h"

@implementation Animal

- (void)eat {
    NSLog(@"%@ is eating.", self.name);
}

- (void)move {
    NSLog(@"%@ is moving.", self.name);
}

@end


//Dog.m
#import "Dog.h"

@implementation Dog

- (instancetype)init {
    if (self = [super init]) {
        self.name = @"Dog";
    }
    return self;
}

@end


//Cat.h
#import "Animal.h"

@interface Cat : Animal

@end



//Cat.m
#import "Cat.h"

@implementation Cat

- (instancetype)init {
    if (self = [super init]) {
        self.name = @"Cat";
    }
    return self;
}

@end


//AnimalFactory.h
#import <Foundation/Foundation.h>
#import "Animal.h"

@interface AnimalFactory : NSObject

+ (Animal *)createAnimalWithName:(NSString *)name;

@end


//AnimalFactory.m 
#import "AnimalFactory.h"
#import "Dog.h"
#import "Cat.h"

@implementation AnimalFactory

+ (Animal *)createAnimalWithName:(NSString *)name {
    if ([name isEqualToString:@"Dog"]) {
        return [[Dog alloc] init];
    } else if ([name isEqualToString:@"Cat"]) {
        return [[Cat alloc] init];
    } else {
        return nil;
    }
}

@end



//使用
Animal *dog = [AnimalFactory createAnimalWithName:@"Dog"];
[dog eat]; // 输出：Dog is eating.
[dog move]; // 输出：Dog is moving.

Animal *cat = [AnimalFactory createAnimalWithName:@"Cat"];
[cat eat]; // 输出：Cat is eating.
[cat move]; // 输出：Cat is moving.

使用场景

1. 在创建对象的过程中需要进行复杂的初始化或配置，例如需要读取配置文件、调用其他服务等；
2. 需要根据不同的条件创建不同的对象，例如根据不同的操作系统创建对应的界面控件；
3. 需要对创建的对象进行统一管理和控制，例如在游戏中控制怪物生成的数量和类型；
4. 需要通过接口来隐藏具体的实现类，例如在一个框架中，将具体的实现类放在独立的库中，通过工厂来创建对象，使得客户端代码只依赖于接口而不依赖于具体的实现。

抽象工厂

抽象工厂模式提供了一种将工厂的创建逻辑和产品的创建逻辑分离的方法，使得客户端可以更加简单地切换产品簇而不需要修改代码，同时也降低了客户端和产品之间的耦合度。

实现例子

// 抽象产品接口
@protocol Shape <NSObject>
- (void)draw;
@end

@protocol Color <NSObject>
- (void)fill;
@end

// 具体产品类
@interface Rectangle : NSObject <Shape>
@end
@implementation Rectangle
- (void)draw {
    NSLog(@"Inside Rectangle::draw() method.");
}
@end

@interface Square : NSObject <Shape>
@end
@implementation Square
- (void)draw {
    NSLog(@"Inside Square::draw() method.");
}
@end

@interface Red : NSObject <Color>
@end
@implementation Red
- (void)fill {
    NSLog(@"Inside Red::fill() method.");
}
@end

@interface Blue : NSObject <Color>
@end
@implementation Blue
- (void)fill {
    NSLog(@"Inside Blue::fill() method.");
}
@end

// 抽象工厂接口
@protocol AbstractFactory <NSObject>
- (id<Shape>)createShape;
- (id<Color>)createColor;
@end

// 具体工厂类
@interface ShapeFactory : NSObject <AbstractFactory>
@end
@implementation ShapeFactory
- (id<Shape>)createShape {
    return [[Rectangle alloc] init];
}
- (id<Color>)createColor {
    return [[Red alloc] init];
}
@end

@interface ColorFactory : NSObject <AbstractFactory>
@end
@implementation ColorFactory
- (id<Shape>)createShape {
    return [[Square alloc] init];
}
- (id<Color>)createColor {
    return [[Blue alloc] init];
}
@end

// 客户端代码
id<AbstractFactory> factory1 = [[ShapeFactory alloc] init];//因为AbstractFactory是一个抽象类，不能够被实例化，只能被继承。在创建一个抽象类的实例时，需要使用其子类来实现具体的功能。而在这里，ShapeFactory是AbstractFactory的子类，因此可以创建一个ShapeFactory的实例并将其赋值给一个指向AbstractFactory的指针，这个指针可以用于调用AbstractFactory中定义的方法。
id<Shape> shape1 = [factory1 createShape];
id<Color> color1 = [factory1 createColor];
[shape1 draw];
[color1 fill];

id<AbstractFactory> factory2 = [[ColorFactory alloc] init];
id<Shape

使用场景

1. 需要创建多个对象系列，这些系列具有相同的主题或目的，并且可能相互依赖或交互。

2. 需要在运行时根据配置或其他条件来动态地切换或选择不同的对象系列。

3. 需要遵循开闭原则，以便可以方便地添加或扩展不同的对象系列，而不需要修改已有代码。

4. 需要保证创建的对象系列之间的一致性和兼容性，以便可以轻松地相互替换和使用。

生成器

它的主要目的是将复杂对象的构建与表示分离开来，使得同样的构建过程可以创建不同的表示。生成器模式适用于创建一些复杂的对象，由于这些对象的构建过程比较复杂，直接使用构造函数或者工厂方法模式会显得比较繁琐和复杂。

生成器模式包含以下角色：

• 抽象生成器（Builder）：定义生成器的接口，包括构建对象的各个部分的方法，以及返回构建完成的对象的方法。
• 具体生成器（Concrete Builder）：实现抽象生成器接口，负责构建复杂对象的各个部分，并返回构建完成的对象。
• 指导者（Director）：负责指导具体生成器按照一定的顺序构建对象。
• 产品（Product）：最终生成的复杂对象。

使用例子

//Meal
@interface Meal : NSObject
@property (nonatomic, strong) NSString *drink;
@property (nonatomic, strong) NSString *food;
@property (nonatomic, assign) float price;
@end

@implementation Meal
@end


//MealBuilder
@interface MealBuilder : NSObject
- (void)buildDrink:(NSString *)drink;
- (void)buildFood:(NSString *)food;
- (void)buildPrice:(float)price;
- (Meal *)getMeal;
@end

@implementation MealBuilder {
    Meal *_meal;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        _meal = [[Meal alloc] init];
    }
    return self;
}

- (void)buildDrink:(NSString *)drink {
    _meal.drink = drink;
}

- (void)buildFood:(NSString *)food {
    _meal.food = food;
}

- (void)buildPrice:(float)price {
    _meal.price = price;
}

- (Meal *)getMeal {
    return _meal;
}
@end



//使用
MealBuilder *builder = [[MealBuilder alloc] init];
[builder buildDrink:@"Coke"];
[builder buildFood:@"Burger"];
[builder buildPrice:10.0];

Meal *meal = [builder getMeal];

使用场景

1. 创建复杂的对象：如果你需要创建一个复杂的对象，它需要多个步骤才能完成，每个步骤可能需要不同的参数，这时可以使用生成器模式来封装这个复杂的构建过程。

2. 创建不同的配置：如果你需要创建多种不同的配置，每种配置都包含一组不同的选项和设置，这时可以使用生成器模式来创建这些不同的配置对象。

3. 创建不同类型的数据库查询：如果你需要创建多种不同类型的数据库查询，每个查询都需要不同的参数和设置，这时可以使用生成器模式来创建这些查询对象。

4. 创建游戏角色：如果你正在创建一个角色扮演游戏，需要创建多种不同类型的游戏角色，每个角色都有不同的属性和能力，这时可以使用生成器模式来创建这些游戏角色。

单例

它的目的是确保某个类只有一个实例，并提供全局访问点。

实现例子

@interface Singleton : NSObject

+ (instancetype)sharedInstance;

@end

@implementation Singleton

+ (instancetype)sharedInstance {
    static Singleton *instance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[self alloc] init];
    });
    return instance;
}

@end

缺点

1. 对象创建时机不可控：单例模式在应用程序启动时就会创建一个实例对象，而有些情况下，我们可能希望在第一次使用该对象时再进行创建，以避免不必要的开销。

2. 单例对象职责过重：在某些情况下，单例对象可能承担了过多的职责，导致其变得复杂和难以维护。

3. 单例对象难以测试：由于单例对象无法被轻易地替换或模拟，因此在进行单元测试时可能会遇到困难。

4. 单例模式对可扩展性的影响：由于单例模式在系统中只存在一个实例对象，因此在后期需要对系统进行扩展时可能会遇到困难。

替代

1. 工厂模式：通过工厂方法来创建对象，可以控制对象的创建时机，避免在系统启动时就创建对象。

2. 依赖注入模式：通过将单例对象的创建过程交给依赖注入容器来管理，可以在需要时进行创建，并且可以方便地进行替换和测试。（依赖注入是一种编程思想，不能称之为一种模式）

3. 享元模式：将单例对象拆分成多个小对象，通过共享这些小对象来达到节约内存的效果，同时也可以避免单例对象职责过重的问题。