swift3 继承与初始化

1.继承

1.1 子类可以继承父类的属性和方法

class Viechle {
    var speed = 0
    var desc: String {
        return "时速是(speed)km/h"
    }

    func makeNoise() {
        print("hello")
    }
}
//子类可以继承父类的属性和方法
class Bike: Viechle {
    var hasBasket = false
}

let aBike = Bike()
aBike.speed //0
aBike.speed = 40    //40
aBike.desc  //"时速是40km/h"
aBike.hasBasket //false
aBike.makeNoise()   //输出:hello

1.2 子类可以根据需要，修改继承来的属性和方法（多态）

1.2.1 override 修改继承来的属性和方法

class CRH:Viechle {
    //override,子类可以根据需要，修改继承来的属性和方法（多态）
    override func makeNoise() {
        speed = 9
        print("嘟-嘟-嘟")
    }
}

let acrh = CRH()
acrh.speed  //0
acrh.makeNoise()    //输出:嘟-嘟-嘟
acrh.speed  //9

1.2.2 final 不允许对其修饰的内容进行继承或者重新操作

final:表示不允许对其修饰的内容进行继承或者重新操作。

Swift中，final关键字可以在class、func和var前修饰。
通常大家都认为使用final可以更好地对代码进行版本控制，发挥更佳的性能，同时使代码更安全。

1) final关键字在class前修饰

//1.final关键字在class前修饰
final class loverBike: Bike {
    var riders = 2
}

// class abcd:loverBike { //编译错误
// 
// }
// 将显示错误:error: inheritance from a final class 'loverBike' class abcd:loverBike 表示继承一个不可更改的类是错误的

2) final关键字在func和var前修饰

//2.final关键字在func和var前修饰
class classA{
    final var A :Int
    var B :Int
    //类中未初始化的实例变量／常量必须在init内初始化
    init(AA:Int,BB:Int) {
        A = AA
        B = BB
    }

    final func make() {
        A = 11
        B = 12
        print("hello world")
    }
}

class classB:classA{
    //final不允许对其修饰的内容进行继承或者重新操作
// override func make(){ //编译错误
// }

// override var A :Int{ //编译错误
// get {
// return super.A
// }
// set {
// super.A = newValue < 8 ? 8: newValue
// }
// }

    override var B :Int{
        get {
            return super.B
        }
        set {
            //如果为B赋的值小于8，则B的值改变为8
            super.B = newValue < 8 ? 8: newValue
        }
    }

    let C :Int
    let D :Int
    override init(AA:Int,BB:Int) {
        C = AA+1
        D = BB+1
        super.init(AA:AA,BB:BB)
    }

}
//: [](@next)
let a = classA(AA: 1,BB: 2)    //A:1,B:2
a.make()    //A:11,B:12

let b = classB(AA: 1,B:2,C:2,D:3
b.B = 5 //A:1,B:8,D:3

2.初始化

初始化：描述类/结构体/枚举实例化时，属性如何给初始值的方法。
形式： init(){ }

此方法称之为构造器。

在 init 里我们可以对 let 的实例常量进行赋值，这是初始化方法的重要特点。
正常情况下 let 声明的值是不可变的，无法被赋值，这对构建线程安全的 API 十分有用。而 init 只可能被调用一次，所以在 init 里我们可以为不变量进行赋值，而不会引起任何线程安全的问题。

2.1 类的定义和结构体的定义

类的定义没有给属性默认的值，则须在init中指定。
结构体的定义不需要指定属性默认的值，因为默认提供一个包含所有属性初始化的构造器。

//1.类的定义没有给属性默认的值，则须在init中指定
class RoomTemp {
    var 季节 : String
    var 温度 : Int

    init(季节:String,温度:Int) {
        self.温度 = 温度
        self.季节 = 季节
    }
}

let livingTemp = RoomTemp(季节: "夏天",温度: 24)
livingTemp.季节   //"夏天"
livingTemp.温度   //24

//2.结构体定义不需要指定属性默认的值，因为默认提供一个包含所有属性初始化的构造器
struct OfficeTemp {
    var 季节 : String
    var 温度 : Int
}

let xiaoboOfficeTemp = OfficeTemp(季节: "冬天",温度: 25)
xiaoboOfficeTemp.季节 //"冬天"
xiaoboOfficeTemp.温度 //25

2.2 convenience 子类只能调用,不能重写override或从以super的方式被调用

便利构造器：可以通过对主构造器的包装，实现便利的初始化
convenience只作为补充和提供使用上的方便。所有的convenience初始化方法都必须调用同一个类中的designated初始化完成设置。
子类可以照常调用父类的初始化方法，但是convenience的初始化方法是不能被子类重写override或从子类中以super的方式被调用的。

//1.便利构造器
class Food {
    var name: String

    init(name: String) {
        self.name = name
    }
    //convenience:子类只能调用不能重写override或从以super的方式被调用
    convenience init() {
        self.init(name: "没有名称的食物！")
    }
}

let nonameFood = Food()

nonameFood.name //"没有名称的食物！"

class Menu: Food {
    var count: Int

    init(name:String,count: Int){
        self.count = count
        super.init(name: name)
    }
    //重写父类的属性或者方法override
    convenience override init(name: String) {
        self.init(name: name,count: 1)
    }
}

let menu1 = Menu(name: "牛肉")

menu1.name  //"没有名称的食物！"
menu1.count //1

//2.convenience的使用
class ClassA {
    let numA:Int
    init(num:Int){
        numA = num
    }
    //convenience 子类只能调用,不能重写override或从以super的方式被调用
    convenience init(bigNum: Bool){
        self.init(num: bigNum ? 10000 : 1)
    }
}

class ClassB: ClassA {
    let numB: Int
    //重写父类的初始化方法override
    override init(num: Int) {
        numB = num + 1
        super.init(num: num)
    }

// convenience override init(bigNum: Bool) { // //编译错误
// }
}

//子类可以照常调用父类的初始化方法
let a = ClassB.init(num: 1)
print(a.numA)   //1
print(a.numB)   //2

//子类可以照常调用父类的convenience的初始化方法
let anObj = ClassB(bigNum: true)
print(anObj.numA)   //10000
print(anObj.numB)   //10001

2.3 可失败构造器 init?

可失败构造器：针对有可能的初始化失败，返回nil。
例：初始化一张图片，如果图片名不存在，则初始化失败

import UIKit

//UIImage方法需要添加UIKit库
let ball =  UIImage(named: "ball")  //图片名不存在 为nil

struct Animal {
    let name: String

    init?(name :String) {
        if name.isEmpty {
            print("动物没有给名字")
            return nil
        }
        self.name = name
    }
}

let elepant = Animal(name: "")  //nil
let elepant1 = Animal(name: "asd")  //Animal,name:asd

//可选链 optional chain
elepant?.name.fastestEncoding.description   //nil
elepant1?.name.fastestEncoding.description  //"Unicode (UTF-16)"

//! 为值一定存在
let url = URL(string: "http://www.baidu.com")
let urlrequest = URLRequest(url: url!)  //http://www.baidu.com

参考自
SwiftV课堂视频源码
http://www.csdn.net/article/2015-01-07/2823458-init-keywords