swift类、枚举和结构体的属性 - Swift最新教程

上一章Swift教程请查看：swift类和对象

Swift语言为类、枚举或结构提供属性来关联值，属性可以进一步分为存储属性和计算属性。

存储属性和计算属性之间的差异

存储属性	计算属性
将常量和变量值存储为实例	计算一个值，而不是存储该值
由类和结构提供	由类、枚举和结构提供

存储和计算的属性都与实例类型相关联，当属性与其类型值相关联时，则将其定义为“类型属性”。存储和计算的属性通常与特定类型的实例相关联，但是，属性也可以与类型本身相关联，这些属性称为类型属性，属性观察还用于：

以观察存储属性的值
观察继承自超类的子类的属性

存储属性

Swift引入了存储属性概念来存储常量和变量的实例，常量的存储属性由’let’关键字定义，变量的存储属性由’var’关键字定义。

定义期间，存储属性提供“默认值”
在初始化期间，用户可以初始化和修改初始值

struct Number {
   var digits: Int
   let pi = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.pi)")

请考虑上述代码中的下列行

let pi = 3.1415

这里，变量pi被初始化为一个存储的属性值，实例pi = 3.1415，因此，每当实例被引用时，它将单独保存值3.1415。

另一种存储属性的方法是使用常量结构，因此，结构的整个实例将被视为“常量的存储属性”。

struct Number {
    var digits: Int
    let numbers = 3.1415
 }
 
 var n = Number(digits: 12345)
 n.digits = 67
 
 print("\(n.digits)")
 print("\(n.numbers)")
 n.numbers = 8.7

它将返回一个错误消息，指示将“number”声明为常量，而不是将“number”初始化为8.7。

惰性存储属性

Swift提供了一个名为“惰性存储属性”的灵活属性，当变量第一次初始化时，它不会计算初始值。在变量声明之前使用’lazy’修饰符，将其作为懒存储属性。

使用惰性性质：

延迟对象创建。
当属性依赖于类的其他部分时，这些部分还不知道

class sample {
    lazy var no = number()    // `var` 声明是必须的
 }
 
 class number {
    var name = "Swift"
 }
 
 var firstsample = sample()
 print(firstsample.no.name)

实例变量

在Objective-C中，存储的属性也有实例变量，用于备份以存储在存储属性中声明的值。

Swift将这两个概念集成到一个单独的“存储属性”声明中，“stored property”包含了在一个单一位置中定义的关于变量属性的所有集成信息，包括变量名、数据类型和内存管理功能，而不是拥有一个对应的实例变量和备份值。

计算属性

与存储值不同，计算属性提供一个getter和一个可选的setter来间接检索和设置其他属性和值。

class sample {
    var no1 = 0.0, no2 = 0.0
    var length = 300.0, breadth = 150.0
 
    var middle: (Double, Double) {
       get {
          return (length / 2, breadth / 2)
       }
       
       set(axis){
          no1 = axis.0 - (length / 2)
          no2 = axis.1 - (breadth / 2)
       }
    }
 }
 
 var result = sample()
 print(result.middle)
 result.middle = (0.0, 10.0)
 
 print(result.no1)
 print(result.no2)

当计算得到的属性未定义新值时，将为该特定变量设置默认值。

计算属性为只读属性

计算属性中的只读属性定义为具有getter但没有setter的属性，它总是用来返回一个值，变量进一步通过’.’语法访问，但不能设置为其他值。

class film {
    var head = ""
    var duration = 0.0
    var metaInfo: [String:String] {
       return [
          "head": self.head,
          "duration":"\(self.duration)"
       ]
    }
 }
 
 var movie = film()
 movie.head = "Swift Properties"
 movie.duration = 3.09
 
 print(movie.metaInfo["head"]!)
 print(movie.metaInfo["duration"]!)

计算属性作为属性观察者

在Swift中，使用属性观察者来观察和响应属性值。每次设置属性值时，都会调用属性观察者。除了延迟存储属性外，我们还可以通过方法“覆盖”将属性观察者添加到“继承”属性中。

属性观察者可以由以下任意一种定义

在存储值- willset之前
在存储新值didset之后
当在初始化器中设置属性时，将无法调用willset和didset观察者。

class Samplepgm {
    var counter: Int = 0 {
       willSet(newTotal){
          print("Total: \(newTotal)")
       }
       
       didSet {
          if counter > oldValue {
             print("最新添加: \(counter - oldValue)")
          }
       }
    }
 }
 
 let NewCounter = Samplepgm()
 NewCounter.counter = 100
 NewCounter.counter = 800

局部变量和全局变量

为了计算和观察属性，声明了局部变量和全局变量。

本地变量	全局变量
在函数、方法或闭包上下文中定义的变量。	在函数、方法、闭包或类型上下文外部定义的变量。
用于存储和检索值。	用于存储和检索值。
存储的属性用于获取和设置值。	存储的属性用于获取和设置值。
还使用计算属性。	还使用计算属性。

类型属性

属性是在类型定义部分用大括号{}定义的，变量的作用域也是在前面定义的，对于定义值类型的类型属性，使用“static”关键字，对于类类型使用“class”关键字。

语法

struct Structname {
    static var storedTypeProperty = " "
    static var computedTypeProperty: Int {
       // 返回Int值
    }
 }
 
 enum Enumname {
    static var storedTypeProperty = " "
    static var computedTypeProperty: Int {
       // 返回Int值
    }
 }
 
 class Classname {
    class var computedTypeProperty: Int {
       // 返回Int值
    }
 }

查询和设置属性

就像实例属性一样，查询并使用’.’设置属性类型，只针对类型，而不是指向实例。

struct StudMarks {
    static let markCount = 97
    static var totalCount = 0
    
    var InternalMarks: Int = 0 {
       didSet {
          if InternalMarks > StudMarks.markCount {
             InternalMarks = StudMarks.markCount
          }
          if InternalMarks > StudMarks.totalCount {
             StudMarks.totalCount = InternalMarks
          }
       }
    }
 }
 
 var stud1Mark1 = StudMarks()
 var stud1Mark2 = StudMarks()
 
 stud1Mark1.InternalMarks = 98
 print(stud1Mark1.InternalMarks)
 
 stud1Mark2.InternalMarks = 87
 print(stud1Mark2.InternalMarks)