状态模式：用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题
当系统中某个对象存在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。
状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中。

1、Context（环境类）

在环境类中维护一个抽象状态类State的实例

//银行账户：环境类，环境类又称为上下文类，它是拥有多种状态的对象。在环境类中维护一个抽象状态类State的实例
class Account {
    var state: AccountState? //维持一个对抽象状态对象的引用
    var owner: String
    var balance: Double = 0
    
    init(owner: String, initial: Double) {
        self.owner = owner
        self.state = NormalState.init(acc: self)
        print("\(self.owner)开户，初始金额为\(initial)");
        print("-------------------")
    }
    func deposit(amout: Double) {
        self.state?.deposit(amount: amout)
        print("现在余额为\(self.balance),账户状态为：\(String(describing: self.state!))")
        print("-------------------")
    }
    func withdraw(amout: Double) {
        self.state?.withdraw(amount: amout)
        print("现在余额为\(self.balance),账户状态为：\(String(describing: self.state!))")
        print("-------------------")
    }
    func computeInterest() {
        self.state?.computeInterest()
    }
}

2、State（抽象状态类）

作用：用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现类这些方法
状态之间的转换，通常有两种实现方式：（本示例使用了方式2）
1、统一有环境内来负责状态之间的转换，此时，环境类还充当的状态管理器（state manager）角色
2、由具体状态类来负责状态之间的转换，此时，状态类与环境类存在依赖或关联关系，因为状态类需要访问环境类中的属性值。

为了避免循环引用，在AccountState中引用的Account类型需要添加weak。详细可参考swift中解决循环引用的三种方法

//抽象状态类
class AccountState {
    weak var acc: Account?
    
    init(acc: Account) {
        self.acc = acc
    }
    
    func deposit(amount: Double) {
        self.acc?.balance += amount
        self.stateCheck()
    }
    func withdraw(amount: Double) {
        self.acc?.balance -= amount
        self.stateCheck()
    }
    func computeInterest() {
        print("正常状态，无须支付利息！")
    }
    //状态转换
    func stateCheck() {
        guard let account = self.acc else {
            return
        }
        if account.balance > 0.0 {
            account.state = NormalState.init(acc: account)
        } else if  account.balance > -2000.0 && account.balance <= 0.0 {
            account.state = OverdraftState.init(acc: account)
        } else if account.balance == -2000.0 {
            account.state = RestrictedState.init(acc: account)
        } else if account.balance < -2000.0 {
            print("操作受限！")
        }
        
    }
}

3、ConcreteState（具体状态类）

class NormalState: AccountState {
  
}
//透支状态：具体状态类
class OverdraftState: AccountState {
    override func computeInterest() {
        print("计算利息！")
    }
}
//受限状态：具体状态类
class RestrictedState: AccountState {
    override func withdraw(amount: Double) {
        print("帐号受限，取款失败")
    }
    override func computeInterest() {
        print("计算利息！")
    }
}

测试代码

print("/*********** 状态模式 State ***********/")
let acc = Account.init(owner: "段誉", initial: 0.0)
let state = NormalState.init(acc: acc)
acc.state = state
acc.deposit(amout: 1000)
acc.withdraw(amout: 2000)
acc.deposit(amout: 3000)
acc.withdraw(amout: 4000)
acc.withdraw(amout: 1000)
acc.computeInterest()

共享状态

如果希望在系统中实现多个环境对象共享一个或多个状态对象，需要将这些状态对象定义为环境类的静态成员对象

class Switch {
    //定义静态成员对象
    static var state: State = OnState.init()
    var name: String
    
    init(name: String) {
        self.name = name
        Switch.state = OnState.init()
    }
    
    func on() {
        print("\(self.name)")
        Switch.state.on(s: self)
    }
    
    func off() {
        print("\(self.name)")
        Switch.state.off(s: self)
    }
}

protocol State {
    func on(s: Switch)
    func off(s: Switch)
}

class OnState: State {
    func on(s: Switch) {
        print("已经打开！")
    }
    
    func off(s: Switch) {
        print("关闭！")
        Switch.state = OffState.init()
    }
    
    
}

class OffState: State {
    func on(s: Switch) {
        print("打开！")
        Switch.state = OnState.init()
    }
    
    func off(s: Switch) {
        print("已经关闭！")
    }
    
}

static作用：
1、被static修饰的局部变量，延长生命周期至整个应用程序结束
2、被static修饰的局部变量，只会分配一次内存。程序一运行就会给static变量分配内存