说实话，工厂模式在iOS开发中的应用真的hen广泛，尤其是在需要根据条件创建不同子类的时候。

你知道，为啥有时候我们需要工厂模式呢？就比如说你有个需求，要根据不同平台创建不同的UI组件。

哈哈，这时候Ru果不用工厂模式，你就得写一堆if-else或者switch-case，代码会变得hen乱。

先来kankan简单工厂模式是个啥样。

咱定义个协议，比如Button和TextField，然后为不同平台实现具体的组件。

protocol Button {
    func render
    func onTap
}
protocol TextField {
    func render
    func onInput
}
// MARK: - iOS 具体产品
struct IOSButton: Button {
    func render  { print }
    func onTap   { print }
}
struct IOSTextField: TextField {
    func render             { print }
    func onInput { print") }
}
// MARK: - Android 具体产品
struct AndroidButton: Button {
    func render  { print }
    func onTap   { print }
}
struct AndroidTextField: TextField {
    func render             { print }
    func onInput { print") }
}

然后咱再定义个工厂类，根据不同条件创建不同的组件。

enum Platform {
    case iOS, android
}
class SimpleFactory {
    static func makeButton -> Button {
        switch platform {
        case .iOS:
            return IOSButton
        case .android:
            return AndroidButton
        }
    }
    static func makeTextField -> TextField {
        switch platform {
        case .iOS:
            return IOSTextField
        case .android:
            return AndroidTextField
        }
    }
}

使用的时候，直接调用工厂方法就行了。

let button = SimpleFactory.makeButton
button.render   // 🔵 渲染 iOS 圆角按钮
button.onTap    // 📳 iOS Haptic 触感反馈

害，说实话，这个问题我也遇到过。

有人说是内容质量的问题，有人说是关键词优化的问题。

你懂的，其实影响收录的因素有hen多，比如网站权重、内容原创度、用户体验等等。

不过我觉得主要还是内容质量和关键词优化的问题。

好，继续说工厂模式。

抽象工厂模式其实是简单工厂模式的升级版，它解决的是创建一族相关对象的问题。

protocol UIFactory {
    func makeButton -> Button
    func makeTextField -> TextField
}
// MARK: - 具体工厂
struct IOSFactory: UIFactory {
    func makeButton    -> Button    { IOSButton }
    func makeTextField -> TextField { IOSTextField }
}
struct AndroidFactory: UIFactory {
    func makeButton    -> Button    { AndroidButton }
    func makeTextField -> TextField { AndroidTextField }
}

使用抽象工厂模式，Ke以保证同一工厂出来的产品风格一致。

class LoginVC {
    private let button: Button
    private let textField: TextField
    // 注入工厂，由外部决定平台风格
    init {
        self.button    = factory.makeButton
        self.textField = factory.makeTextField
    }
    func show {
        print
        textField.render
        textField.onInput
        button.render
        button.onTap
    }
}
// MARK: - 运行
print
LoginVC).show
print
LoginVC).show

不对不对，应该是：核心区别一句话——工厂方法解决"造哪个"，抽象工厂解决"造哪套"。

主要用于封装对象的创建逻辑，调用方只关心"我要什么"，不关心"怎么造"。

说白了就是把创建对象的逻辑封装起来让调用方geng方便地使用。

// 产品协议
protocol Button {
    func render
    func tap
}
// 具体产品
struct IOSButton: Button {
    func render { print }
    func tap    { print }
}
struct AndroidButton: Button {
    func render { print }
    func tap    { print }
}
// 工厂 —— 根据不同平台，决定创建哪种 Button
enum Platform { case iOS, android }
struct ButtonFactory {
// 提供公共创建方法，传入不同条件/场景，返回协议对象 
static func makeButton -> Button {
switch platform {
case .iOS:
return IOSButton
case .android:
return AndroidButton
}
}
}
// 使用：调用方不需要知道具体类型
let btn = ButtonFactory.makeButton
btn.render   // 🔵 
btn.tap

iOS开发中,无论是简单,还是抽象的dou有hen大作用。