Swift—重写-备

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

重写实例属性

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

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

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

下面看一个示例：

class Person {



    var name: String        //存储属性

    var age: Int            //存储属性



    func description() -> String {

        return "(name) 年龄是: (age)"

    }



    init (name: String, age: Int) {

        self.name = name

        self.age  = age

    }

}



class Student: Person {



    var school: String



    override var age: Int { //重写属性前面要添加override关键字

        get {

         return super.age

        }

        set {

         super.age = newValue < 8 ? 8: newValue

        }

    }



    convenience init() {

        self.init(name: "Tony", age: 18, school: "清华大学")

    }



    init (name: String, age: Int, school: String) {

        self.school = school

        super.init(name: name, age: age)

    }

}



let student1 = Student()

print("学生年龄：(student1.age)")

student1.age = 6

print("学生年龄：(student1.age)")

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

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

class Person {



    var name: String

    var age: Int



    func description() -> String {

        return "(name) 年龄是: (age)"

    }



    init (name: String, age: Int) {

        self.name = name

        self.age  = age

    }

}



class Student: Person {



    var school: String



    override var age: Int {  //重写了age属性观察者

     willSet {              //如果只关注修改之前的调用，可以只重写willSet观察者

         print("学生年龄新值：(newValue)")



     }

     didSet{                //如果只关注修改之后的调用，可以只重写didSet观察者

         print("学生年龄旧值：(oldValue)")

     }

    }



    convenience init() {

        self.init(name: "Tony", age: 18, school: "清华大学")

    }



    init (name: String, age: Int, school: String) {

        self.school = school

        super.init(name: name, age: age)

    }

}



let student1 = Student()

print("学生年龄：(student1.age)")

Student1.age = 6

print("学生年龄：(student1.age)")

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

学生年龄新值：6

学生年龄旧值：18

 

重写静态属性

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

示例代码如下：

class Account {



    var amount: Double = 0.0                // 账户金额

    var owner: String = ""                   //账户名



    var interestRate: Double = 0.0668     //利率



    //class不能换成static

    class var staticProp: Double {              //静态属性staticProp

        return 0.0668 * 1_000_000

    }



    var instanceProp: Double {

        return self.interestRate * self.amount

    }

}



class TermAccount: Account {



    //class换成static

    override class var staticProp: Double {     //重写静态属性staticProp

        return 0.0700 * 1_000_000

    }

}



//访问静态属性

print(Account.staticProp)

print(TermAccount.staticProp)

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

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

重写实例方法

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

下面看一个示例：

 

class Person {

    var name: String
    var age: Int

    func description() -> String {    //实例方法
        return "(name) 年龄是: (age)"
    }

    class func printClass() ->() {    //静态方法
        print( "Person 打印...")
    }

    init (name: String, age: Int) {
        self.name = name
        self.age  = age
    }
}

class Student: Person {

    var school: String

    convenience init() {
        self.init(name: "Tony", age: 18, school: "清华大学")
    }

    init (name: String, age: Int, school: String) {
        self.school = school
        super.init(name: name, age: age)
    }

    override func description() -> String {   //重写实例方法description，重写的方法前面要添加关键字override
      print("父类打印 (super.description())")
      return "(name) 年龄是: (age), 所在学校: (school)。"
    }

    override class func printClass() ->() {   //重写静态方法printClass
        print( "Student 打印...")
    }
}

let student1 = student()
print("学生1：(student1.description())") //调用了description方法

Person.printClass()
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关键字就不能被重写。

示例代码如下：

 

class Account {

    var owner: String = "Tony"     //账户名

    //不能换成static
    class func interestBy(amount: Double) -> Double {         //静态方法
        return 0.08886 * amount
    }
}

class TermAccount: Account {//定期账户

    //可以换成static
    override class func interestBy(amount: Double) -> Double {    //静态方法
        return 0.09 * amount
    }
}

//调用静态方法
print(Account.interestBy(10_000.00 ))
print(TermAccount.interestBy(10_000.00 ))

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

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

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

下面看一个示例：

class DoubleDimensionalArray {
    let rows: Int, columns: Int
    var grid: [Int]
    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        grid = Array(count: rows * columns, repeatedValue: 0)
    }
    subscript(row: Int, col: Int) -> Int {    //定义下标
        get {
            return grid[(row * columns) + col]
        }

        set {
            grid[(row * columns) + col] = newValue
        }
    }                     //定义下标

}

class SquareMatrix: DoubleDimensionalArray {

    override subscript(row: Int, col: Int) -> Int {   //重写父类下标

        get {

            return super.grid[(row * columns) + col]

        }

        set {

            super.grid[(row * columns) + col] = newValue * newValue
        }

    }
}

var ary2 = SquareMatrix(rows: 5, columns: 5)

for var i = 0; i < 5; i++ {
    for var j = 0; j < 5; j++ {
        ary2[i,j] = i + j
    }
}

for var i = 0; i < 5; i++ {
    for var j = 0; j < 5; j++ {
        print("		 (ary2[i,j])")
    }
    print("
")
}

 

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

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