12.Swift属性

/**属性:将值跟特定的类、结构体或枚举关联。
    存储属性：存储常量或变量作为实例的一部分，只能用于类和结构体
    计算属性：计算一个值，可以用于类、结构体和枚举。
    存储属性与计算属性通常与特定类型的实例关联，但属性也可以直接作用于类型本身，这种属性称为类型属性
    还可以定义属性观察器来监控属性值得变化，以此来触发一个自定义操作；属性观察器可以添加到自己定义存储属性上，也可以添加到从父类继承的属性a上。
 */

//==============================存储属性==============================
//存储属性：存储在特定类或结构体实例里的一个常量let或变量var，
struct FixedLengthRange{//固定长度的结构体，包含一个变量存储属性firstValue和一个常量存储属性length(起始值、长度)
    var firstValue: Int
    let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)//该区间表示：0，1，2
rangeOfThreeItems.firstValue = 5 //该区间表示：5，6，7
print(rangeOfThreeItems.firstValue,rangeOfThreeItems.length)
//如果将结构体实例赋值给一个常量，则无法修改该实例的任何属性，即使有属性被声明为变量
let rangeOfFourItems = FixedLengthRange(firstValue: 2, length: 4)
//rangeOfFourItems.firstValue = 3//会报错，因为结构体是值类型，值类型被声明为常量的时候，它的所有属性也就成了常量

//延迟存储属性：第一次被调用时才会计算其初始值的属性。在属性声明前使用lazy来标示一个延迟存储属性。
//注意：延迟存储属性必须声明成var,因为属性的初始值可能在实例构造完成之后才会得到，而let属性在构造完成之前必须要有初始值，因此无法声明成延迟属性。
class DataImporter{//这个类负责将外部文件中的数据导入，初始化时会消耗不少时间
    var fileName = "data.txt"//提供数据导入功能
}
class DataManager {//这个类负责数据管理
    lazy var importer = DataImporter() //延迟属性，在用的时候才初始化
    var data = [String]()
}
let manager = DataManager()
manager.data.append("添加一些数据")
manager.data.append("添加更多的数据")
//因为DataManager类中的 importer是延迟属性，所以此时 importer属性还没有被创建
print(manager.importer.fileName)//此时，访问了 importer属性，该属性才会被创建
//***注意：如果一个被标记为lazy的属性在没有初始化时就同时被多个线程访问，则无法保证该属性只会被初始化一次

//==============================计算属性==============================
//计算属性不直接存储值，而是提供一个getter 和一个 可选的setter 来间接获取和设置其他属性或s变量的值。
struct Point{//一个xy和结构体
    var x = 0.0, y=0.0
}
struct Size {//一个宽高的结构体
    var width = 0.0, height = 0.0
}
struct Rect {//一个有xy、宽高、中心点的结构体
    var origin = Point()
    var size = Size()
    var center: Point{//一个名为center的计算属性
        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)
//        }
        //如果计算属性的setter没有定义表示新值得参数名，则可以使用默认名称newValue
        set {
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}
var square = Rect(origin: Point(x: 0.0, y: 0.0), size: Size(width: 10.0, height: 10.0))
let initSquareCenter = square.center
square.center = Point(x: 15.0, y: 15.0)
print("square的xy为：\(square.origin.x),\(square.origin.y)，中心点为：\(initSquareCenter)---\(square.center)")
//只读计算属性:只有getter没有setter的计算属性
struct Cuboid {//计算长方体的体积
    var width = 0.0, height = 0.0, depth = 0.0 //宽、高、深
    var volume: Double{
        return width * height * depth
    }
}
let cTJ = Cuboid(width: 3, height: 4, depth: 5)
print("长方体的体积为：\(cTJ.volume)")

//==============================属性观察器==============================
/*触发调用条件：每次属性被设置值得时候都会调用属性观察器，即使新值和当前值相同的时候也不例外
 *哪些属性可以添加：可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重写属性的方式为继承的属性添加属性观察器
 *可以添加哪些观察器： willSet在新的值被设置之前调用、didSet在新的值被设置之后立即调用，属性可以添加一个或两个。
    willSet观察器：将新的属性值作为常量参数传入，在willSet的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称 newValue表示。
    didSet观察器：将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名oldValue。如果在didSet方法中d再次对该属性赋值，那么新值会覆盖旧的值。
 
 注意：父类的属性在子类的构造器中被赋值时，它在父类中的willSet和didSet观察器会被调用，随后才会调用子类的观察器。
      在父类初始化方法调用之前，子类给属性赋值时，观察器不会被调用。
 */
class StepCounter {//该类统计的是一个人的总步数
    var totalSteps: Int = 0 {//totalSteps是一个Int型的存储属性，包含一个 willSet观察器 和 一个didSet观察器
        //当totalSteps被设置新值得时候，它的willSet和DidSet都会被调用，即使新值与当前值相等
//        willSet(newTotalSteps) {//可以自定义，如果不写，默认是newValue
//            print("总步数：\(newTotalSteps)")
//        }
        willSet {
            print("总步数：\(newValue)")
        }
        didSet {//在totalSteps的值改变后被调用，可以拿到新值与旧值(不能自定义，默认为oldValue)
            if totalSteps > oldValue {
                print("新增加了：\(totalSteps - oldValue) 步")
            }
        }
    }
}
let stepCount = StepCounter()
stepCount.totalSteps = 200 //第一次 都是200步
stepCount.totalSteps = 360 //第二次 总步数360步、新增160步
stepCount.totalSteps = 699 //第三次 总步数699步、新增339步
//注意： 如果将属性通过 in-out方式传入函数，willSet和didSet也会被调用。因为in-out参数采用了拷入拷出模式：在函数内部使用的是参数的copy，函数结束后，又对参数重新赋值。

//全局变量：在函数、方法、闭包或任何类型之外定义的变量； 局部变量：在函数、方法或者闭包内部定义的变量。
//全局的常量或变量都是延迟计算的，跟延迟存储属性相似，但是全局的常量或变量不需要标记lazy修饰符；局部范围的常量或变量从不延迟计算

//==============================类型属性==============================
/*类型属性：为某个类定义一个属性，然后无论创建了多少个该类的实例对象，这个属性都只有唯一的一份，这就是类型属性。
    定义时必须给该属性指定默认值，因为类型本身没有构造器，无法再初始化过程中使用构造器给类型属性赋值。
    主要用于：定义某个类型所有实例共享的数据，比如所有实例都能用的一个常量、或者所有实例都能访问的一个变量。
    类型属性是延迟初始化的，只有在第一次被访问时才会被初始化，即使再多个线程中同时访问，系统也保证只会对其进行一次初始化，并且不需要对其使用lazy修饰符。
 */
//定义方法：使用关键字static来定义类型属性，作为类型定义的一部分，写在类型最外层的花括号内，作用范围也是在类型支持的范围内。

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 {//在为类定义计算型属性时，可以改用关键字class来支持子类对父类的实现进行重写
        return 107
    }
}
//获取和设置类型属性的值：
print(SomeStructure.storedTypeProperty)//通过点语法来访问，但不是通过实例，而是通过类型本身来访问
SomeStructure.storedTypeProperty = "修改了结构体的类型属性的值"
print(SomeStructure.storedTypeProperty)
print(SomeEnumeration.computedTypeProperty)
print(SomeClass.overrideableComputedTypeProperty)

//示例：
struct AudioChannel{
    static let thresholdLevel = 10//最大阈值
    static var maxInputLevelForAllChannels = 0 //当前设置的最大音量
    var currentLevel: Int = 0 {//存储属性currentLevel包含didSet属性观察器，来检查每次设置后的属性值
        didSet {
            if currentLevel > AudioChannel.thresholdLevel {//把当前音量限制在最大值之内
                currentLevel = AudioChannel.thresholdLevel
            }
            if currentLevel > AudioChannel.maxInputLevelForAllChannels{//如果大于之前的值，就更新该值
                AudioChannel.maxInputLevelForAllChannels = currentLevel
            }
        }
    }
}
var leftChannel = AudioChannel()//左声道
var rightChannel = AudioChannel()//右声道
leftChannel.currentLevel = 7 //将左声道的值设置为7，属性maxInputLevelForAllChannels也会更新成7
print("\(leftChannel.currentLevel)---\(AudioChannel.maxInputLevelForAllChannels)")
rightChannel.currentLevel = 11//将右声道设置为11，实际值会是10
print("\(rightChannel.currentLevel)---\(AudioChannel.maxInputLevelForAllChannels)--\(leftChannel.currentLevel)")