swift5.1学习-9.继承,可选链,协议

1.继承(Inheritance)

2.重写实例方法、下标

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 super[index] + 1
} }

3.重写属性

4.final

5.可选链(Optional Chaining)

var person: Person? = Person() 
var age1 = person!.age() // Int 
var age2 = person?.age() // Int? 
var name = person?.name // String? 
var index = person?[6] // Int?
 func getName() -> String { "jack" } 
// 如果person是nil，不会调用getName()
 person?.name = getName()

6.协议(Protocol)

协议可以用来定义方法、属性、下标的声明，协议可以被枚举、结构体、类遵守(多个协议之间用逗号隔开)

protocol Drawable {
    func draw()
    var x: Int { get set }
    var y: Int { get }
    subscript(index: Int) -> Int { get set }
}
protocol Test1 {}
protocol Test2 {}
protocol Test3 {}
class TestClass : Test1, Test2, Test3 {}

7.协议中的属性

protocol Drawable {
    func draw()
var x: Int { get set }
var y: Int { get }
subscript(index: Int) -> Int { get set }
}

class Person : Drawable {
    var x: Int = 0
    let y: Int = 0
    func draw() {
        print("Person draw")
    }
  subscript(index: Int) -> Int { set {}
  get { index } }
  }
//类似写法
class Person : Drawable {
  var x: Int {
  get { 0 }
  set {} }
  var y: Int { 0 }
  func draw() { print("Person draw") } subscript(index: Int) -> Int {
  set {}
  get { index } }
}

8.协议的mutating

protocol Drawable {
    mutating func draw()
}
class Size : Drawable {
    var width: Int = 0
    func draw() {
width = 10 }
}
struct Point : Drawable {
    var x: Int = 0
    mutating func draw() {
        x = 10
} }

9.协议的初始化器

protocol Drawable {
    init(x: Int, y: Int)
}
class Point : Drawable {
    required init(x: Int, y: Int) {}
}
final class Size : Drawable {
    init(x: Int, y: Int) {}
}

protocol Livable {
    init(age: Int)
}
class Person {
    init(age: Int) {}
}
class Student : Person, Livable {
    required override init(age: Int) {
        super.init(age: age)
    }
}

10.协议的继承

一个协议可以继承其他协议

protocol Runnable {
    func run()
}
protocol Livable : Runnable {
    func breath()
}
class Person : Livable {
    func breath() {}
    func run() {}
}

11.协议组合

协议组合，可以包含1个类类型(最多1个)

protocol Livable {}
protocol Runnable {}
class Person {}


// 接收Person或者其子类的实例
func fn0(obj: Person) {}
// 接收遵守Livable协议的实例
func fn1(obj: Livable) {}
// 接收同时遵守Livable、Runnable协议的实例
func fn2(obj: Livable & Runnable) {}
// 接收同时遵守Livable、Runnable协议、并且是Person或者其子类的实例 func fn3(obj: Person & Livable & Runnable) {}

 typealias RealPerson = Person & Livable & Runnable
// 接收同时遵守Livable、Runnable协议、并且是Person或者其子类的实例 
func fn4(obj: RealPerson) {}