Swift—重写-备

=========================

重写实例属性

我们可以在子类中重写从父类继承来的属性，属性有实例属性和静态属性之分，他们在具体实现也是不同的。

实例属性的重写一方面可以重写getter和setter访问器，另一方面可以重写属性观察者。

计算静态属性需要使用getter和setter访问器，而存储属性不需要。子类在继承父类后，也可以通过getter和setter访问器重写父类的存储属性和计算属性。

下面看一个示例：

1. class Person {
2. var name: String        //存储属性
3. var age: Int            //存储属性
4. func description() -> String {
5. return "\(name) 年龄是: \(age)"
6. }
7. init (name: String, age: Int) {
8. self.name = name
9. self.age  = age
10. }
11. }
12. class Student: Person {
13. var school: String
14. override var age: Int { //重写属性前面要添加override关键字
15. get {
16. return super.age
17. }
18. set {
19. super.age = newValue < 8 ? 8: newValue
20. }
21. }
22. convenience init() {
23. self.init(name: "Tony", age: 18, school: "清华大学")
24. }
25. init (name: String, age: Int, school: String) {
26. self.school = school
27. super.init(name: name, age: age)
28. }
29. }
30. let student1 = Student()
31. print("学生年龄：\(student1.age)")
32. student1.age = 6
33. print("学生年龄：\(student1.age)")

从属性重写可见，子类本身并不存储数据，数据是存储在父类的存储属性中的。

以上示例是重写属性getter和setter访问器，我们还可以重写属性观察者，代码如下：

1. class Person {
2. var name: String
3. var age: Int
4. func description() -> String {
5. return "\(name) 年龄是: \(age)"
6. }
7. init (name: String, age: Int) {
8. self.name = name
9. self.age  = age
10. }
11. }
12. class Student: Person {
13. var school: String
14. override var age: Int {  //重写了age属性观察者
15. willSet {              //如果只关注修改之前的调用，可以只重写willSet观察者
16. print("学生年龄新值：\(newValue)")
17. }
18. didSet{                //如果只关注修改之后的调用，可以只重写didSet观察者
19. print("学生年龄旧值：\(oldValue)")
20. }
21. }
22. convenience init() {
23. self.init(name: "Tony", age: 18, school: "清华大学")
24. }
25. init (name: String, age: Int, school: String) {
26. self.school = school
27. super.init(name: name, age: age)
28. }
29. }
30. let student1 = Student()
31. print("学生年龄：\(student1.age)")
32. Student1.age = 6
33. print("学生年龄：\(student1.age)")

代码Student1.age = 6修改了age属性，修改前后的输出结果如下：

学生年龄新值：6

学生年龄旧值：18

重写静态属性

在类中静态属性定义使用class或static关键字，但是使用哪一个要看子类中是否重写该属性。class修饰的属性可以被重写，static关键字就不能被重写。

示例代码如下：

1. class Account {
2. var amount: Double = 0.0                // 账户金额
3. var owner: String = ""                   //账户名
4. var interestRate: Double = 0.0668     //利率
5. //class不能换成static
6. class var staticProp: Double {              //静态属性staticProp
7. return 0.0668 * 1_000_000
8. }
9. var instanceProp: Double {
10. return self.interestRate * self.amount
11. }
12. }
13. class TermAccount: Account {
14. //class换成static
15. override class var staticProp: Double {     //重写静态属性staticProp
16. return 0.0700 * 1_000_000
17. }
18. }
19. //访问静态属性
20. print(Account.staticProp)
21. print(TermAccount.staticProp)

由于要被重写所以代码class var staticProp: Double 中的class不能换成static。代码overrideclass var staticProp: Double中的静态属性staticProp可以使用class或static，除非在TermAccount的子类中重写属性staticProp。

================================

重写实例方法

在子类中重写从父类继承来的实例方法和静态方法。先介绍实例方法的重写。

下面看一个示例：

1. class Person {
2. var name: String
3. var age: Int
4. func description() -> String {    //实例方法
5. return "\(name) 年龄是: \(age)"
6. }
7. class func printClass() ->() {    //静态方法
8. print( "Person 打印...")
9. }
10. init (name: String, age: Int) {
11. self.name = name
12. self.age  = age
13. }
14. }
15. class Student: Person {
16. var school: String
17. convenience init() {
18. self.init(name: "Tony", age: 18, school: "清华大学")
19. }
20. init (name: String, age: Int, school: String) {
21. self.school = school
22. super.init(name: name, age: age)
23. }
24. override func description() -> String {   //重写实例方法description，重写的方法前面要添加关键字override
25. print("父类打印 \(super.description())")
26. return "\(name) 年龄是: \(age), 所在学校: \(school)。"
27. }
28. override class func printClass() ->() {   //重写静态方法printClass
29. print( "Student 打印...")
30. }
31. }
32. let student1 = student()
33. print("学生1：\(student1.description())") //调用了description方法
34. Person.printClass()
35. Student.printClass()

使用super.description()语句调用父类的description方法，其中super指代父类实例。

重写静态方法printClass，在静态方法中不能访问实例属性。

调用了description方法。由于在子类中重写了该方法，所以调用的是子类中的description方法。输出结果是：

父类打印 Tony 年龄是: 18

学生1：Tony 年龄是: 18, 所在学校: 清华大学。

为了测试静态方法重写，调用Person.printClass()语言，它是调用父类的printClass静态方法，输出结果是：

Person 打印...

调用Student.printClass()语言，它是调用子类的printClass静态方法，输出结果是：

Student 打印...

重写静态方法

与类的静态属性定义类似，静态方法使用class或static关键字，但是使用哪一个要看子类中是否重写该方法。class修饰的静态方法可以被重写，static关键字就不能被重写。

示例代码如下：

1. class Account {
2. var owner: String = "Tony"     //账户名
3. //不能换成static
4. class func interestBy(amount: Double) -> Double {         //静态方法
5. return 0.08886 * amount
6. }
7. }
8. class TermAccount: Account {//定期账户
9. //可以换成static
10. override class func interestBy(amount: Double) -> Double {    //静态方法
11. return 0.09 * amount
12. }
13. }
14. //调用静态方法
15. print(Account.interestBy(10_000.00 ))
16. print(TermAccount.interestBy(10_000.00 ))

由于被重写所以代码class funcinterestBy(amount: Double) -> Double中的class不能换成static。静态方法interestBy可以使用class或static，除非在TermAccount的子类中重写方法interestBy。

==============================================

下标是一种特殊属性。子类属性重写是重写属性的getter和setter访问器，对下标的重写也是重写下标的getter和setter访问器。

下面看一个示例：

1. class DoubleDimensionalArray {
2. let rows: Int, columns: Int
3. var grid: [Int]
4. init(rows: Int, columns: Int) {
5. self.rows = rows
6. self.columns = columns
7. grid = Array(count: rows * columns, repeatedValue: 0)
8. }
9. subscript(row: Int, col: Int) -> Int {    //定义下标
10. get {
11. return grid[(row * columns) + col]
12. }
13. set {
14. grid[(row * columns) + col] = newValue
15. }
16. }                     //定义下标
17. }
18. class SquareMatrix: DoubleDimensionalArray {
19. override subscript(row: Int, col: Int) -> Int {   //重写父类下标
20. get {
21. return super.grid[(row * columns) + col]
22. }
23. set {
24. super.grid[(row * columns) + col] = newValue * newValue
25. }
26. }
27. }
28. var ary2 = SquareMatrix(rows: 5, columns: 5)
29. for var i = 0; i < 5; i++ {
30. for var j = 0; j < 5; j++ {
31. ary2[i,j] = i + j
32. }
33. }
34. for var i = 0; i < 5; i++ {
35. for var j = 0; j < 5; j++ {
36. print("\t\t \(ary2[i,j])")
37. }
38. print("\n")
39. }

其中super.grid[(row * columns) + col]语句中使用super调用父类的grid属性。

其中super.grid[(row * columns) + col] = newValue * newValue语句是给父类的grid属性赋值。