Swift：（十）、下标、继承、重写、构造方法

//一、下标：一个类型可以定义多个下标,通过不同索引类型进行重载。下标不限于一维,你可以定义具有多个入参的下标满足自定义类型的需求。//（1）、下标语法：与定义实例方法类似,定义下标使用 subscript 关键字,指定一个或多个输入参数和返回类型
struct TimesTable {    let multiplier: Int    subscript(index: Int) -> Int {        return multiplier * index    }}
//实例化结构体：let threeTimesTable = TimesTable(multiplier: 3)print("six times three is \(threeTimesTable[6])")
//（2）、下标使用：下标通常作为访问集合,列表或序列中元素的快捷方式。可以针对自己特定的类或结构体的功能来自由地以最恰当的方式实现下标。
//二、继承：一个类可以继承另一个类的方法,属性和其它特性。当一个类继承其它类时,继承类叫子类,被继承类叫超类(或父类)
//（1）、基类：class Person {    var name = "lisi"    var description: String {        return "我的名字是\(name)"    }    func makeMoney() {        print("person make money!")    }}
let person = Person()print(person.description)
//(2)、子类：语法：class 子类名称：superClass{}class StundentClass:Person{    func study() {        print("study")    }}
class TeacherClass:Person{    func teaching() {    }    override func makeMoney() {        print("teacher  make money!")    }}
var student = StundentClass()student.name = "贾栋梁"print(student.description)print(student.name)student.study()
//（3）、再继承：class MindleStudentClass:StundentClass{    func doHomeWork() {        print("doHomeWork")    }}var mindelStudent = MindleStudentClass()mindelStudent.name = "曹痘痘"print(mindelStudent.name)print(mindelStudent.description)
//(4)、方法的重写：子类可以为继承来的实例方法,类方法,实例属性,或下标提供自己定制的实现。我们把这种行为叫重写。//注意：如果要重写某个特性,你需要在重写定义的前面加上 override 关键字。这么做,你就表明了你是想提供一个重写版本,而非错误地提供了一个相同的定义。意外的重写行为可能会导致不可预知的错误,任何缺少 override 关键字的重写都会在编译时被诊断为错误。
class NewTeacherClass:Person{    func teaching() {            }    override func makeMoney() {        print("teacher  make money!")    }}

var  newTeaching = NewTeacherClass()newTeaching.makeMoney()

//（5）、属性重写：重写继承来的实例属性或类型属性,提供自己定制的 getter 和 setter,或添加属性观察器使重写的属性 可以观察属性值什么时候发生改变。//注意：重写一个属性时,必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。可以将一个继承来的只读属性重写为一个读写属性，但是,不可以将一个继承来的读写属性重写为一个只读属性。
class AmiyClass:Person{    var age = 20    override var description: String {        return super.description + " 年龄是 \(age)岁"    }    func doSoneThing() {            }    override func makeMoney() {        print("Amiy make money!")    }}
var  Amiy = AmiyClass()print(Amiy.description)
Amiy.name = "吴京"Amiy.age = 40print(Amiy.description)

//(6)、重写属性观察器：可以通过重写属性为一个继承来的属性添加属性观察器//注意：不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器class ZhanlangAmiy: AmiyClass {    override var name: String {        didSet {            print(name)        }    }}
var  zhanlangAmiy = ZhanlangAmiy()zhanlangAmiy.name = "吴京"print("\(zhanlangAmiy.description)")

//（7）、防止重写：你可以通过把方法,属性或下标标记为 final 来防止它们被重写,只需要在声明关键字前加上  final 修饰符即可
//(8)、自定义构造过程：
struct Color {    let red, green, blue: Double    init(red: Double, green: Double, blue: Double) {        self.red   = red        self.green = green        self.blue  = blue    }    init(white: Double) {        red   = white        green = white        blue  = white    }}
let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)let halfGray = Color(white: 0.5)
//注意：如果不通过外部参数名字传值,你是没法调用这个构造器的。只要构造器定义了某个外部参数名,你就必须使用它,忽略它将导致编译错误:

//（9）、值类型的构造器代理：对于值类型,你可以使用 self.init 在自定义的构造器中引用相同类型中的其它构造器。并且你只能在构造器内部调用 self.init 。struct Size {    var width = 0.0, height = 0.0}
struct Point {    var x = 0.0, y = 0.0}

struct Rect {    var origin = Point()    var size = Size()    init() {}    init(origin: Point, size: Size) {        self.origin = origin        self.size = size    }    init(center: Point, size: Size) {        let originX = center.x - (size.width / 2)        let originY = center.y - (size.height / 2)//        值类型的构造器代理        self.init(origin: Point(x: originX, y: originY), size: size)    }}
//（10）、类构造器的继承和重写class Vehicle {    var numberOfWheels = 0    var description: String {        return "\(numberOfWheels) wheel(s)"    }}

let vehicle = Vehicle()print("Vehicle: \(vehicle.description)")

class Bicycle: Vehicle {    override init() {        super.init()        numberOfWheels = 2    }}
let bicycle = Bicycle()print("Bicycle: \(bicycle.description)")