Swift的继承

一、继承（Inheritance）

1、值类型：枚举、结构体不支持继承，只有类支持继承。
2、没有父类的类称为基类
Swift并没有类似于Java、C++、OC那样的规定，即：任何类都要继承自某个基类。
3、子类可以重写父类的下标、方法和属性，但是必须添加override关键字。

二、重写实例方法、下标

1、创建Animal类以及方法。

class Animal {
    func speak() {
        print("Animal speak")
    }
    func eat() {
        print("Animal eat")
    }
    func sleep() {
        print("Animal sleep")
    }
}

2、创建Dog继承Animal，并重写父类方法。

class Dog : Animal {
    override func speak() {
        super.speak()
        print("Dog speak")
    }
    override func eat() {
        super.speak()
        super.eat()
        print("Dog eat")
    }
    func run() {
        print("Dog run")
    }
    
    override subscript(index:Int) -> Int{
        return super[index]+1
    }
}

三、重写类型方法

class Animal {
   class func speak() {
        print("Animal speak")
    }
  class  func eat() {
        print("Animal eat")
    } 
}

class Animal {
  override class func speak() {
        print("Animal speak")
    }
  override class  func eat() {
        print("Animal eat")
    } 
}

四、重写属性

1、子类可以将父类的属性（存储、计算）重写成计算属性。

2、子类重写的属性的权限必须大于等于父类属性的权限，不能小于父类的权限，否则报错。

a.父类的属性权限是只读的，子类可以是只读的也可以是读写的。
b.父类属性的权限是读写的，子类的权限不可以使只读的。

3、子类不可将父类属性重写为存储属性。

4、子类不可以重写let修饰的属性，必须是var修饰的属性。

5、重写时，属性名和类型必须一致。

• a.设置父类的属性为只读的和读写的。

class Circle {
    var radius: Int = 0
    var diameter: Int {
        set {
            print("Circle setDiameter")
            radius = newValue / 2
        }
        get {
            print("Circle getDiameter")
            return radius * 2
        }
    }
}

• b、子类重写父类的属性，此处都写为可读可写。

class SubCircle : Circle {
    override var radius: Int {
        set {
            print("SubCircle setRadius")
            super.radius = newValue > 0 ? newValue : 0
        }
        get {
            print("SubCircle getRadius")
            return super.radius
        }
    }
    override var diameter: Int {
        set {
            print("SubCircle setDiameter")
            super.diameter = newValue > 0 ? newValue : 0
        }
        get {
            print("SubCircle getDiameter")
            return super.diameter
        }
    }
}

五、重写类属性

1、被class修饰的计算属性可以被重写。
2、被static修饰的类型属性，不可以被重写。

class Cricle {
    static var radius: Int = 0
    class var diameter: Int {
        set(newValues){
          print("Circle setDiameter")
          radius = newValues / 2
        }
        get{
            print("Circle getDiameter")
            return radius * 2
        }        
    }
}

重写后：

class SubCircle: Circle {
        override static var diameter : Int {
            set(newValues){
                 print("Circle setDiameter")
                super.diameter = newValues > 0 ? newValues : 0
             }
             get{
                 print("Circle getDiameter")
                return super.radius * 2
             }        
    }
}

六、属性观察器

可以在子类中为父类添加属性观察器。

class Cricle {
    var radius: Int = 0
}

class SubCircle: Circle {
    override var radius: Int {
        willSet {
           print("SubCircle willSetRadius",newValue)
        }
        didSet{
           print("SubCircle didSetRadius",oldValue,radius)
        }        
    }
}

七、final（最终）

1、被final修饰的属性禁止被重写。
2、被final修饰的类禁止被重写。