swift从零开始-11-属性

本页内容包括：

存储属性
计算属性
属性观察器
全局变量和局部变量
类型属性

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

一、存储属性

即：存储在特定类或结构体的实例里的一个常量或变量
//例子

struct LengthRanuge {
    var firstValue: Int
    let length: Int
}

var rangeOfThreeItems = LengthRanuge(firstValue: 0, length: 3)
该区间表示整数0，1，2
rangeOfThreeItems.firstValue = 6
该区间表示整数6，7，8
该结构体的实例包含一个名为firstValue的变量存储属性和一个名为length的常量存储属性。length在创建实例的时候被赋值，因为是一个常量存储属性，之后无法修改它的值。

常量和存储属性

如果创建一个结构体的实例并赋给了一个常量，则无法修改实例内的任何属性，即使是变量存储属性

let rangeOfFourItems = LengthRanuge(firstValue: 0, length: 4)
//rangeOfFourItems.firstValue = 6  
//尽管firstValue是变量属性，这里也会报错

延迟存储属性

延迟存储属性是指第一次被调用的时候才会计算器初始值的属性。在属性声明前使用lazy来标识一个延迟存储属性。必须将延迟存储属性声明为变量
//使用场所：当属性的值依赖于在实例的构造过程结束前无法知道具体指的外部因素时，或者当属性的值需要复杂或大量计算时，可以只在需要的时候来计算它。
//例:

class DataImporter {
    /*
     DataImporter 是一个将外部文件中的数据导入的类
     这个类的初始化会消耗不少时间
     */
    var fileName = "data.txt"
    //这里提供数据导入功能
}

class DataManager {
    lazy var importer = DataImporter()
    var data = String()
    //这里提供数据管理功能
}

let manager = DataManager()
manager.data += "Some data"
manager.data += "Some more data"
//DataImporter 实例的 importer 属性还没有被创建

print(manager.importer.fileName)
//DataImporter 实例的 importer 属性现在才被创建了

二、计算属性

计算属性不直接存储值，而是提供一个getter来获取值，一个可以选择的setter来间接设置其他属性或变量的值
//例:

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

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

struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + size.width/2
            let centerY = origin.y + size.height/2
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {
            origin.x = newCenter.x - size.width/2
            origin.y = newCenter.y - size.height/2
        }
    }
}

var square = Rect(origin: Point.init(x: 0.0, y: 0.0), size: Size(width: 10.0, height: 10.0))
let initialCenter = square.center
print(initialCenter.x, initialCenter.y)
square.center = Point(x: 15.0, y: 15.0)
print(square.center.x, square.center.y)

只读计算属性

只有geter没有setter的计算属性就是制度计算属性。只读计算属性总是返回一个值，可以通过点运算符来访问，但不能设置新的值
只读计算属性的声明可以去掉get关键字

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
        return width * height * depth
    }
}
let vol = Cuboid(width: 4, height: 7, depth: 6)
print(vol.volume)

三、属性监视器

定义：属性监视器监控和响应属性值的变化，每次属性被设置值得时候都会被调用属性监视器。

添加属性监视器
willSet 在设置新的值之前调用
didSet 在新的值被设置之后立即调用
willSet会将新的属性值作为常量参数传入，在willSet的实现代码中可以为这个参数指定一个名称，如果不指定则参数默认名称为 newValue 表示
类似的，didSet 会将旧的属性值作为参数传入，可以命名或者使用默认参数名 oldValue

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("about to set totalSteps to \(newTotalSteps)")
        }
        didSet {
            if  totalSteps > oldValue {
                print("added \(totalSteps - oldValue) steps")
            }
        }
    }
}
let stepCounter = StepCounter()
stepCounter.totalSteps = 200
//about to set totalSteps to 200
//added 200 steps

stepCounter.totalSteps = 360
//about to set totalSteps to 360
//added 160 steps

stepCounter.totalSteps = 400

四、全局变量和局部变量

• 全局变量：是在函数，方法，闭包或任何类型之外定义的变量
• 局部变量：是在函数，方法或闭包内部定义的变量
  PS：全局的常量或变量都是延迟计算的，跟延迟存储属性相似，不过不用标记为lazy特性

五、类型属性

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

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        //这里返回一个 Int 值
        return 9
    }
}

enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        //这里返回一个 Int 值
        return 8
    }
}

class SomeClass {
    static var storedTypeProperty = "Some value."
    class var computedTypeProperty: Int {
        return 7
    }
    class var overrideableComputedTypeProperty: Int {
        return 11
    }
}

获取和设置类型属性的值

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

print(SomeStructure.storedTypeProperty)
print(SomeEnumeration.computedTypeProperty)
print(SomeClass.computedTypeProperty)