属性
属性将值与特定的类、结构体或枚举相关联，分为存储型属性和计算型属性。存储型属性将常量和变量值存储为实例的一部分，计算型属性存储值。计算型属性可由类、结构体和枚举提供，存储型属性仅由类和结构体提供。
可以定义属性观察器来监听值的更改，也可以自定义操作响应。属性观察器可以添加到存储型属性中，也可以添加到子类从其超类继承的属性。
存储型属性
存储型属性是作为特定类或结构的实例的一部分存储的常量或变量。可以提供默认值，也可以在初始化期间设置和修改存储型属性的初始值，即便是常量属性也可如此。
struct FixedLengthRange {
var firstValue: Int
let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
// the range represents integer values 0, 1, and 2
rangeOfThreeItems.firstValue = 6
// the range now represents integer values 6, 7, and 8
常量结构体实例的存储型属性
若创建一个结构体实例并将其分配给常量，即便结构体属性为变量，也不能修改该实例的属性。
let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// this range represents integer values 0, 1, 2, and 3
rangeOfFourItems.firstValue = 6
// this will report an error, even though firstValue is a variable property
由于结构体是值类型，当值类型的实例被标记为常量时，其所有属性都被标记为常量。
而类是引用类型，当引用类型的实例分配给变量时，仍然可以修改该实例的变量属性。
延迟存储型属性
延迟存储型属性是其初始值在第一次使用之前不会被计算，且必须声明为变量var，在声明属性前添加lazy关键字。
当有以下情况时将存储型属性声明为延迟属性：
- 属性的初始值在实例初始化之前无法确定
- 属性的初始值设置复杂或计算昂贵
以下为使用延迟属性来避免复杂类不必要的初始化：
class DataImporter {
/*
DataImporter is a class to import data from an external file.
The class is assumed to take a nontrivial amount of time to initialize.
*/
var filename = "data.txt"
// the DataImporter class would provide data importing functionality here
}
class DataManager {
lazy var importer = DataImporter()
var data = [String]()
// the DataManager class would provide data management functionality here
}
let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")
// the DataImporter instance for the importer property has not yet been created
DataManager类有一个DataImporter类提供的从文件中导入数据的功能，DataImporter类初始化时需要打开文件并将内容读入内存。首先，该过程需要耗费初始化时间，此外，DataManager类用来管理数据而无需从文件导入数据。所以importer属性在首次使用DataImporter实例时才使用更具意义。
print(manager.importer.filename)
// the DataImporter instance for the importer property has now been created
// Prints "data.txt"
注意
延迟属性是线程不安全的，当尚未初始化的延迟属性同时被多个线程访问，不能保证该属性仅被初始化一次。
计算型属性
类、结构体和枚举可以定义计算型属性，计算型属性不存储值，提供一个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(x: 0.0, y: 0.0),
size: Size(width: 10.0, height: 10.0))
let initialSquareCenter = square.center
square.center = Point(x: 15.0, y: 15.0)
print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
// Prints "square.origin is now at (10.0, 10.0)"
Rect结构体有一个名为center的计算型属性，其值由结构体属性origin和size确定，在其getter方法中定义这种确定关系，而其setter方法可同时改变origin属性值。
setter声明简写
若计算型属性的setter未定义要设置的新值的名称，则使用默认名称newValue。
struct AlternativeRect {
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 {
origin.x = newValue.x - (size.width / 2)
origin.y = newValue.y - (size.height / 2)
}
}
}
只读计算型属性
只有getter而没有setter方法的计算型属性为只读计算型属性。只读计算型属性始终返回一个值，只能通过点语法访问，而无法设置其值。
注意
计算型属性(包括只读计算型属性)必须声明为变量var，因为其值不是固定的。常量let属性则表示其值被初始化后无法修改。
只读计算型属性可以忽略get关键字和大括号以简化声明：
struct Cuboid {
var width = 0.0, height = 0.0, depth = 0.0
var volume: Double {
return width * height * depth
}
}
let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
// Prints "the volume of fourByFiveByTwo is 40.0"
属性观察器
属性观察器监听并响应属性值的变化，即便新值与当前值相同，在每次设置属性值时也会调用属性观察器。
除延迟属性外的任何存储型属性都可以设置属性观察器，也可以通过重写子类属性将属性观察器添加到任何继承属性(无论是存储型还是计算型属性)。非重写计算型属性无法添加属性观察器，因为可以通过计算型属性的setter来观察和响应其值的改变。
根据实际情况定义以下属性观察器中的一个或两个：
- willSet在存储该前调用
- didSet在存储新值后立即调用
若实现willSet观察器，新属性值作为常量参数传入，该值在未指定名称的情况下默认为newValue。
若实现didSet观察器，旧属性值作为常量参数传入，该值在未指定名称的情况下默认为oldValue。
注意
在调用超类初始化器后，并在子类初始化器设置属性时，会调用超类属性的willSet和willSet，它们在类调用超类初始化器之前设置属性值则不会被调用。
以下为一个跟踪步行总步数的StepCounter类，该类可能与计步器输入数据一起使用：
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 = 896
// About to set totalSteps to 896
// Added 536 steps
类型属性
实例属性是属于特定类型实例的属性，每次创建该类型的新实例时，它都有一个与其他实例分开的自己的一组属性值。
而类型属性是只属于类型本身的属性值，不是该类型的任何一个实例。无论创建多少个该类型的实例，该类型属性只有一个副本。
类型属性可用于定义通用于特定类型的所有实例的值，如所有实例都可使用的常量属性(C中的静态常量)或存储对该类型实例全局共有的变量属性(C中的静态变量)。
存储类型属性可以是变量或常量。 计算类型属性始终声明为可变属性，与计算的实例属性相同。
注意
与存储型实例属性不同，由于类型本身没有初始化器，必须给存储型类型属性设置默认值，也可以在实例初始化时为该属性赋值。
存储型类型属性在其第一次访问时被延迟初始化，即时同时被多个线程访问，也能保证只被初始化一次，且不需要用lazy修饰符标记。
类型属性语法
使用static关键字定义类型属性，对于类类型的计算型类型属性，可使用class关键字允许子类重写超类的实现。
struct SomeStructure {
static var storedTypeProperty = "Some value."
static var computedTypeProperty: Int {
return 1
}
}
enum SomeEnumeration {
static var storedTypeProperty = "Some value."
static var computedTypeProperty: Int {
return 6
}
}
class SomeClass {
static var storedTypeProperty = "Some value."
static var computedTypeProperty: Int {
return 27
}
class var overrideableComputedTypeProperty: Int {
return 107
}
}
查询和设置类型属性
使用点语法查询和设置类型属性，但类型属性是在类型本身被查询和设置，而不是在类型实例上。
print(SomeStructure.storedTypeProperty)
// Prints "Some value."
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// Prints "Another value."
print(SomeEnumeration.computedTypeProperty)
// Prints "6"
print(SomeClass.computedTypeProperty)
// Prints "27"
下面为音频频道的结构体示例：
struct AudioChannel {
static let thresholdLevel = 10
static var maxInputLevelForAllChannels = 0
var currentLevel: Int = 0 {
didSet {
if currentLevel > AudioChannel.thresholdLevel {
// cap the new audio level to the threshold level
currentLevel = AudioChannel.thresholdLevel
}
if currentLevel > AudioChannel.maxInputLevelForAllChannels {
// store this as the new overall maximum input level
AudioChannel.maxInputLevelForAllChannels = currentLevel
}
}
}
}
var leftChannel = AudioChannel()
var rightChannel = AudioChannel()
leftChannel.currentLevel = 7
print(leftChannel.currentLevel)
// Prints "7"
print(AudioChannel.maxInputLevelForAllChannels)
// Prints "7"
rightChannel.currentLevel = 11
print(rightChannel.currentLevel)
// Prints "10"
print(AudioChannel.maxInputLevelForAllChannels)
// Prints "10"