Swift学习笔记-属性

• 存储属性只能用于类和结构体，计算属性可以用于类，结构体，枚举。
• 结构体的属性为var可变 但是如果结构体实例为let不可变得，则var属性也不可以修改，因为结构体是值属性。
• 必须将延时属性用var修饰。
• 计算属性必须用var修饰，因为值是不固定的。不必纠结是否像oc中重写setter一样保存新值，因为必有get方法。
• 属性观察器可以为除了延时存储属性之外的存储属性添加，即使新值和旧值相同也可以触发。
• 全局的属性都是延时计算的，不需要用lazy修饰。
• 类属性用static修饰，需要给一个初始值(因为没有构造方法)

1.存储属性

如果结构体的实例为let不可变，则其存储属性即使是可变的，也无法修改

struct FixedLengthRange {
    var firstValue: Int
    let length: Int
}
//相当于初始化方法，所以可以给不可变得length赋值
let rangeOfThreeItems = FixedLengthRange(firstValue: 2, length: 5)
rangeOfThreeItems.firstValue = 3 //这里是会报错的

如果结构体的存储属性没有默认值，则在初始化的时候可以设置let类型的初始值，否则无法改变。

2.延迟存储属性

在被访问的时候才被创建。(类似懒加载)

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

class DataImporter {
    var filename = "data.text"
    
}
class DataManager {
    var data = [String]()
    lazy var importer = DataManager()
}
let manager = DataManager()
        manager.data.append("zc")
        manager.data.append("cz")
        print(manager.importer.data) //此时importer属性才被创建

3.计算属性

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
        }
    }
}

如果set(newCenter)改为set ,则默认使用newValue表示。
只读计算属性:只能获取，不能设置,但是仍然要用var修饰，因为他不是固定不变的。

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
        return width * height * depth
    }
}

4.属性观察器

当属性被设置时会触发哪怕值不变化。(默认参数为newValue和oldValue)

class StepCounter {
    var totalSteps : Int = 0 {
        willSet(newValue){
            print(newValue)
        }
        didSet(oldValue){
            print(oldValue)
        }
    }
}

4.类型属性

类型属性相当于类属性，只有类对象可以直接改变他的值和获取它的值。

struct AudioChannel {
    static let thresholdLevel = 10
    static var maxInputLevelForAllChannels = 0
    var currentLevel: Int = 0 {
        didSet {
            if currentLevel > AudioChannel.thresholdLevel {
                // 将当前音量限制在阈值之内
                currentLevel = AudioChannel.thresholdLevel
            }
            if currentLevel > AudioChannel.maxInputLevelForAllChannels {
                // 存储当前音量作为新的最大输入音量
                AudioChannel.maxInputLevelForAllChannels = currentLevel
            }
        }
    }
}

///打印值为7
var left = AudioChannel()
        left.currentLevel = 6
        AudioChannel.maxInputLevelForAllChannels = 7
        print(AudioChannel.maxInputLevelForAllChannels)