概念：软件实体应当对扩展开放，对修改关闭

理解：当编写代码的时候，当需求增加或者新增功能的时候，不需要对原始的代码进行改写，只需进行添加，所以就达成了对扩展开放，对修改关闭的原则

开闭原则：是软件设计的终极目标，对扩展开放可以使软件拥有一定的灵活性，同时对修改关闭又可以保持软件的稳定性。

开闭原则的优势：
①：测试方便，由于开闭原则对修改关闭，因此软件实体是拥有稳定性的，测试只需对扩展代码进行测试即可
②：更好的提高代码的复用性，开闭原则通常采用抽象接口的方式来组织代码结构，抽象的编程本身就对代码的复用性的提高有很大的帮助
③：提高软件的维护性和扩展性，由于开闭原则对扩展开放，因此当软件需要升级的时候，可以很容易对的通过扩展来实现新的功能，开发效率会更高，代码也更易于维护

开闭原则的实现方式
①：继承
②：接口

接下来，假如我们要做个APP切换主题需求
以下为原始需求
先定义好颜色的枚举：

enum Color : String {
    case black = "black"
    case white = "white"
    case red = "red"
    case blue = "blue"
    case green = "green"
    case gray = "gray"
    case yellow = "yellow"
    case purple = "purple"
}

接着定义好默认主题

class BaseStyle{
    var backGroundColor = Color.white
    var  textColor  = Color.black
    
    init() {
        
    }
    //应用主题的方法
    func apply()  {
        print("主题被应用 ： 背景色\(self.backGroundColor.rawValue)，文字颜色\(self.textColor.rawValue)")
   }
    
}

接下来调用代码

let style = BaseStyle()
style.apply()

控制台输出：

主题被应用 ： 背景色white，文字颜色black

到现在这个时候，我们拿到了一个新的需求：“我们不只需要一个基础的背景色，需要添加其他的主题风格”。
这个时候我们的代码应该如何通过开闭原则来进行扩展呢？首先遵循开闭原则的核心：“对扩展开放，对修改关闭”
当然不能对 BaseStyle 这个类进行修改，这样会违背开闭原则，我们应该尽量不修改原始的代码。

第一种方法 ： 继承
假如我们要新增苹果的 暗黑模式
新增类

    DarkStyle

继承自

    BaseStyle

class darkStyle : BaseStyle{
    var buttonColor = Color.red
    
    override init() {
        super.init()
        self.backGroundColor = Color.black
        self.textColor = Color.white
    }
    
    override func apply() {
        print("主题被应用 ： 背景色\(self.backGroundColor.rawValue)，文字颜色\(self.textColor.rawValue)，按钮颜色\(self.buttonColor.rawValue)")
    }
}

方法调用以及控制台打印

let dark = darkStyle()
dark.apply()

主题被应用 ： 背景色black，文字颜色white，按钮颜色red

以上通过继承这种方式就遵循了开闭原则，并没有修改任何关于 BaseStyle 类的代码，就实现了功能的扩展。

第二种方法 ： 接口（协议）
在swift语言中 通过接口的方式来实现其实就是通过协议的方式来实现
在协议中，我们一般会定义新增需求或者功能的属性或方法，它们就相当于新功能的接口，在协议中不需要实现方法，需要在新增的类中实现

定义风格协议（只需实现get方法）

protocol StyleProtocol{
    var backGroundColor : Color{get}
    var textColor : Color{get}
    var buttonColor : Color{get}
    func apply()
}

定义原始类 LightStyle

class LightStyle : StyleProtocol{
    var backGroundColor : Color{get
    {
        return Color.white
        }
    }
     var textColor : Color{get
     {
        return Color.black
        }
    }
     var buttonColor : Color{get
     {
        return Color.blue
        }
    }
    func apply(){
             print("（通过接口）主题被应用 ： 背景色\(self.backGroundColor.rawValue)，文字颜色\(self.textColor.rawValue)，按钮颜色\(self.buttonColor.rawValue)")
    }
}

此时，需要在LightStyle上新增BlackStyle，又不能修改LightStyle里面的代码我们应该怎么做呢？

新定义BlackStyle 遵循StyleProtocol协议

class BlaskStyle : StyleProtocol{
    var backGroundColor : Color{get
       {
           return Color.blue
           }
       }
        var textColor : Color{get
        {
           return Color.red
           }
       }
        var buttonColor : Color{get
        {
           return Color.green
           }
       }
       func apply(){
                print("（通过接口） 主题被应用 ： 背景色\(self.backGroundColor.rawValue)，文字颜色\(self.textColor.rawValue)，按钮颜色\(self.buttonColor.rawValue)")
       }
}

可以看到，在不修改原来LightStyle代码下，新增BlaskStyle

调用与打印

let light = LightStyle()
light.apply()

let black = BlaskStyle()
black.apply()

（通过接口）主题被应用 ： 背景色white，文字颜色black，按钮颜色blue
（通过接口） 主题被应用 ： 背景色blue，文字颜色red，按钮颜色green

以上的例子我们可以看到，在原始类LightStyle新增BlaskStyle风格，只需新增BlaskStyle类并遵循相同的协议就可以了，通过这种方式实现的开闭原则比通过继承实现的耦合度更低，更易于维护

七大原则传送门

Swift-里式替换原则