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

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

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

一、存储属性

存储属性，就是类或结构体的成员变量或者常量

struct Phone {
    var price : Float
    let brand : String
    //这两个都是存储属性，一个是常量一个是变量
}
var phone1 = Phone(price: 999, brand: "xiaomi1")
let phone2 = Phone(price: 1799, brand: "xiaomiNote")
//phone1是变量结构体实例
//phone2是常量结构体实例
phone1.price = 888
//brand 是常量属性，无论结构体实例是变量实例还是常量实例，brand都不可变
//由于phone2是常量实例，所以它的属性，无论是变量还是常量，都不可变

如果结构体换成类呢：

class Phone1 {
    var price : Float
    let brand : String
    init () {
        price = 10.0
        brand = "xiaomi"
    }
}

var phone3 = Phone1()
let phone4 = Phone1()
print("(phone3.price), (phone3.brand)")
//10.0, xiaomi
phone4.price = 100
//phone4.brand = "red mi"   //不能改
//不是说phone4是常量实例吗，属性值怎么可以改？   
//其实说白了还是值类型和引用类型的区别，类是引用类型，phone4定义为常量是不能修改，即不能 phone4 = phone3  这样是不可以的，但是let对类的属性并不影响

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

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

func complexCompute() -> Int {
    //这里假设10是经过大量复杂计算所得到的结果
    return 10
}
class MathCompute {
    lazy var computeResult = complexCompute()
    var x = 10
}
//这里创建MathCompute对象后如果不访问computeResult属性，就不会调用复杂函数去计算属性值，只有在第一次访问computeResult的时候才去计算初始值，其它属性则是在创建对象的时候就计算初始值

二、计算属性

计算属性不直接存储值，⽽是提供⼀个 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  //此时会调用get
square.center = Point(x: 15.0, y: 15.0)  //此时会调用set
print("square.origin is now at ((square.origin.x), (square.origin.y))")
//"square.origin is now at (10.0, 10.0)”

便捷 setter 声明
如果计算属性的 setter 没有定义表⽰新值的参数名，则可以使⽤默认名称 newValue  。下⾯是使⽤了便捷 setter 声明的 Rect  结构体代码：

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。只读计算属性也可以去掉get和{}。

三、属性观察器

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

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

注意：
不需要为⾮重载的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。

可以为属性添加如下的⼀个或全部观察器：
willSet  在新的值被设置之前调⽤
didSet  在新的值被设置之后⽴即调⽤

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

注意：
⽗类的属性在⼦类的构造器中被赋值时，它在⽗类中的 willSet  和 didSet  观察器会被调⽤。

class Dog {
    var dogName : String = "littledog" {
        willSet(newDogName) { //设置之前调用
            print("old dog name is (dogName) ,and the new dog name is (newDogName)")
        }
        didSet {  //设置之后调用
            print("new dog name is (dogName)")
        }
    }
}
var dog1 = Dog()
dog1.dogName = "bigDog"
//old dog name is littledog ,and the new dog name is bigDog
//new dog name is bigDog

class LittleDog: Dog {
    
    override init() {
        super.init()
        self.dogName = "---this is little dog---"
    }
}
var littleDog1 = LittleDog()   //⽗类的属性在⼦类的构造器中被赋值时，它在⽗类中的 willSet 和 didSet 观察器会被调⽤。
//old dog name is littledog ,and the new dog name is ---this is little dog---
//new dog name is ---this is little dog---

注意：
如果在⼀个属性的 didSet  观察器⾥为它赋值，这个值会替换该观察器之前设置的值。

四、全局变量和局部变量

计算属性和属性观察器所描述的模式也可以⽤于全局变量和局部变量。

全局变量是在函数、⽅法、闭包或任何类型之外定义的变量。局部变量是在函数、⽅法或闭包内部定义的变量。

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

注意：
全局的常量或变量都是延迟计算的，跟延迟存储属性相似，不同的地⽅在于，全局的常量或变量不需要标记 lazy  特性。
局部范围的常量或变量不会延迟计算。

五、类型属性

实例的属性属于⼀个特定类型实例，每次类型实例化后都拥有⾃⼰的⼀套属性值，实例之间的属性相互独⽴。

还可以为类型本⾝定义属性，不管类型有多少个实例，这些属性都只有唯⼀⼀份。这种属性就是类型属性。

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

注意：

跟实例的存储属性不同，必须给存储型类型属性指定默认值，因为类型本⾝⽆法在初始化过程中使⽤构造器给类型属性赋值。

类型属性语法：

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
    }
}
//关键字 class  来⽀持⼦类对⽗类的实现进⾏重写
class SubSomeClass: SomeClass {
    override class var overrideableComputedTypeProperty: Int {
        return 1077
    }
}
print(SomeClass.storedTypeProperty)
print(SomeClass.computedTypeProperty)
print(SomeClass.overrideableComputedTypeProperty)
print(SubSomeClass.overrideableComputedTypeProperty)
//Some value.
//27
//107
//1077