Swift-重写-override

//定义一个基类

class Vehicle {

   var numberOfWheels: Int

   var maxPassengers: Int

   func description() -> String {

        return "\(numberOfWheels)wheels; up to \(maxPassengers) passengers"

    }

   init(){

        numberOfWheels = 0

        maxPassengers = 1

    }

}

 

//=====重写方法=====

class Car: Vehicle {

   var speed: Double = 0.0

    override init() {

       super.init()

        numberOfWheels = 4

        self.maxPassengers = 10

        super.maxPassengers = 20

        maxPassengers = 5 //继承了父类的属性，因此self.maxPassengers、 super.maxPassengers、maxPassengers都是指car的属性

    }

    override func description() -> String {//重写了方法

        return super.description() + "; " + "travelling at \(speed)mph"

    }

   func des1() -> String{

       return self.description()

    }

   func des2() -> ()->String {

        return self.description

    }

   func des3() {

       self.description()

    }

   func desc4()->String{

        return "self = \(self.maxPassengers),super = \(super.maxPassengers),maxPassengers = \(maxPassengers)"

    }

    

}

let car0 = Car()

car0.maxPassengers  //5

car0.numberOfWheels //4

car0.description()

car0.des1()

let dd = car0.des2()

car0.des2()() //4 wheels; up to 5 passengers; travelling at 0.0 mph

dd()//4 wheels; up to 5 passengers;travelling at 0.0 mph

car0.desc4()

 

 

 

//重写属性

//子类并不知道继承来的属性是储值型还是算值型，它只知道继承来的属性有一个名字和类型，所以在重写属性时必须把它的名字和类型都写出来

//储值属性可以重写为算值属性

//只读可以重写为读写；读写不能重写为只读

//不想重写getter，可以直接返回super.Someproperty

 

class SpeedLimitedCar:Car {

    override varspeed : Double { //重写了父类的属性speed，因此self和super的speed是两个不同的属性

       get {

           return super.speed

       }

       set {

           super.speed = min(newValue, 40.0)

       }

    }

   func CompareSpeed() -> String {

        return "super = \(super.speed), self = \(self.speed)"

    }

}

let Scar0 = SpeedLimitedCar()

Scar0.speed = 60.0

Scar0.description()

Scar0.CompareSpeed() //super=40.0 self=40.0

 

class UnLimitedCar: SpeedLimitedCar {

   override var speed : Double {

       get {

           println("speed0 = \(super.speed)")

           return super.speed + 10.0

       }

       set {

           println("speed1 = \(super.speed)")

           super.speed = newValue + 5.0

           println("speed2 = \(super.speed)")

       }

    }

}

let Ucar0 = UnLimitedCar()

Ucar0.speed = 20.0

Ucar0.description() //35.00

Ucar0.CompareSpeed()//super=25.0,self=35.0

 

//重写属性观察器

//可以为继承来的变量储值属性添加属性观察器

//可以值重写didSet或willSet

class AutomaticCar: Car {

   var gear = 1

   override var speed: Double {

       didSet{

           gear = Int(speed / 10.0) + 1

       }

    }

   override func description() -> String {

       return super.description() + " in gear \(gear)"

    }

}

 

let automatic = AutomaticCar()

automatic.speed = 50

automatic.description() //........travelling at 50.0 mph in gear 6

 

 

//防止重写

//通过把方法、属性或下标标记为final来防止它们被重写

//在扩展中，添加到类里的方法、属性或下标也可以在扩展的定义里标记为final

//可以在class前添加final来将整个定义为不能重写，这样的类是不可继承的