本文由海之号角(OceanHorn)翻译自ochococo/OOD-Principles-In-Swift

import Swift
import Foundation

Swift 2.2 面向对象设计原则

基于 Xcode 7.3 Playground 的一个简短备忘 (OOD-Principles-In-Swift.playground.zip).

👷 项目由 @nsmeme (Oktawian Chojnacki)维护。

S.O.L.I.D.

• 单一功能原则 (The Single Responsibility Principle)
• 开放-封闭原则 (The Open Closed Principle)
• 里氏替换原则 (The Liskov Substitution Principle)
• 接口分离原则 (The Interface Segregation Principle)
• 依赖倒置原则 (The Dependency Inversion Principle)

🔐 单一功能原则

有且仅有一个原因可以使得一个类需要调整。 (read more)

举例:

protocol CanBeOpened {
    func open()
}

protocol CanBeClosed {
    func close()
}

// PodBayDoor类有一个封闭的状态，可以通过方法来改变这个状态。
final class PodBayDoor: CanBeOpened, CanBeClosed {

    private enum State {
        case Open
        case Closed
    }

    private var state: State = .Closed

    func open() {
        state = .Open
    }

    func close() {
        state = .Closed
    }
}

// DoorOpener类仅仅负责打开，并不知道门内有什么以及怎样关闭。
class DoorOpener {
    let door: CanBeOpened

    init(door: CanBeOpened) {
        self.door = door
    }

    func execute() {
        door.open()
    }
}

// DoorCloser类仅负责关闭，并不清楚门内有什么以及怎样打开。
class DoorCloser {
    let door: CanBeClosed

    init(door: CanBeClosed) {
        self.door = door
    }

    func execute() {
        door.close()
    }
}

let door = PodBayDoor()

⚠ 仅有DoorOpener负责将门打开。

let doorOpener = DoorOpener(door: door)
doorOpener.execute()

⚠ 如果有其他的操作来关闭门，比如打开报警器，你将不需要改变DoorOpener类。

let doorCloser = DoorCloser(door: door)
doorCloser.execute()

✋ 开放-封闭原则

你将能够扩展一个类的行为，而不必修改这个类本身。 (read more)

举例:

protocol CanShoot {
    func shoot() -> String
}

// 激光束，可以射击。
final class LaserBeam: CanShoot {
    func shoot() -> String {
        return "Ziiiiiip!"
    }
}

// 要你命3000，拥有各种武器并可以依次完成拥有的所有武器的射击。
final class WeaponsComposite {

    let weapons: [CanShoot]

    init(weapons: [CanShoot]) {
        self.weapons = weapons
    }

    func shoot() -> [String] {
        return weapons.map { $0.shoot() }
    }
}

let laser = LaserBeam()
var weapons = WeaponsComposite(weapons: [laser])

weapons.shoot()

火箭发射车，可以射出火箭。

⚠️ 为了增加火箭发射车类，并不需要改变既有的任何类。

final class RocketLauncher: CanShoot {
    func shoot() -> String {
        return "Whoosh!"
    }
}

let rocket = RocketLauncher()

weapons = WeaponsComposite(weapons: [laser, rocket])
weapons.shoot()

👥 里氏替换原则

派生类必须能够替代他们的基类。 (read more)

举例:

let requestKey: NSString = "NSURLRequestKey"

// RequestError是NSError的子类，提供额外的功能，但不会跟父类中的功能相混淆。
class RequestError: NSError {

    var request: NSURLRequest? {
        return self.userInfo[requestKey] as? NSURLRequest
    }
}

// 获取数据失败后返回RequestError的实例对象。
func fetchData(request: NSURLRequest) -> (data: NSData?, error: RequestError?) {

    let userInfo: [NSObject:AnyObject] = [ requestKey : request ]

    return (nil, RequestError(domain:"DOMAIN", code:0, userInfo: userInfo))
}

// 这里并不清楚RequestError是什么，在请求失败时返回一个NSError实例对象。
func willReturnObjectOrError() -> (object: AnyObject?, error: NSError?) {

    let request = NSURLRequest()
    let result = fetchData(request)

    return (result.data, result.error)
}

let result = willReturnObjectOrError()

// 以我的观点，这是一个完美的NSError实例。
let error: Int? = result.error?.code

// 但是这里它也是一个RequestError实例，一切都非常完美！
if let requestError = result.error as? RequestError {
    requestError.request
}

🍴 接口分离原则

提供给使用者指定粒度的接口。 (read more)

举例:

// 拥有一个着陆地点。
protocol LandingSiteHaving {
    var landingSite: String { get }
}

// 拥有着陆能力，可以着陆在着陆地点对象上。
protocol Landing {
    func landOn(on: LandingSiteHaving) -> String
}

// 载有有效载荷。
protocol PayloadHaving {
    var payload: String { get }
}

// 国际空间站类，可以通过装置，比如加拿大臂(空间站上用的机械装置)，取到有效载荷。
final class InternationalSpaceStation {

⚠ 空间站并不知道SpaceX CRS8的着陆能力。

    func fetchPayload(vehicle: PayloadHaving) -> String {
        return "Deployed \(vehicle.payload) at April 10, 2016, 11:23 UTC"
    }
}

// 海洋着陆平台，有一个着陆地点。
final class OfCourseIStillLoveYouBarge: LandingSiteHaving {
    let landingSite = "a barge on the Atlantic Ocean"
}

// SpaceX CRS8类，携带有效载荷，可以着陆在有着陆地点的地方。
// SpaceX CRS8是有个非常有限的太空运输工具。 （下面的BEAM是比奇洛公司的充气空间站舱段。最近有新闻。）
final class SpaceXCRS8: Landing, PayloadHaving {

    let payload = "BEAM and some Cube Sats"

⚠ CRS8仅仅知道着陆位置信息。

    func landOn(on: LandingSiteHaving) -> String {
        return "Landed on \(on.landingSite) at April 8, 2016 20:52 UTC"
    }
}

let crs8 = SpaceXCRS8()
let barge = OfCourseIStillLoveYouBarge()
let spaceStation = InternationalSpaceStation()

spaceStation.fetchPayload(crs8)
crs8.landOn(barge)

🔩 依赖倒置原则

依赖抽象，而非具象。 (read more)

举例:

protocol TimeTraveling {
    func travelInTime(time: NSTimeInterval) -> String
}
// DeLorean是科幻电影《回到未来》中的那辆车的名字。
final class DeLorean: TimeTraveling {
    func travelInTime(time: NSTimeInterval) -> String {
        return "Used Flux Capacitor and travelled in time by: \(time)s"
    }
}
// Emmett Brown就是埃米特*布朗博士，电影主角之一。
final class EmmettBrown {
    private let timeMachine: TimeTraveling

⚠ 是Emmet Brown给了DeLorean的TimeTraveling功能，而非DeLorean本身。

    init(timeMachine: TimeTraveling) {
        self.timeMachine = timeMachine
    }

    func travelInTime(time: NSTimeInterval) -> String {
        return timeMachine.travelInTime(time)
    }
}

let timeMachine = DeLorean()

let mastermind = EmmettBrown(timeMachine: timeMachine)
mastermind.travelInTime(-3600 * 8760)

Info

📖 摘自: The Principles of OOD by Uncle Bob

本文相关代码请见OceanHorn/OOD-Principles-In-Swift,原文链接请见ochococo/OOD-Principles-In-Swift