Swift学习笔记—— 属性

定义一个属性

struct FixedLengthRange{
    var firstValue:Int
    let length:Int
}
// FixedLengthRange这个类里面有两个属性，一个为 firstValue:Int 为可变类型，另外一个为 length 为不可变类型

// 属性赋值
var rangeofThreeItems =  FixedLengthRange(firstValue: 0,length: 3)  // println: { firstValue 0,length 3}

rangeofThreeItems.firstValue = 6  // println: {firstValue 6,length 3}

//rangeofThreeItems.length = 10 // 这里是错误的,length在创建实例的时候被赋值，因为它是一个常量存储属性，所以之后无法修改它的

// 结构体无论是 let 还是 var 都是可以修改为 var 的属性
let rangeofFourtems = FixedLengthRange(firstValue: 0,length: 3)
// println :{firstValue 0,length 3}

rangeofThreeItems.firstValue = 6  // println :{firstValue 6,length 3}

延迟属性

// 延迟存储属性是指当第一次调用的时候才会计算其初始值的属性。在属性声明前使用 lazy 来标记一个延迟存储属性

class DataImporter {
    /* DataImporter是一个将外部文件中的数据导入的类，反正就是一个耗时操作的类 */
    var fileName = "some thing importer handle"
    // 这是提供数据导入功能
}

class DataManager {

    lazy var importer = DataImporter()
    var data = [String]() // 初始值为一个空字符串（String）数组
    // 这是提供数据管理功能
}

var manager = DataManager()
manager.data.append("some data")
manager.data.append("some more data")
// DataManager也可能不从文件中导入数据。所以当DataManager的实例被创建时，没必要创建一个DataImporter的实例，更明智的是当用到DataImporter的时候才去创建它。
// 那么这个时候就要用到 lazy 了，由于使用了 lazy，importer 属性只有再第一次被访问的时候才会被创建。比如它的属性 fileName
println(manager.importer.fileName)
// DataImporter 实例的 importer 属性现在被创建了

Get 和 Set 方法

// 如果设置了属性的 set 方法，那么属性必须也要设置 get 方法 ，但是只有 get 方法的时候可不设置 set 方法，这个时候这个属性为只读属性

// 以下这个实例是一个视图中的Rect，Rect 具有原点origin，大小size，和中点
center
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{ // 在用构造器设置origin和size的时候center 已经有值了
            let centerX = origin.x + size.width / 2.0
            let centerY = origin.y + size.width / 2.0
            return Point(x: centerX,y: centerY)
        }
        set{ // 如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称newValue
            origin.x = newValue.x - size.width / 2.0
            origin.y = newValue.y - size.width / 2.0
        }
    }
}

var square = Rect(origin: Point(x: 0.0,y: 0.0),size: Size(width: 10.0,height: 10.0))  // Println: {{x 0,y 0},{width 10,height 10}}
println("(square.center.x)") // Println: 5.0

let initialSquareCenter = square.center //第一次调用 get 方法
// Println: {x 5,y 5}

square.center = Point(x: 15.0,y: 15.0) // 第一次调用 set 方法 
// Println: {{x 10,y 10},height 10}}

println("(square.center.x)")  // Println: "15.0"

只读计算属性

// 只有 getter 没有 setter 的计算属性就是只读计算属性。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
struct Cuboid{
    var width = 0.0,height = 0.0,depth = 0.0
    var volume:Double{
        get{
            return width * height * depth
        }
    }

}

let fourByFiveByTwo = Cuboid(width: 4.0,height: 5.0,depth: 8.0)

//fourByFiveByTwo.volume = 160 // 只有 get 方法没有 set 方法的属性为 readOnly 属性，不能更改这个属性的值，例子中的volume不能更改它的值

println("(fourByFiveByTwo.volume)")  // println ： 160

// KVC 值变换观察

// 以下这个实例是走路的实例，totalSteps 为总共走了多少步
class StepCounter {
    var totalSteps:Int = 0{
        willSet{
            // willSet 这个观察器只是简单的将新的值输出,并不能在 willSet 方法中更改totalSteps的值
            println("About to set totalSteps to (newValue)")
        }
        didSet{
            if totalSteps > oldValue{
                // 如果在didSet观察器里为属性赋值，这个值会替换观察器之前设置的值。
                totalSteps += 10
                println("Added(totalSteps - oldValue) step")
            }
        }
    }
}

// willSet和didSet观察器在属性初始化过程中不会被调用，它们只会当属性的值在初始化之外的地方被设置时被调用。
// willSet在设置新的值之前调用
// didSet在新的值被设置之后立即调用

let stepCounter = StepCounter()
stepCounter.totalSteps = 200 // 先调用 willSet 后再调用 didSet
//println: {totalSteps 210}
stepCounter.totalSteps = 360
// println :{totalSteps 370}
stepCounter.totalSteps = 896
// println:{totalSteps 906}

类型属性

// 在 Swift 编程语言中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
// 使用关键字static来定义值类型的类型属性，关键字class来为类（class）定义类型属性。下面的例子演示了存储型和计算型类型属性的语法：

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

    }
}

enum SomeEnumeration {
    static var storeTypeProperty = "some value."
    static var computedTypeProperty:Int{
        // 这里返回一个 Int 值

    }
}

class SomeClass {
    class var computedTypePorperty:Int {
        // 这里返回一个 Int 值

    }
}

// 例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟实例计算属性的语法类似。

// 跟实例属性一样，类型属性的访问也是通过点运算符来进行，但是类型属性是通过类型本身来获取设置的，而不是通过实例
println(SomeClass.computedTypePorperty)
println(SomeStructure.storedTypeProperty)
SomeStructure.storedTypeProperty = "Another value."
println(SomeStructure.storedTypeProperty)

// 以下实例是模仿音频中的左右声道，声道最大值为10，最少值为0,currentValue为当前值，可变
struct AudioChannel {
    static let maxValue = 10
    static var minValue = 0
    var currentValue: Int = 0{
        didSet {
            if currentValue > AudioChannel.maxValue{
                currentValue = AudioChannel.maxValue
            }

            if currentValue > AudioChannel.minValue{
                AudioChannel.minValue = currentValue
            }
        }
    }
}

var leftChannel = AudioChannel() // currentValue = 0
var rightChannel = AudioChannel() // currentValue = 0

// 当 currentValue 为7的时候，AudioChannel.minValue的值也为7
leftChannel.currentValue = 7 
println(leftChannel.currentValue) // println: 7
println(AudioChannel.minValue)  // println: 7

// 当 currentValue 为13的时候，超过了10，默认为 AudioChannel.maxValue的值，即为10
rightChannel.currentValue = 13
println(rightChannel.currentValue) // println: 10
println(AudioChannel.minValue)  // println: 10