属性

属性将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，而计算属性计算（不是存储）一个值。计算属性可以用于类、结构体和枚举，存储属性只能用于类和结构体。

存储属性和计算属性通常与特定类型的实例关联。但是，属性也可以直接作用于类型本身，这种属性称为类型属性。

另外，还可以定义属性观察器来监控属性值的变化，以此来触发一个自定义的操作。属性观察器可以添加到自己定义的存储属性上，也可以添加到从父类继承的属性上。

存储属性

一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量。存储属性可以是变量存储属性（用关键字var定义），也可以是常量存储属性（用关键字let定义）。可以在定义存储属性的时候指定默认值，也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值。

struct FixedLengthRange {
    var first: Int      // 变量存储属性
    let length: Int     // 常量存储属性
}
var a = FixedLengthRange(first: 10,length: 100)
a.first = 20 // a.length = 200 // error: cannot assign to property: 'length' is a 'let' constant
print(a)    // FixedLengthRange(first: 20,length: 100)

常量结构体的存储属性

如果创建了一个结构体的实例并将其赋值给一个常量，则无法修改该实例的任何属性，即使定义了变量存储属性。

由于结构体（struct）属于值类型。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。属于引用类型的类（class）则不一样。把一个引用类型的实例赋给一个常量后，仍然可以修改该实例的变量属性。

延迟存储属性

延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用lazy来标示一个延迟存储属性。

注意，必须将延迟存储属性声明成变量（使用var关键字），因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。

延迟属性很有用，当属性的值依赖于在实例的构造过程结束后才会知道具体值的外部因素时，或者当获得属性的初始值需要复杂或大量计算时，可以只在需要的时候计算它。可以利用延迟存储属性来避免复杂类中不必要的初始化。

如果一个被标记为lazy的属性在没有初始化时就同时被多个线程访问，则无法保证该属性只会被初始化一次。

/** * 一个负责将外部文件中的数据导入的类，初始化耗时。 */
class DataImporter {
   var fileName = "data.txt"
    init() {
        print("DataImporter.init() called")
    }
}

class DataManager {
    lazy var importer = DataImporter()    // 必须声明为变量
    var data = [String]()
}

let manager = DataManager()     // 当DataManager的实例被创建时，没必要创建一个DataImporter的实例，更明智的做法是第一次用到DataImporter的时候才去创建它
manager.data.append("Hello")
manager.data.append("World")
manager.data.append("!!!")
print(manager.data)
// importer属性还未创建！
// importer属性只有在第一次被访问的时候才被创建。比如访问它的属性fileName时
print(manager.importer.fileName)

/* ["Hello","World","!!!"] DataImporter.init() called data.txt */

存储属性和实例变量

如果有过Objective-C经验，应该知道Objective-C为类实例存储值和引用提供两种方法。除了属性之外，还可以使用实例变量作为属性值的后端存储。

Swift编程语言中把这些理论统一用属性来实现。Swift中的属性没有对应的实例变量，属性的后端存储也无法直接访问，这就避免了不同场景下访问方式的困扰。同时也将属性的定义简化成一个语句。属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。

计算属性

除存储属性外，类、结构体和枚举可以定义计算属性。计算属性不直接存储值，而是提供一个getter和一个可选的setter，来间接获取和设置其他属性或变量的值。

struct Point {
    var x = 0.0
    var y = 0.0
}

struct Size {
    var width = 0.0
    var height = 0.0
}

struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {     // 必须声明为变量
        get {
            return Point(x: origin.x + size.width / 2,y: origin.y + size.height / 2)
        }
        set(newCenter) {
            origin.x = newCenter.x - size.width / 2     // 修改了中心后需要重新设置原点
            origin.y = newCenter.y - size.width / 2
        }
    }
}

var r = Rect(origin: Point(x: 0.0,y: 0.0),size: Size(width: 20.0,height: 20.0))
print(r)    // Rect(origin: Point(x: 0.0,y: 0.0),size: Size(width: 20.0,height: 20.0))
let a = r.center
print(a)    // Point(x: 10.0,y: 10.0)
r.center = Point(x: 20,y: 20)
print(r)    // Rect(origin: Point(x: 10.0,y: 10.0),height: 20.0))

Rect的计算属性center提供了自定义的getter和setter来获取和设置矩形的中心点，就像它有一个存储属性一样。而当设置属性center的值时，会调用它的setter来修改属性origin的x和y的值。

便携setter声明

如果计算属性的setter没有定义表示新值的参数名，则可以使用默认名称newValue。

struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {     // 必须声明为变量
        get {
            return Point(x: origin.x + size.width / 2,y: origin.y + size.height / 2)
        }
        set {
            origin.x = newValue.x - size.width / 2     // 修改了中心后需要重新设置原点
            origin.y = newValue.y - size.width / 2
        }
    }
}

只读计算属性

只有getter没有setter的计算属性就是只读计算属性。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。

注意，必须使用var关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。let关键字只用来声明常量属性，表示初始化后再也无法修改的值。

只读计算属性的声明可以去掉get关键字和花括号。

struct Cuboid {
    var width = 0.0
    var height = 0.0
    var depth = 0.0
    var volume: Double {    // 只读计算属性
        return width * height * depth
    }
}

var a = Cuboid(width: 2,height: 3,depth: 5)
print(a.volume)
// a.volume = 100 // error: cannot assign to property: 'volume' is a get-only property

属性观察器

属性观察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新值和当前值相同的时候也不例外。

可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重写属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。

注意，不需要为非重写的计算属性添加属性观察器，因为可以通过它的setter直接监控和响应值的变化。（貌似可以访问该属性得到旧值，通过访问newValue得到新值）

可以为属性添加如下的一个或全部观察器：

• willSet在新的值被设置之前调用
• didSet在新的值被设置之后立即调用

willSet观察器会将新的属性值作为常量参数传入，在willSet的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称newValue表示。类似地，didSet观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名oldValue。

注意，父类的属性在子类的构造器中被赋值时，它在父类中的willSet和didSet观察器会被调用。

如果在一个属性的didSet观察器里为它赋值，这个值会替换之前设置的值。

class StepCounter {
    var totalSteps: Int = 0 {   // 这是存储属性，需要赋初值，否则报错：error: class 'StepCounter' has no initializers
        willSet {
            print("about to set new value: \(newValue)")
        }
        didSet {
            print("added \(totalSteps - oldValue) steps")
        }
    }
}

let s = StepCounter()
s.totalSteps = 100
s.totalSteps = 225
s.totalSteps = 225
print(s.totalSteps)
/*
about to set new value: 100
added 100 steps
about to set new value: 225
added 125 steps
about to set new value: 225
added 0 steps
225
*/

注意上面的totalSteps变量是存储属性，必须赋初值。而非重写的计算属性直接可以访问setter得到。

全局变量和局部变量

计算属性和属性观察器所描述的功能也可以用于全局变量和局部变量。全局变量是在函数、方法、闭包或任何类型之外定义的变量。局部变量是在函数、方法或闭包内部定义的变量。

全局或局部变量都属于存储型变量，跟存储属性类似，它为特定类型的值提供存储空间，并允许读取和写入。

另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义观察器。计算型变量跟计算属性一样，返回一个计算结果而不是存储值，声明格式也完全一样。

注意，全局的常量或变量都是延迟计算的，跟延迟存储属性相似，不同的地方在于，全局的常量或变量不需要标记lazy修饰符。

局部范围的常量或变量从不延迟计算。

var a: Int = 0 {        // 全局存储型变量
willSet {
    print("about to set new value: \(newValue)")
}
didSet {
    print("already set,old value: \(oldValue)")
}
}

a = 100
print(a)
a = 200
a = 200
print("==========")

var b: Int {
get {
    return 0
}
set {
    print("old value: \(b),new value: \(newValue)")
}
}

print(b)    // 全局计算型变量，计算型变量并不存储值，这里每次都return 0
b = 100
print(b)
b = 200

/*
about to set new value: 100
already set,old value: 0
100
about to set new value: 200
already set,old value: 100
about to set new value: 200
already set,old value: 200
==========
0
old value: 0,new value: 100
0
old value: 0,new value: 200
*/

类型属性

实例属性属于一个特定类型的实例，每创建一个实例，实例都拥有属于自己的一套属性值，实例之间的属性相互独立。

也可以为类型本身定义属性，无论创建了多少个该类型的实例，这些属性都只有唯一一份。这种属性就是类型属性。

类型属性用于定义某个类型所有实例共享的数据，比如所有实例都能用的一个常量（就像C语言中的静态常量），或者所有实例都能访问的一个变量（就像C语言中的静态变量）。

存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算型属性一样只能定义成变量属性。

注意，跟实例的存储型属性不同，必须给存储型类型属性指定默认值（实例的存储型属性也要吧？？？），因为类型本身没有构造器，也就无法在初始化过程中使用构造器给类型属性赋值。

存储型类型属性是延迟初始化的，它们只有在第一次被访问的时候才会被初始化。即使它们被多个线程同时访问，系统也保证只会对其进行一次初始化，并且不需要对其使用lazy修饰符。

类型属性语法

在C或Objective-C中，与某个类型关联的静态常量和静态变量，是作为全局（global）静态变量定义的。但是在Swift中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。

使用关键字static来定义类型属性。在为类定义计算型类型属性时，可以改用关键字class来支持子类对父类的实现进行重写。计算型类型属性可读也可写。

struct A {
    static var a: Int = 1   // 存储型类型属性
    static var b: Int {     // 计算型类型属性
        return 100
    }
}

enum B {
    static var a: Int = 1   // 存储型类型属性
    static var b: Int {     // 计算型类型属性
        return 100
    }
}

class C {
    static var a: Int = 1   // 存储型类型属性
    static var b: Int {     // 计算型类型属性
        return 100
    }
    class var c: Int {      // 子类重写父类的计算型类型属性
        return 200
    }
}

获取和设置类型属性的值

跟实例属性一样，类型属性也是通过点运算符来访问。但是，类型属性是通过类型本身来访问，而不能通过实例。

struct A {
    static var a: Int = 1   // 存储型类型属性
    static var b: Int {     // 计算型类型属性
        return 100
    }
}

enum B {
    static var a: Int = 1   // 存储型类型属性
    static var b: Int {     // 计算型类型属性
        return 100
    }
}

class C {
    static var a: Int = 1   // 存储型类型属性
    static var b: Int {     // 计算型类型属性
        return 100
    }
    class var c: Int {      // 子类重写父类的计算型类型属性
        return 200
    }
}

print(A.a)  // 1
A.a = 2
print(A.a)  // 2
print(A.b)  // 100

print(B.a)  // 1
B.a = 2
print(B.a)  // 2
print(B.b)  // 100

print(C.a)  // 1
C.a = 2
print(C.a)  // 2
print(C.b)  // 100
print(C.c)  // 200

/** * 文档中的声道模型，展示了如何把两个声道结合来模拟立体声的音量。 */
struct AudioChannel {
    static let thresholdLevel = 10
    static var maxInputLevelForAllChannels = 0
    var currentLevel: Int = 0 {
        didSet {
            if currentLevel > AudioChannel.thresholdLevel {
                currentLevel = AudioChannel.thresholdLevel  // 此处didSet属性观察器将currentLevel设置成了不同的值，但这不会造成属性观察器被再次调用！！！
            }
            if currentLevel > AudioChannel.maxInputLevelForAllChannels {
                AudioChannel.maxInputLevelForAllChannels = currentLevel
            }
        }
    }
}

var left = AudioChannel()   // 左声道
var right = AudioChannel()  // 右声道
left.currentLevel = 7
print(left.currentLevel)    // 7
print(AudioChannel.maxInputLevelForAllChannels)     // 7
right.currentLevel = 11
print(right.currentLevel)   // 10
print(AudioChannel.maxInputLevelForAllChannels)     // 10