12.4　静态属性

在介绍静态属性之前，我们先来看一个类的设计，有一个Account（银行账户）类，假设它有3个属性：amount（账户金额）、interestRate（利率）和owner（账户名）。在这3个属性中，amount和owner会因人而异，不同的账户这些内容是不同的，而所有账户的interestRate都是相同的。

amount和owner属性与账户个体有关，称为实例属性。interestRate属性与个体无关，或者说是所有账户个体共享的，这种属性称为静态属性或类型属性。

3种面向对象类型（结构体、枚举和类）都可以定义静态属性，它们的语法格式分别如下所示：

  1. struct 结构体名 {                                  ①
  2.     static var(或let) 存储属性  = "xxx"            ②
  3.     ......
  4.     static var 计算属性名 : 属性数据类型 {         ③
  5.     get {
  6.         return 计算后属性值
  7.     }
  8.     set (新属性值) {
  9.         ......
  10.     }
  11.     }
  12. }
  14. enum 枚举名 {                                      ④
  15.     static var(或let) 存储属性  = "xxx"            ⑤
  16.     ......
  17.     static var 计算属性名 : 属性数据类型 {         ⑥
  18.     get {
  19.         return 计算后属性值
  20.     }
  21.     set (新属性值) {
  22.         ......
  23.     }
  24.     }
  25. }
  27. class 类名 {                                       ⑦
  28.     ......
  29.     class var 计算属性名 : 属性数据类型 {          ⑧
  30.     get {
  31.         return 计算后属性值
  32.     }
  33.     set (新属性值) {
  34.         ......
  35.     }
  36.     }
  37. }

上述代码中，第①行是定义结构体，结构体中可以定义静态存储属性和计算属性。第②代码是定义静态存储属性，声明关键字是static，这个属性可以是变量属性，也可以是常量属性。第③行代码是定义静态计算属性，声明使用的关键字是static，计算属性不能为常量，这里只能是变量。结构体静态计算属性也可以是只读的，语法如下：

  1. static var 计算属性名 : 属性数据类型 {
  2.     return 计算后属性值
  3. }

第④行是定义枚举，枚举中不可以定义实例存储属性，但可以定义静态存储属性，也可以定义静态计算属性。定义枚举静态属性与定义结构体静态属性的语法完全一样，这里就不再赘述了。

第⑦行是定义类，类中可以定义实例存储属性，但不可以定义静态存储属性。类中可以定义静态计算属性。声明使用的关键字是class，这与结构体和枚举的声明不同。

我们对上述说明进行了归纳，见表12-1。

表12-1　面向对象类型属性

面向对象类型 实例存储属性 静态存储属性 实例计算属性 静态计算属性
类 支持 不支持 支持 支持
结构体 支持 支持 支持 支持
枚举 不支持 支持 支持 支持

提示　在静态计算属性中不能访问实例属性（包括存储属性和计算属性），但可以访问其他静态属性。在实例计算属性中能访问实例属性，也能访问静态属性。

12.4.1　结构体静态属性

下面我们先看一个Account结构体静态属性示例：

  1. struct Account {
  3.     var amount : Double = 0.0                 //账户金额
  4.     var owner : String = ""                   //账户名
  6.     static var interestRate : Double = 0.668  //利率        ①
  8.     static var staticProp : Double {                        ②
  9.         return interestRate  1_000_000
  10.     }
  12.     var instanceProp : Double {                             ③
  13.         return Account.interestRate  amount
  14.     }
  15. }
  17. //访问静态属性
  18. println(Account.staticProp)                                 ④
  20. var myAccount = Account()
  21. //访问实例属性
  22. myAccount.amount = 1_000_000                                ⑤
  23. //访问静态属性
  24. println(myAccount.instanceProp)                             ⑥

上述代码定义了Account结构体，其中第①行代码定义了静态存储属性interestRate，第②行代码定义了静态计算属性staticProp，在其属性体中可以访问interestRate等静态属性。第③行代码定义了实例计算属性instanceProp，在其属性体中能访问静态属性interestRate，访问方式为“类型名.静态属性”，如Account.interestRate。第④行代码也是访问静态属性，访问方式也是“类型名.静态属性”。

第⑤行和第⑥行代码是访问实例属性，访问方式是“实例.实例属性”。

12.4.2　枚举静态属性

下面我们先看一个Account枚举静态属性示例：

  1. enum Account {
  3.     case 中国银行                                       ①
  4.     case 中国工商银行
  5.     case 中国建设银行
  6.     case 中国农业银行                                   ②
  8.     static var interestRate : Double = 0.668 //利率     ③
  10.     static var staticProp : Double {                    ④
  11.         return interestRate  1_000_000
  12.     }
  14.     var instanceProp : Double {                         ⑤
  16.         switch (self) {                                 ⑥
  17.             case 中国银行:
  18.                 Account.interestRate = 0.667
  19.             case 中国工商银行:
  20.                 Account.interestRate = 0.669
  21.             case 中国建设银行:
  22.                 Account.interestRate = 0.666
  23.             case 中国农业银行:
  24.                 Account.interestRate = 0.668
  25.         }                                               ⑦
  26.         return Account.interestRate  1_000_000         ⑧
  27.     }
  28. }
  30. //访问静态属性
  31. println(Account.staticProp)                             ⑨
  33. var myAccount = Account.中国工商银行
  34. //访问实例属性
  35. println(myAccount.instanceProp)                         ⑩

上述代码定义了Account枚举类型，其中第①~②行代码定义了枚举的4个成员。第③行代码定义了静态存储属性interestRate，第④行代码定义了静态计算属性staticProp，在其属性体中可以访问interestRate等静态属性。第⑤行代码定义了实例计算属性instanceProp，其中第⑥~⑦行代码使用switch语句判断当前实例的值，获得不同的利息，第⑥行代码中使用了self，它指代当前实例本身。第⑧行代码是返回计算的结果。

第⑨行代码是访问静态属性。第⑩行代码是访问实例属性。

示例运行结果如下：

  1. 668000.0
  2. 669000.0

12.4.3　类静态属性

下面我们先看一个Account类静态属性示例：

  1. class Account {                                                  ①
  3.     var amount : Double = 0.0               // 账户金额
  4.     var owner : String = ""                 // 账户名
  6.     var interestRate : Double = 0.668       // 利率              ②
  8.     class var staticProp : Double {                              ③
  9.         return 0.668  1_000_000
  10.     }
  12.     var instanceProp : Double {                                  ④
  13.         return self.interestRate  self.amount                   ⑤
  14.     }
  15. }
  17. //访问静态属性
  18. println(Account.staticProp)                                      ⑥
  20. var myAccount = Account()
  21. //访问实例属性
  22. myAccount.amount = 1_000_000
  23. //访问静态属性
  24. println(myAccount.instanceProp)                                  ⑦

上述代码第①行定义了Account类，第②行代码定义了存储属性interestRate，注意在类中不能定义静态存储属性。第③行代码定义了静态计算属性staticProp，关键字是class。第④行代码定义了实例计算属性instanceProp，在第⑤行代码访问实例属性interestRate和amount，访问当前对象的实例属性可以在属性前加“self.”，self指代当前实例本身。第⑥行代码也是访问静态属性。第⑦行代码是访问实例属性。