iOS开发Swift篇—（九）属性

一、类的定义

Swift与Objective-C定义类的区别

Objective-C：一般需要2个文件，1个.h声明文件和1个.m实现文件

Swift：只需要1个.swift文件

Swift中类的定义格式

1 class 类名  {
2     // ... 属性和方法
3 }

二、属性

1.什么是属性

　　Swift中的属性（Properties），就类似于其他面向对象语言中的成员变量

2.属性的分类

按照官方文档的说明，属性可以分为以下几种

（1）存储属性（Stored Properties）

（2）计算属性（Computed Properties）

（3）类型属性（Type Properties）

3.存储属性

1）简单说明

存储属性：存储属性就是存储在对象（实例）中的一个变量或者常量

存储属性类似于其他面向对象语言中的成员变量

1 class Person {
2     var age: Int = 1
3     var height: Double = 0.0
4     let life = 1
5 }

说明：

Person类中定义了3个存储属性

2个变量存储属性：Int类型的age、Double类型的height 

1个常量存储属性：Int类型的life

系统并不会自动初始化上面的3个存储属性，需要进行手动初始化

2）存储属性的读写

　　如何读写存储属性？

　　直接通过点运算符（.），就可以读写某个对象的存储属性　　

class Person {
    var age: Int = 1
    let life = 1
}
var p = Person()
p.age = 20
println("p的生命是(p.life), p的年龄是(p.age)")

说明：

第5行：创建Person对象

第6行：给对象p的age属性赋值

第7行：访问对象p的life属性值和age属性值

3）延迟存储属性

什么是延迟存储属性？

延迟存储属性是第一次使用时才进行初始化的属性

使用@lazy来标识一个延迟存储属性

1 class Person {
2     @lazy var dog: Dog = Dog()
3 }
4 var p = Person()
5 println(p.dog)

说明：

　　执行第5行代码时，才会去初始化dog属性，才真正创建了Dog对象

延迟存储属性的使用注意：延迟存储属性必须是变量，不能是常量

延迟存储属性的好处：让某些资源用到时再去加载，避免一些不必要的资源浪费

4.计算属性

（1）什么是计算属性

跟存储属性不一样的是，计算属性不是直接存储值，而是提供get和set

get：用来取值，封装取值的过程

set：用来设值，封装设值的过程

（2）代码示例：

class Square {
    // 正方形的宽度
      var  Double = 0.0
    // 正方形的周长
      var girth: Double {
        get {
            // 周长 = 宽度 * 4
                return width * 4
        }
        set(newGirth) {
            // 宽度 = 周长 / 4
                   width = newGirth / 4
        }
    }
}

计算属性举例：

1 var s = Square()
2 s.width = 10
3 println(s.girth)
4 s.girth = 200 
5 println(s.width) 

说明：

第3行代码：调用girth属性的get，输出结果是40

第4行代码：调用girth属性的set，并且把200传递给newGirth参数

第5行代码：输出结果是50

（3）简便的set

　　set也可以不特意指定新值的参数名，新值的默认参数名叫做newValue

var girth: Double {
    get {
        return width * 4
    }
    set {
        width = newValue / 4
    }
}
s.girth = 200

说明：

　　执行第9行代码时：第6行中newValue的值就是200

（4）计算属性的使用注意

　　1）因为计算属性的值不是固定的，因此只能用var修饰计算属性，不能用let

class Square {
    var girth: Double {
        get {
            return girth
        }
        set(newGirth) {
            girth = newGirth
        }
    }
}

说明：上面的代码会引发死循环，第4行代码会引发循环调用get，第7行代码会引发循环调用set。

2）一个属性不能既是存储属性，又是计算属性

class Square {
    var girth: Double = 20.0 {
        get {
            return 10.0
        }
        set() {
            
        }
    }
}

说明：上面的代码是错误的

（5）只读计算属性

什么是只读计算属性？只提供get，没有set的计算属性

class Square {
    var  Double = 0.0
    var girth: Double {
        get {
            return width * 4
        }
    }
}
var s = Square()
s.girth = 200

说明:第10行代码会报错

　　只读计算属性的简写。只读计算属性可以省略get关键字

class Square {
    var  Double = 0.0
    var girth: Double {
        return width * 4
    }
}
var s = Square()
s.girth = 200

说明：第8行代码会报错

5.类型属性

（1）什么是类型属性？

用class关键字修饰的属性，就是类型属性，也可以称为“类属性”

class修饰的类型属性只能是计算属性，不能是存储属性

代码示例：

1 class Circle {
2     class var PI : Double  {
3         return 3.14
4     }
5 }

说明：第2行定义的属性PI，就是一个类型属性

（2）类型属性的特点

　　一个类只会有一份，类的多个实例对象都共享这唯一的一份

　　类型属性的使用：类型属性不依赖于对象而存在，因此用类名来访问

　　println(Circle.PI)

三、属性监视器

1.什么是属性监视器？

有时，需要在属性值被修改的时候做出响应，这种情况下就可以用属性监视器

属性监视器，可以监视属性值的修改过程 

　　计算属性可以直接在set中监听属性值的改变，而存储属性没有set

可以为存储属性添加willSet和didSet两个属性监视器

（1）willSet：

在设置新的属性值之前调用

会将新的属性值作为参数传入，参数名默认是newValue

（2）didSet：

在设置新的属性值之后调用

会将旧的属性值作为参数传入，参数明默认是oldValue

2.代码示例

class Square {
    var  Double = 0.0 {
        willSet {
            println("willSet---(newValue)")
        }
        didSet {
            println("didSet---(oldValue)")
        }
    }
}
var s = Square()
s.width = 10

打印结果：

willSet---10.0

didSet---0.0

3.使用注意

class Square {
    var  Double = 0.0 {
        willSet { }
        didSet { width = 20 }
    }
}
var s = Square()
s.width = 10
println(s.width)

代码说明：

willSet和didSet在属性初始化过程中不会被调用，只会当属性的值在初始化之外的地方被设置时被调用

第2行代码的初始化不会引发willSet和didSet的调用

第8行代码的赋值会引发willSet和didSet的调用

如果在didSet监视器里为属性赋值，这个值会替换之前设置的值

第4行对width属性进行了再次赋值，覆盖了第8行赋的值，因此第9行的输出结果是20

willSet、didSet和set、get不能共存