服务器上建设网站郑州建设工程协会网站

七大设计原则

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) { _ inprint("收到任务完成通知！")
}

 KVO

class Person: NSObject {@objc dynamic var age = 20
}let person = Person()
let observer = person.observe(\.age, options: .new) { _, change inprint("年龄变化：\(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 = handlerBhandlerA.handleRequest("B") // 输出：B 处理请求

备忘录模式

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

class Game {var score = 0func 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