Swift Academy · 课时

基于协议的抽象

Q: 「基于协议的抽象」这节课中我会学到什么？

依赖协议，而不是具体类型。 你通过在浏览器中直接运行的动手代码来练习 Swift Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

依赖协议，而不是具体类型。

基于协议的抽象 是 CoddyKit 上的免费 Swift Academy 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Swift Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Swift Academy 课程共包含 4 节课。

基于协议的抽象

注入协议而不是具体类型，可以自由替换实现。使用者只依赖行为，而不依赖具体类。

定义协议

将能力描述为协议。任何遵循该协议的类型都可以作为依赖提供。

protocol Logging {
    func log(_ message: String)
}
print("Protocol describes behavior, not a concrete class.")

让具体类型遵循协议

真正的实现遵循该协议。它就是生产环境中的依赖。

protocol Logging { func log(_ m: String) }
struct ConsoleLogger: Logging {
    func log(_ m: String) { print("LOG: \(m)") }
}
ConsoleLogger().log("ready")

依赖协议

使用者的属性类型是协议，因此可以接受任何遵循该协议的值。

protocol Logging { func log(_ m: String) }
struct ConsoleLogger: Logging { func log(_ m: String) { print(m) } }
struct Service {
    let logger: Logging // protocol, not ConsoleLogger
    func run() { logger.log("running") }
}
Service(logger: ConsoleLogger()).run()

替换实现

由于类型是协议，您可以传入其他遵循该协议的实现，而无需修改使用者。

protocol Logging { func log(_ m: String) }
struct Loud: Logging { func log(_ m: String) { print(m.uppercased()) } }
struct Quiet: Logging { func log(_ m: String) {} }
struct Service { let logger: Logging; func run() { logger.log("hi") } }
Service(logger: Loud()).run()
Service(logger: Quiet()).run()

面向接口编程

这就是“依赖抽象，而非具体实现”的原则。高级代码不会受到低级细节的影响。

protocol Storage { func save(_ v: Int) }
struct MemoryStore: Storage { func save(_ v: Int) { print("kept \(v)") } }
struct Manager { let store: Storage; func add() { store.save(1) } }
Manager(store: MemoryStore()).add()

多个遵循者

多个类型可以遵循同一个协议，分别适用于网络、磁盘或内存等场景。

protocol Source { func value() -> Int }
struct Fixed: Source { func value() -> Int { 10 } }
struct Doubler: Source { func value() -> Int { 20 } }
func use(_ s: Source) { print(s.value()) }
use(Fixed())
use(Doubler())

带有关联行为的协议

协议可以声明多个方法，为依赖形成清晰的契约。

protocol Cache {
    func get(_ key: String) -> Int?
    func set(_ key: String, _ v: Int)
}
struct Dict: Cache {
    var store: [String: Int] = [:]
    func get(_ k: String) -> Int? { store[k] }
    mutating func set(_ k: String, _ v: Int) { store[k] = v }
}
var c = Dict(); c.set("a", 1)
print(c.get("a") ?? -1)

泛型约束

您还可以通过受协议约束的泛型参数进行注入，从而避免存在类型带来的开销。

protocol Greeter { func greet() -> String }
struct English: Greeter { func greet() -> String { "Hello" } }
struct Welcome<G: Greeter> {
    let greeter: G
    func show() { print(greeter.greet()) }
}
Welcome(greeter: English()).show()

稳定的契约

只要协议保持稳定，实现就可以在内部改变，而不会破坏使用者。

protocol Formatter { func format(_ n: Int) -> String }
struct Plain: Formatter { func format(_ n: Int) -> String { "\(n)" } }
struct Padded: Formatter { func format(_ n: Int) -> String { String(format: "%03d", n) } }
func render(_ f: Formatter) { print(f.format(7)) }
render(Plain())
render(Padded())

为模拟做好准备

重要的是，协议允许测试提供一个模拟实现来替代真实实现。这正是下一课的重点。

protocol Network { func fetch() -> String }
struct Real: Network { func fetch() -> String { "server data" } }
struct VM { let net: Network; func load() { print(net.fetch()) } }
VM(net: Real()).load()

快速检查

为什么要注入协议类型，而不是具体类？

回顾

注入协议可以隐藏具体类型，因此可以替换为任何遵循该协议的类型。这遵循“依赖抽象”的原则，并支持替代实现，更重要的是，还支持测试替身。下一步：在测试中模拟依赖。

常见问题解答

「基于协议的抽象」课时是免费的吗？

是的 — 「基于协议的抽象」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Swift Academy 课程的其余内容，请升级到 CoddyKit PRO。 Swift Academy 课程共包含 4 节课。

「基于协议的抽象」这节课中我会学到什么？

依赖协议，而不是具体类型。你通过在浏览器中直接运行的动手代码来练习 Swift Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Swift Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Swift Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「基于协议的抽象」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Swift Academy 课中编写并运行代码吗？

能。每节 Swift Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Swift Academy