iOS开发

设计模式与软件原则 (二):SOLID 原则

2022-02-19  本文已影响0人  _浅墨_
SOLID 设计原则

SOLID 设计原则鼓励我们创建更易于维护、更易于理解和更灵活的软件。

  1. 单一职责原则(Single Responsibility Principle)

实体应承担一项责任。

  1. 开闭原则(Open-Closed Principle)

实体应该对 extension 开放但对修改(modification) 关闭。

  1. 里氏替换原则(Liskov Substitution Principle)

如果类 A 是类 B 的子类型,那么我们应该能够用 A 替换 B 而不会破坏程序的行为。

  1. 接口隔离(Interface Segregation)

实体不应使用他们不会完全使用的接口。大接口应该拆分成更小的接口。

  1. 依赖倒置(Dependency Inversion)

高级模块不应该依赖于低级模块,两者都应该依赖于抽象。

下面我们来看代码示例:

// 一、单一职责原则(Single Responsibility Principle)

class User {
    
    var name: String
    var profileName: String
    
    init(name: String, profileName: String) {
        self.name = name
        self.profileName = profileName
    }
    
    func changeName(to name: String) {
        self.name = name
    }
    
    func changeProfileName(to profileName: String) {
        self.profileName = profileName
    }
    
}

struct Account {
    
    var user: User
    
    init(user: User) {
        self.user = user
    }
    
    func createAccount() {
        print("account created")
    }
    
    func loginAccount() {
        print("logged into account")
    }
    
    func logoutAccount() {
        print("logged out of account")
    }
    
}

//二、开闭原则

class Guitar {
    
    var brandName: String
    var model: String
    
    init(brandName: String, model: String) {
        self.brandName = brandName
        self.model = model
    }
    
}

class FlameGuitar: Guitar {
    var flame: String = "Red"
}

protocol Instrument {
    var brandName: String { get set }
    var model: String { get set }
}

class BassGuitar: Instrument {
    
    var brandName: String
    var model: String
    
    init(brandName: String, model: String) {
        self.brandName = brandName
        self.model = model
    }
    
}

class WaterGuitar: Instrument {
    
    var brandName: String
    var model: String
    var waterVolume: Int
    
    init(brandName: String, model: String, waterVolume: Int) {
        self.brandName = brandName
        self.model = model
        self.waterVolume = waterVolume
    }
    
}

// 三、里氏替换原则(Liskov Substitution Principle)
protocol Polygon {
    var area: Float { get }
}

class Rectangle: Polygon {
    
    var width: Float = 0
    var length: Float = 0
    
    init(length: Float, width: Float) {
        self.length = length
        self.width = width
    }
    
    var area: Float {
        return width * length
    }
    
}

class Square: Polygon {
    
    var side: Float = 0 

    init(side: Float) {
        self.side = side
    }
    
    var area: Float {
        return side * side
    }
    
}

func printArea(ofPolygon polygon: Polygon) {
    print(polygon.area)
}

let rectangle = Rectangle(length: 10, width: 2)
printArea(ofPolygon: rectangle)
let square = Square(side: 2)
printArea(ofPolygon: square)

// 四、接口隔离(Interface Segregation)
protocol Vehicle {
    func accelerate()
}

protocol Engine {
    func turnEngineOn() 
}

class MotorCar: Vehicle, Engine {
    
    func turnEngineOn() {  
        print("engine on!")
    }
    
    func accelerate() {
        print("going faster")
    }
}

class HorseDrawnCarriage: Vehicle {
    func accelerate() {
        print("going faster")
    }
}

// 五、依赖倒置(Dependency Inversion)
protocol CloudService {
    func fetchData(url: String) -> [String]
}

struct FirebaseService: CloudService {
    
    func observeSingleEvent(forRef: String) -> [String] {
        return ["Post"]
    }
    
    func fetchData(url: String) -> [String] {
        return observeSingleEvent(forRef: url)
    }
}

struct ParseService: CloudService {
    
    func fetchData(url: String) -> [String] {
        return ["Post"]
    }
}

class UserFeed {
    
    private let data: CloudService
    
    init(data: CloudService) {
        self.data = data
    }
    
    func getUserFeedData(url: String) {
        data.fetchData(url: url)
    }
}

let parseService = ParseService()
let userFeedService = UserFeed(data: parseService)
userFeedService.getUserFeedData(url: "url")

上一篇下一篇

猜你喜欢

热点阅读