Swift(五 属性)

属性

1、 存储属性

1.1 实例存储属性 - 重点掌握

• 存在于类、结构体中，枚举不行

• 可用var\let定义实例属性

• 对于类，创建的let常量实例不能修改let定义的实例存储属性，只能修改var定义的变量存储属性

• 对于结构体，创建的let实例，不能修改let与var定义的实例存储属性。如果创建的是var实例，只能修改var定义的实例存储属性（常量值类型，无论是结构体还是枚举都不能修改，即便它的属性是变量属性也不能修改）

• 引用类型相当于指针，常量指针是不能修改的，但是它所指向的内容可以修改

• 延迟存储属性 [eg： lazy var 属性名：属性类型 = 属性类型() ] 必须定义的同时初始化,在第一次访问时候，才加载

• 实例属性访问方式：实例.实例属性(如果self能省略不写 那就不适用self)

  • 代码如下：

           // 类
          class Employee{
    
              let no: Int = 0
              var name: String = ""
              var job: String?
              var salary: Double = 0
              var dept: Department?
    
          }
    
          // 结构体
          struct Department{
              var no: Int = 0
              var name: String = ""
    
          }
    
          // 类 与 结构体的实例化
          let emp = Employee()
          //emp.no = 100  // 编译错误  no是let原因
    
          let dept = Department()  // 编译错误 是let的原因
          dept.name = "qwe"
    
          let emp1 = Employee()
          emp1.name = "asd"  // 正确，类一般用let定义
    

  1.2 静态存储属性

  • 存在于类(又叫类型属性static)、结构体(static)、枚举(static-不能定义实例存储属性)中

  • 在类、结构体、枚举中定义类似，static var(let) 存储属性 = “xxx” 一般都会赋值

  • 静态属性访问方式：类型名.静态属性 在实例计算属性内引用必须加类型名，在静态计算属性内引用可以省略类型名或者由self替换

  • 代码如下：

    --------------------结构体静态存储属性---------------
      struct Account{
      var amount: Double = 0.0
      var owner: String = ""
    
      static var interestRate: Double = 0.0668
    
      // 静态只读计算属性
     static var staticProp: Double{
         return interestRate * 1_000_000 
         //  相当于Account.interestRate 与 self.interestRate，此时self代表类型名
         }
      }
      // 访问静态属性
      Account.interestRate
    --------------------枚举静态存储属性类似---------------
    --------------------类静态存储属性类似-----------------
    

2、 计算属性

2.1 实例计算属性

• 存在于类、结构体、枚举中（Getter无参 + Setter有参 默认为newValue）

• 不存储数据，而是从其他存储属性中计算得到数据

• 只读计算属性只有Getter没有Setter（先掌握Getter的简写）

• self可以用于类、结构体和枚举类型中，代表当前实例，可用于访问自身的实例方法与属性self.rawValue

• 代码如下：

       //  类
       class Employee{
             let no: Int = 0
             var firstName: String = "Tony"
             var lastName: String = "Guan"
             var job: String?
             var salary: Double = 0
            
             // 计算属性
             var fullName: String{
                 get{
                       return firstName + "." + lastName
                  }
                 set{  // set(newFullValue) 省略  默认使用newValue字段
                       var name = newValue.components(separatedBy: ".") // 分割为字符串数组
                       firstName = name[0]
                       lastName = name[1]
                   }
  
               }
              // 只读计算属性  只有get方法  但是get可以省略
             var fullName1: String{
                        return firstName + "." + lastName
               }
       } // end class Employee
  
       // 实例化
       var emp = Employee()
       print(emp.fullName)
  
       emp.fullName = "123.qwe"
       print(emp.fullName)
  
  
      ------------------------------------
  
        // 枚举
       enum WeekDays: String{
  
            case Monday  = "Mon."
            case Tuesday = "Tue."
            case Wednesday = "Wed."
            case Thursday = "Thu."
            case Firday = "Fir."
  
           // 枚举的只读计算属性
           var message: String{
                    return "Today is " + self.rawValue
                }
            }
  
         // 枚举的实例化！！！！！！！
          var day = WeekDays.Monday
          print(day.message)
      --------------------------------
       //   打印结果
        Tony.Guan
        123.qwe
        Today is Mon.
  

2.2 静态计算属性

• 存在于类(static\class)、结构体(static)、枚举(static)中

• 在静态计算属性中不能访问实例属性（存储+计算），但可以访问其他静态属性。在实例计算属性中能访问实例属性，也能访问静态属性（可以联想到java的实例变量与类变量）

• 类静态计算属性如果使用static定义，则该属性不能再子类中被重写（override），如果使用class定义，则该属性可以被子类重写。

• 代码如下：

   ------结构体的静态计算属性（类枚举与此类似，类可用class或者static）----------------
   struct Account{
      var amount: Double = 0.0
      var owner: String = ""
  
     static var interestRate: Double = 0.0668
  
  
     // 静态只读计算属性
     static var staticProp: Double{
            return interestRate * 1_000_000 // Account.interestRate与self.interestRate都是正确的
           }
  
     // 实例只读属性
     var intanceProp: Double{
               return Account.interestRate * amount  // Account不能省略，self.amount写法也是正确的
          }
    }
  
  // 访问静态计算属性
  Account.staticProp
  ----------------------类的静态计算属性-----------------
  // static不能override，  class可以
  class Account1{
      var amount: Double = 0.0
      var owner: String = ""
      static var interestRate: Double = 0.0668
     // 静态只读计算属性 static不能被重写
     class var staticProp: Double{
                return interestRate * 1_000_000
      }
  
     // 实例只读属性
     var intanceProp: Double{
            return Account1.interestRate * self.amount
     }
  }
  
  
  // 继承：属性也被继承过来了  Account2可以访问此时Account1的属性
  class Account2: Account1{
  
       // 计算属性的重写
      override class var staticProp:Double{
           return interestRate * 1000000
      }
  }
  

3、 属性观察者-存储属性

• 监听存储属性的变化，即便前后变化的值相同，也能监听到

• 属性观察者不能监听延迟存储属性和常量存储属性的变化, 实例存储属性与静态存储属性可以被监听

• 属性观察者不存在于枚举中(枚举没有存储属性的存在)，存在于类与结构体中

• willSet + didSet（默认参数newValue + oldValue）

• 代码如下：

      class Employee{
  
             let no: Int = 0
             var name: String = "Tony"{  // 也可写成var name: String?{}
                     willSet{  // willSet(newNameValue)也可以  willSet很少用，didSet就能获得新值与旧值了
                            print("新值\(newValue)")
                        }
                    didSet{
                          print("旧值\(oldValue)")
    
                      }
  
                }
       var job: String?
       var salary: Double = 0
  }
  
  // 实例化
  var emp = Employee()
  emp.name = "CBG"
  

4、 访问属性

• 我的建议最好是静态属性加上类型名，实例属性加上实例名称（self\实例名---self能省略就不使用）。读起来更加容易。