所有面向对象语言都具有三大特征：封装、继承、多态

1:简介:

当有多个类具有相同的属性和行为时，将共同的部分提取出来封装成新的类，然后让多个类继承这个新类。（使代码维护起来更加简单）

(1)继承：与现实生活中的继承原理相同 。 例如：财产继承、基因继承等

(2)继承讲的是父与子的关系，子继承于父。 
编程语言中继承指的是类与类之间的继承

(3)关系：父类(parentClass) 、超类(superClass) 、基类 
子类(childClass) 、子类(subClass)、 派生类

(4)重写：子类继承父类的方法,属性,下标. 如果子类继承父类的方法,属性,下标,并不满足子类的需求,子类可以将继承过来的内容进行重写。
重写就是方法名相同，内容不同

(5)派生：子类也有自己的属性、方法、下标，子类较父类多出的部分，称为派生

2继承的格式

class name: super class {
    code
}

3单继承

(1)swift语言中没有统一的父类，如果定义类时没有指定该类的父类，那么这个类就可以充当父类

(2)swift语言中的继承指的是单继承，一个子类只有一个直接父类。可以借助协议实现多继承(和OC一样),在后续的文章协议中会具体介绍

(3)一个类的属性和方法在内存中分为两部分： 一部分是自身的属性和方法，一部分是从父类继承过来的属性和方法。

(4)self关键字在实例方法中相当于对象,在类方法中相当于类名

程序实例如下:

class Person {
    var name: String = ""
    static var age : Int = 0 // static也可以修饰属性
    
    func eat() -> Void {
        print("\(name)正在吃东西")
    }
    func sleep() -> Void {
        print("\(Person.age)正在睡觉")
        // static修饰的属性为类型属性, 必须通过类名调用.非static修饰的属性为存储属性 , 通过对象调用
    }
    static func hitDouDou () -> Void {
        print("\(age)正的在打豆豆")
        // <结论>self关键字在实例方法中相当于对象,在类方法中相当于类名
    }
}

class Man: Person {
    var height : Double = 0.0
    
    func writeCoder() -> Void {
        name = "ZZ"
        Man.age = 11
        print("\(name)今年:\(Man.age)岁了,身高:\(height),")
    }
}
var man = Man.init()
man.height = 1.90
man.writeCoder()
man.eat()
man.sleep()
Man.hitDouDou()

4:重写父类的方法

(1)子类重写父类的方法，子类重写的方法就会将父类的同名方法进行覆盖，所以子类对象调用的同名方法是子类重写的方法

(2)子类的方法名、参数列表，如果和父类中的方法完全相同，编译器默认就是重写方法，需要在方法名前加关键字override。

程序实例如下：

class Car {
    var speed : Double = 90.0
    var wheel : Int = 4
    
    func run() -> Void {
        print("速度为\(speed)的大众速腾后悬挂断了")
    }
    class func stop () {
        print("因为断轴不会跑了")
    }
}

var car = Car.init()
car.run()
Car.stop()

class Bike: Car {
    override func run() {
         super.run() // super关键字!只是!用来调用父类的方法或者属性，只是个关键字，没有其它意义
        print("跑丢了\(wheel)轮子")
    }
    // 父类中使用static修饰的方法/属性 子类只能继承 不能重写
    // 父类中使用class修饰的方法/属性 子类可以重写 但是很少使用class关键字定义方法
    override class func stop () {
        super.stop()
    }
}
var bike = Bike.init()
bike.speed = 20.0
bike.wheel = 2
bike.run()
Bike.stop()

5重写父类的属性

(1)swift语言中是允许子类重写父类的属性的，可以为重写的属性指定get和set方法，实现对重写属性进行读写操作，也可以添加属性观察者willSet didSet

(2)子类重写父类的属性 ,如果父类的属性是只读属性(get), 子类重写的时候可以添加set方法 , 但是 如果父类的属性是读写属性(get,set) 子类重写的时候如果只有只读或者只写部分，是会崩溃的。

程序示例如下：

class Cat {
    var color : String = ""
    var description: String {
//        get {
            return "🐱"
//        }
    }
}
class Panda: Cat {
    override var color: String {
        get{
            return super.color
        }
        set{
            super.color = newValue
        }
    }
    override var description: String {
        get {
            return "国宝"
        }
        set {
            print("重写父类的计算属性的set方法")
        }
    }
}
var panda = Panda.init()
panda.color = "黑白色"

print(panda.description)

6重写父类下标

和父类的下标写法几乎一样，见代码如下

class Fruit {
    var color : String = ""
    
    subscript (index: Int) -> String {
        set {
            color = newValue
        }
        get {
            return color
        }
    }
}
var f = Fruit.init()
f[0] = "Green"
print(f[0])

class Apple: Fruit {
    override subscript (index: Int) -> String {
        get {
            return color + "苹果"
        }
        set {
            color = newValue
        }
    }
}
var apple = Apple.init()
apple[0] = "Rad"
print(apple[0])

7父类禁止子类重写的方法

(1)关键字 final 可以修饰 类, 方法, 属性, 下标

(2) final 修饰的 【类】是不能被继承的 , final 修饰的方法、属性、下标是不能被重写的