当前位置：首页 > news >正文

ios中常见的设计原则和设计模式

news 来源：原创 2025/5/8 7:31:22

七大设计原则

1：开闭原则

对扩展开放，对修改关闭，在设计模块的时候，使模块在不被修改的前提下可以扩展功能

2:依赖倒置原则

实现尽量依赖抽象，不依赖具体实现

（1）高层模块不应该依赖底层模块，两者都应该依赖于抽象

（2）抽象不应该依赖于细节，细节应该依赖于抽象

3:单一职责原则

对于一个类而言，应该只存在一个可以一起类变化的原因，一个类只承担一个职责，如果一个类有两个职责，应该将其非开。比如tableviewCell如果有多种样式Cell，分成几种类型写Cell。

4:里氏替换原则

适用父类的功能一定适用于子类，子类能替换父类的对象，子类可以扩展父类的功能，不能修改父类原有的功能。

5:接口隔离原则（设计更专一更小的接口）

客户端不应该依赖不需要的接口，类之间的依赖类应建立在最小的接口上，类不应该被迫实现不需要的方法

6:迪米特法则

一个对象对另一个对象了解的越多，耦合度就越高（对象之间应该保持最少的了解）

7:组合/复用原则

在一个新的对象里面使用已有的对象，使成为新对象一部分。优先使用对象组合聚合来实现代码复用，而不是继承

设计模式

ios开发中常见的设计模式主要分为三大类：

创造型模式（解决对象创建问题）

结构型模式（解决对象组织和结构问题）

行为型模式（解决对象间的交互问题）

创造型模式

单例模式

确保一个类只有一个实例，并提供全局访问点。比如userDefault、UIApplication、FileManager等

例如

class Singleton {
    static let shared = Singleton() // 全局唯一实例

    private init() {} // 防止外部初始化

    func doSomething() {
        print("执行某些操作")
    }
}

// 使用单例
Singleton.shared.doSomething()

Swift提供Lazy属性，可以保证线程安全，不需要额外加锁。

工厂模式

提供创建对象的接口，不直接实例化对象。隐藏负责的对象创建逻辑，提高代码的复用性。

示例：

protocol Animal {
    func makeSound() -> String
}

class Dog: Animal {
    func makeSound() -> String { return "🐶 汪汪" }
}

class Cat: Animal {
    func makeSound() -> String { return "🐱 喵喵" }
}

// 工厂类
class AnimalFactory {
    static func createAnimal(type: String) -> Animal? {
        switch type {
        case "dog": return Dog()
        case "cat": return Cat()
        default: return nil
        }
    }
}

// 使用工厂
let dog = AnimalFactory.createAnimal(type: "dog")
print(dog?.makeSound() ?? "未知") // 🐶 汪汪

结构型模式

代理模式

通过委托对象，处理某些任务，用于类之间通信。

protocol TaskDelegate: AnyObject {
    func taskDidComplete()
}

class Worker {
    weak var delegate: TaskDelegate?

    func doWork() {
        print("正在执行任务...")
        delegate?.taskDidComplete() // 任务完成后通知代理
    }
}

class Manager: TaskDelegate {
    func taskDidComplete() {
        print("任务完成，经理收到通知！")
    }
}

// 使用代理
let worker = Worker()
let manager = Manager()
worker.delegate = manager
worker.doWork()

观察者模式

用于通知多个对象数据更新，如NotificationCenter、KVO

NotificationCenter：

// 发送通知
NotificationCenter.default.post(name: Notification.Name("TaskCompleted"), object: nil)

// 监听通知
NotificationCenter.default.addObserver(forName: Notification.Name("TaskCompleted"), object: nil, queue: .main) { _ in
    print("收到任务完成通知！")
}

KVO

class Person: NSObject {
    @objc dynamic var age = 20
}

let person = Person()
let observer = person.observe(\.age, options: .new) { _, change in
    print("年龄变化：\(change.newValue!)")
}

person.age = 25 // 输出：年龄变化：25

行为型模式

责任链模式

按顺序处理事件，如UIResponder事件传递

class Handler {
    var next: Handler?
    
    func handleRequest(_ request: String) {
        if next != nil {
            next?.handleRequest(request)
        } else {
            print("请求 \(request) 没有处理者")
        }
    }
}

class ConcreteHandlerA: Handler {
    override func handleRequest(_ request: String) {
        if request == "A" {
            print("A 处理请求")
        } else {
            super.handleRequest(request)
        }
    }
}

class ConcreteHandlerB: Handler {
    override func handleRequest(_ request: String) {
        if request == "B" {
            print("B 处理请求")
        } else {
            super.handleRequest(request)
        }
    }
}

// 创建责任链
let handlerA = ConcreteHandlerA()
let handlerB = ConcreteHandlerB()
handlerA.next = handlerB

handlerA.handleRequest("B") // 输出：B 处理请求

备忘录模式

保存和恢复对象状态，如 UserDefaults。

class Game {
    var score = 0
    
    func save() -> Int {
        return score
    }
    
    func restore(_ score: Int) {
        self.score = score
    }
}

let game = Game()
game.score = 100
let savedScore = game.save()

game.score = 50
game.restore(savedScore) // 恢复存档

print(game.score) // 输出：100