Swift——继承

 

值类型(枚举、结构体) 不支持继承、只有类支持继承 。 子类可以重写父类的下标、方法、属性，重写必须加上override关键字

被final 修饰的方法、下标、属性 ，禁止被重写

被final 修饰的类，禁止被继承

一、重写属性

 1、子类可以将父类的属性(存储、计算)重写为计算属性

 2、子类不可以将父类属性重写为存储属性

 3、只能重写var属性，不能重写let属性

 4、重写时，属性名、类型要一致

 5、子类重写后的属性权限不能小于父类属性的权限

   如果父类属性是只读的，那么子类重写后的属性可以是只读的，也可以是可读写的。

   如果父类属性是可读写的，那么子类重写后的属性也必须是可读写的。

1、重写实例属性

class Circle {
    var radius: Int = 0
    var diameter: Int {
        set {
            radius = newValue / 2
        }
        get {
            return radius * 2
        }
    }
    var name: String  {
        get {
            return "Haha"
        }
    }

}

class SubCircle :Circle {
    override var radius: Int {
        set {
           print("")
        }
        get {

            return diameter / 2
        }
    }

    override var name: String {
        set {
            print("")
        }
        get {
            return "haha"
        }
    }
}

2、重写类型属性

被 class 修饰的计算类型属性，可以被子类重写

被 static 修饰的类型属性(存储、计算)，不可以被子类重写

class Circle {
   static var radius: Int = 0
  class  var diameter: Int {
        set {
            radius = newValue / 2
        }
        get {
            return radius * 2
        }
    }
    var name: String  {
        get {
            return "Haha"
        }
    }

}
class SubCircle :Circle {
    override class var diameter: Int {
        set {
            super.diameter = newValue > 0 ? newValue : 0
        }
        get {
            return super.diameter
        }
    }

}

 

二、重写方法、下标

1、重写实例方法、下标

class Animal {
    func speak(){
        print("Animal speak")
    }
    subscript(index: Int) -> Int {
        return index
    }
}
class Cat: Animal {
    override func speak() {
        super.speak()
        print("Cat speak")
    }
    override subscript(index: Int) -> Int {
        return index + 2
    }
}

2、重写类型方法、下标

被 class 修饰的类型方法、下标，允许被子类重写

被 static 修饰的类型方法、下标，不允许被子类重写

class Animal {
   class  func speak(){
        print("Animal speak")
    }
   class  subscript(index: Int) -> Int {
        return index
    }
    //static 修饰的不允许被子类重写
    static func test(){
        print("test")
    }

}
class Cat: Animal {
    override class func speak() {
        super.speak()
        print("Cat speak")
    }
    override class subscript(index: Int) -> Int {
        return index + 2
    }
}