Swift-关键字

Swift关键字汇总如下：

一： 常见使用频繁的关键字：

1，访问修饰符：在swift中，访问修饰符有五种，分别是：open、public 、internal、fileprivate、private。

从高到低的排序：open > public >interal > fileprivate > private
open：可以被任何模块的代码访问，包括override(重写)和继承。
public: 可以被任何模块的代码访问，模块内是可以被override(重写)和继承的，而在但其他模块不可以override(重写)和继承。
internal：内部的意思。默认访问级别，可写可不写，访问级别所修饰的属性或方法在源代码所在的整个模块都可以访问。
fileprivate：修饰的属性或者方法只能在当前文件中访问，包括override(重写)和继承，当前类的extension 中也可以。如果一个文件中含有多个类，这些类中也可以。

class Person  
{  
    fileprivate var jobTitle:String = ""  
}
extension Person  
{
    //当 extension 和 class 在同一个文件中时，允许访问
    func printJobTitle()  
    {  
        print("My job is /(jobTitle)")  
    }  
}

private：修饰的属性或者方法只能在当前类中访问，当前类的extension 中也可以访问。如果当前文件有多个类，这些类中不可以访问。

image.png

2，其他修饰符

Any：用于表示任意类型的实例，包括函数类型。
AnyObject 可以代表任何 class 类型的实例。
override：指明子类会提供自定义实现，覆盖父类的实例方法、类型方法、实例属性、类型属性、下标。如果没有实现，则会直接继承自父类。

class Person  
{  
    func printInfo()  
    {  
        print("I'm just a person!")  
    }  
}

class Programmer : Person  
{  
    override func printInfo()  
    {  
        print("I'm a person who is a dev!")  
    }  
}

let aPerson = Person()  
let aDev = Programmer()

aPerson.printInfo() //打印 I'm just a person!  
aDev.printInfo() //打印 I'm a person who is a dev!

?和!，Swift语言中对一种可选类型（ Optional) 操作的语法糖。
一句话：确定有值直接使用!，不确定有值使用？

?: 先判断在拆包的语法糖。Swift中是可以声明一个没有初始值的属性，类型后加加一个 ? 操作符完成的。

var name: String?
// 上面这个Optional的声明，是”我声明了一个Optional类型值，
 它可能包含一个String，也可能什么都不包含

!：表示强解包，不管有没有值直接拆包。如果没有值往往会崩溃crash，所有使用的时候一定要确定有值。

//举例1
// 定义一个string的可选类型str，显式赋值
var str: String? = "Hello"
if str{
    let message = "你好" + str！
    print(message)//因为已经给str赋值为hello，所以if判断条件成立，然后给name强解包，得到hello
}

//举例2
// 定义一个string的可选类型str，但是没有显式赋值
var str: String?
let message = "你好" + str！
print(message)//强解包程序会crash掉。所以在使用！强解包的时候一定要确定解包对象不为nil，否则会引起程序崩溃。

例如
try：表明接着调用的函数可能会抛出 error。有三种不同的使用方式：try(默认tr)，try?(可选try)， try!( 强行try )。
使用如下几种，建议示例使用法：

import UIKit

/* 知识点:
 从对象 到 二进制数据的过程 一般称为对象的序列化(Serialization)，也称为归档(Archive).
 同理，从二进制数据 到 对象的过程 一般称为反序列化或者反归档.
 */
class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

        loadData()
    }
    
    // 请求数据
    func loadData(){//
        // 请求的url (实测: 返回结果为json)
        let url = URL(string: "http://www.weather.com.cn/data/sk/101010100.html")
//        let url = URL(string: "http://www.baidu.com")
        
        // guard判断url 是否为nil
        guard let u = url else {
            return
        }
        
        // 实例化request
        let request = URLRequest(url: u)
        
        // 发送请求
        URLSession.shared.dataTask(with: request) { (data, _, error) in
            
            // 错误判断
            if error != nil {
                print(error!)
                return
            }
            
            // 判断data 是否有值
            guard let d = data else{
                return
            }

            // 出现问题: 正常情况下, 将Json 反序列化为字典, 但是正常写了会报错
            // 报错内容: Call can throw, but it is not marked with 'try' and the error is not handled
            // 报错原因: 调用可能够抛出异常, 因为没有标记try, 也未作错误处理. 系统处理的一种方式而已.
            // 解决方法: 既然说了没有标记try, 那就标记即可.
//            let dict = JSONSerialization.jsonObject(with: d, options: [])
            
            // 解决方式一: 强行try (try!)
            // 存在问题: 当请求结果不是标准的json数据时, 会造成程序崩溃
            // 也就是说: url为天气的链接时, 就会正常使用; 而url为百度的链接时, 就会崩溃.
//            let dict = try! JSONSerialization.jsonObject(with: d, options: [])
            
            
            // 解决方式二: 可选try (try?)
            // 特点: 能反序列化成功, 就给你返回成功的值; 不能成功就给你返回nil
//            let dict = try? JSONSerialization.jsonObject(with: d, options: [])
            
            // 打印结果
//            print(dict)
            
            // 解决方式三: 默认try (try)
            // 注意: 一定要配合 do{}catch{} 使用
            do{
                let dict = try JSONSerialization.jsonObject(with: d, options: [])
                print(dict)
            }catch{
                // catch 中默认提供error信息, 当序列化不成功是, 返回error
                print(error)
            }
        }.resume()
    }
}

as：类型转换运算符，用于尝试将值转成其它类型。 as、as!、as?三种
as的使用:
①数值类型转换
示例1：

let age = 28 as Int
let money = 20 as CGFloat
let cost = (50 / 2) as Double

②从派生类转换为基类，向上转型：

// 1，定义人员基类
class Person {
    var name : String
    
    init(_ name: String){
        self.name = name
    }
}

// 2，定义学生类
class Student : Person {
}

// 3，定义教师类
class Teacher : Person {
}

// 处理人员对象的函数(或工厂模式处理操作等)
func showPersonName(_ people : Person){
    let name = people.name
    print("这个人的名字是: /(name)")
}

// 定义一个学生对象 tom
var tom = Student("Tom");

// 定义一个教师对象 kevin
var kevin = Student("Kevin Jakson");

// 先把学生对象向上转型为一般的人员对象
let person1 = tom as Person
let person2 = kevin as Person

// 再调用通用的处理人员对象的showPersonName函数
showPersonName(person1)//这个人的名字是: Tom
showPersonName(person2)//这个人的名字是: Kevin Jakson

③switch 语句中进行模式匹配
通过switch语法检测对象的类型，根据对象类型进行处理

switch person1 {
    case let person1 as Student:
        print("是Student类型，打印学生成绩单...")
    case let person1 as Teacher:
        print("是Teacher类型，打印老师工资单...")
    default: break
}

as!的使用:

• as!:向下转型（Downcasting）时使用。由于是强制类型转换，如果转换失败会报 runtime 运行错误。

let person : Person = Teacher("Jimmy Lee")
let jimmy = person as! Teacher

as?的使用:

• as? : as? 和 as! 操作符的转换规则完全一样。但 as?如果转换不成功的时候便会返回一个nil 对象。成功的话返回可选类型值。由于 as? 在转换失败的时候也不会出现错误，所以对于如果能确保100%会成功的转换则可使用 as!，否则使用 as?

let a = 13 as! String
print(a)
//会crash

let a = 13 as? String
print(a)
//输出为nil

is：类型检查运算符，用于确定实例是否为某个子类类型。

class Person {}  
class Programmer : Person {}  
class Nurse : Person {}

let people = [Programmer(), Nurse()]

for aPerson in people  
{  
    if aPerson is Programmer  
    {  
        print("This person is a dev")  
    }  
    else if aPerson is Nurse  
    {  
        print("This person is a nurse")  
    }  
}

_：用于匹配或省略任意值的通配符。
1，格式化数字字面量，提高数字字面量的可读性

let paddedDouble = 123.000_001
let oneMillion = 1_000_000

2，忽略元组的元素值。假设有的元素不须要使用，使用下划线将对应的元素进行忽略

// 仅关心http404Error中第二个元素的值。所以第一个元素能够使用下划线进行忽略
let http404Error = (404, "Not Found")
let (_, errorMessage) = http404Error

3，忽略区间值

let base = 3
let power = 10
var answer = 1
for _ in 1...power {
    answer *= base
}

4，忽略外部參数名
(1).忽略方法的默认外部參数名

class Counter {
    var count: Int = 0
    func incrementBy(amount: Int, numberOfTimes: Int) {
        count += amount * numberOfTimes
    }
}
/* 在上面的代码中，方法incrementBy()中的numberOfTimes具有默认的外部
參数名：numberOfTimes，假设不想使用外部參数名能够使用下划线进行
忽略，代码能够写为（只是为了提高代码的可读性，一般不进行忽略)*/
class Counter {
    var count: Int = 0
    func incrementBy(amount: Int, _ numberOfTimes: Int) {
        count += amount * numberOfTimes
    }
}

(2).忽略具有默认值的參数的外部參数名

//   假设不想使用默认外部參数名，能够进行例如以下改动：
func join(_ s1: String, _ s2: String, _ joiner: String = " ") -> String {
    return s1 + joiner + s2
}
// call the function.
join("hello", "world", "-")

inout：将一个值传入函数，并可以被函数修改，然后将值传回到调用处，来替换初始值。适用于引用类型和值类型。 其实就是声明参数为指针

func dangerousOp(_ error:inout NSError?)  
{  
    error = NSError(domain: "", code: 0, userInfo: ["":""])  
}

var potentialError:NSError?
dangerousOp(&potentialError)

//代码运行到这里，potentialError 不再是 nil，而是已经被初始化

do：用于表示处理错误代码段的开始。
final：防止方法、属性、下标被重写。
get：返回成员的值。还可以用在计算型属性上，间接获取其它属性的值。
default：用于涵盖在 switch 语句中，所有未明确列出的枚举成员。
optional：用于指明协议中的可选方法。遵守该协议的实体类可以不实现这个方法。
#if：条件编译控制语句，用于控制程序在不同条件下编译代码。通过判断条件，决定是否执行代码。
#elseif：条件编译控制语句，用于控制程序在不同条件下执行代码。与 #if 语句结合使用。当条件为 true，执行对应代码。
#endif：条件编译控制语句，用于控制程序在不同条件下执行代码。用于表明条件编译代码的结尾。
willSet：属性观察者，在值存储到属性之前调用。
didSet：属性观察者，当值存储到属性后马上调用。

    
    //带属性监视器的普通属性
    var age:Int = 0 {
        //我们需要在age属性变化前做点什么
        willSet {
            println("Will set an new value /(newValue) to age")
        }
        //我们需要在age属性发生变化后，更新一下nickName这个属性
        didSet {
            println("age filed changed form /(oldValue) to /(age)")
            if age < 10 {
                nickName = "Little"
            }else{
                nickName = "Big"
            }
        }
    }

deinit: 当一个类的实例即将被销毁时，会调用这个方法。

class Person  
{  
    var name:String  
    var age:Int  
    var gender:String

    deinit  
    {  
        //从堆中释放，并释放的资源
    }  
}

required：确保编译器会检查该类的所有子类，全部实现了指定的构造器方法。**
required关键字

对于某些我们希望子类中一定实现的designated初始化方法，我们可以通过添加required关键字进行限制，强制子类对这个方法重写。
required修饰符的使用规则:

• required修饰符只能用于修饰类初始化方法。
• 当子类含有异于父类的初始化方法时（初始化方法参数类型和数量异于父类），子类必须要实现父类的required初始化方法，并且也要使用required修饰符而不是override。
• 当子类没有初始化方法时，可以不用实现父类的required初始化方法。

代码：

        class MyClass {
            var str:String
            required init(str:String) {
                self.str = str
            }
        }
        class MySubClass:MyClass
        {
            init(i:Int) {
                super.init(str:String(i))
            }

        }
        // 编译错误
        MySubClass(i: 123)

会报错，因为你没有实现父类中必须实现的方法。正确的写法：

    class MyClass{
        var str: String?
        required init(str: String?) {
            self.str = str
        }
    }
    class MySubClass: MyClass{
        init(i: Int) {
            super.init(str: String(i))
        }

        required init(str: String?) {
            fatalError("init(str:) has not been implemented")
        }
    }

从上面的代码中，不难看出子类需要添加异于父类的初始化方法，必须要重写有required的修饰符的初始化方法，并且也要使用required修饰符而不是override，请千万注意！

如果子类中并没有不同于父类的初始化方法，Swift会默认使用父类的初始化方法:

    class MyClass{
        var str: String?
        required init(str: String?) {
            self.str = str
        }
    }
    class MySubClass: MyClass{
    }
    var MySubClass(str: "hello swift")

在这种情况下，编译器不会报错，因为如果子类没有任何初始化方法时，Swift会默认使用父类的初始化方法。

nil：在 Swift 中表示任意类型的无状态值。

Swift的nil和OC中的nil不一样.在OC中,nil是一个指向不存在对象的指针。
而在Swift中,nil不是指针,它是一个不确定的值。用来表示值缺失.任何类型的optional都可以被设置为nil.。而在OC中,基本数据类型和结构体是不能被设置为nil的. 给optional的常量或者变量赋值为nil.来表示他们的值缺失情况.一个optional常量或者变量如果在初始化的时候没有被赋值,他们自动会设置成nil.

class Person{}  
struct Place{}

//任何 Swift 类型或实例可以为 nil
var statelessPerson:Person? = nil  
var statelessPlace:Place? = nil  
var statelessInt:Int? = nil  
var statelessString:String? = nil

guard：当有一个以上的条件不满足要求时，将离开当前作用域。同时还提供解包可选类型的功能。

   guard x > 0 else {
        // 变量不符合条件判断时，执行下面代码
        return
    }

1.guard关键字必须使用在函数中。
2.guard关键字必须和else同时出现。
3.guard关键字只有条件为false的时候才能走else语句 相反执行后边语句。

indirect
指明在枚举类型中，存在成员使用相同枚举类型的实例作为关联值的情况。

indirect enum Entertainment  
{  
   case eventType(String)  
   case oneEvent(Entertainment)  
   case twoEvents(Entertainment, Entertainment)  
}

let dinner = Entertainment.eventType("Dinner")  
let movie = Entertainment.eventType("Movie")

let dateNight = Entertainment.twoEvents(dinner, movie)

lazy
指明属性的初始值，直到第一次被使用时，才进行初始化。

class Person  
{  
    lazy var personalityTraits = {  
        //昂贵的数据库开销  
        return ["Nice", "Funny"]  
    }()  
}
let aPerson = Person()  
aPerson.personalityTraits //当 personalityTraits 首次被访问时，数据库才开始工作

optional
用于指明协议中的可选方法。遵守该协议的实体类可以不实现这个方法。

@objc protocol Foo  
{  
    func requiredFunction()  
    @objc optional func optionalFunction()  
}

class Person : Foo  
{  
    func requiredFunction()  
    {  
        print("Conformance is now valid")  
    }  
}

extension：允许给已有的类、结构体、枚举、协议类型，添加新功能。

class Person  
{  
    var name:String = ""  
    var age:Int = 0  
    var gender:String = ""  
}

extension Person  
{  
    func printInfo()  
    {  
        print("My name is /(name), I'm /(age) years old and I'm a /(gender).")  
    }  
}

.Type：表示任意类型的类型(就是一个元类型（Meta），包括类类型、结构类型、枚举类型、协议类型。
.self：.self 用在类型后面取得类型本身，用在实例后面取得实例本身。

二： 其他的关键字：

super：在子类中，暴露父类的方法、属性、下标
infix：指明一个用于两个值之间的运算符。如果一个全新的全局运算符被定义为 infix，还需要指定优先级。
associativity：指明同一优先级的运算符，在缺少大括号的情况，按什么顺序结合。使用 left、right、none。
associatedtype：在协议中，定义一个类型的占位符名称。直到协议被实现，该占位符才会被指定具体的类型。
indirect：指明在枚举类型中，存在成员使用相同枚举类型的实例作为关联值的情况。
in：在序列上迭代，比如一组特定范围内的数字，数组中的元素，字符串中的字符。与关键字 key 搭配使用。*
left：指明运算符的结合性是从左到右。在没有使用大括号时，可以用于正确判断同一优先级运算符的执行顺序。
mutating：允许在方法中修改结构体或者枚举实例的属性值。
none：是一个没有结合性的运算符。不允许这样的运算符相邻出现。
nonmutating：指明成员的 setter 方法不会修改实例的值，但可能会有其它后果。
postfix：位于值后面的运算符。
precedence：指明某个运算符的优先级高于别的运算符，从而被优先使用。
prefix：位于值前面的运算符。
right：指明运算符的结合性是从右到左的。在没有使用大括号时，可以用于正确判断同一优先级运算符的顺序。
set：通过获取的新值来设置成员的值。同样可以用于计算型属性来间接设置其它属性。如果计算型属性的 setter 没有定义新值的名称，可以使用默认的 newValue。
unowned：让循环引用中的实例 A 不要强引用实例 B。前提条件是实例 B 的生命周期要长于 A 实例。
weak：允许循环引用中的实例 A 弱引用实例 B ，而不是强引用。实例 B 的生命周期更短，并会被先释放。

open var foo:String? //这个属性允许在 app 内或 app 外重写和访问。在开发框架的时候，会应用到这个访问修饰符。

operator：特殊符号，用于检查、修改、组合值。
static：用于定义类方法，在类型本身进行调用。此外还可以定义静态成员。

class Person  
{  
    var jobTitle:String?

    static func assignRandomName(_ aPerson:Person)  
    {  
        aPerson.jobTitle = "Some random job"  
    }  
}

let somePerson = Person()  
Person.assignRandomName(somePerson)  
//somePerson.jobTitle 的值是 "Some random job"

struct：通用、灵活的结构体，是程序的基础组成部分，并提供了默认初始化方法。与 class 不同，当 struct 在代码中被传递时，是被拷贝的，并不使用引用计数。除此之外，struct 没有下面的这些功能：

• 使用继承。
• 运行时的类型转换。
• 使用析构方法。

struct Person  
{  
    var name:String  
    var age:Int  
    var gender:String  
}

typealias：给代码中已经存在的类，取别名。

typealias JSONDictionary = [String: AnyObject]
func parseJSON(_ deserializedData:JSONDictionary){}

defer：用于在程序离开当前作用域之前，执行一段代码。

关闭文件

func foo() {
  let fileDescriptor = open(url.path, O_EVTONLY)
  defer {
    close(fileDescriptor)
  }
  // use fileDescriptor...
}

加/解锁：下面是 swift 里类似 Objective-C 的 synchronized block 的一种写法，可以使用任何一个 NSObject 作 lock

func foo() {
  objc_sync_enter(lock)
  defer { 
    objc_sync_exit(lock)
  }
  // do something...
}

defer的执行时机:
defer 的执行时机紧接在离开作用域之后，但是是在其他语句之前。这个特性为 defer 带来了一些很“微妙”的使用方式。比如从 0 开始的自增：

class Foo {
    var num = 0
    func foo() -> Int {
        defer { num += 1 }
        return num
    }

    // 没有 `defer` 的话我们可能要这么写
    // func foo() -> Int {
    //    num += 1
    //    return num - 1
    // }
}

let f = Foo()
f.foo() // 0
f.foo() // 1
f.num   // 2

fallthrough：显式地允许从当前 case 跳转到下一个相邻 case 继续执行代码。

let box = 1

switch box  
{  
    case 0:  
    print("Box equals 0")  
    fallthrough  
    case 1:  
    print("Box equals 0 or 1")  
    default:  
    print("Box doesn't equal 0 or 1")  
}

repeat：在使用循环的判断条件之前，先执行一次循环中的代码。

repeat  
{  
    print("Always executes at least once before the condition is considered")  
}  
while 1 > 2

where：要求关联类型必须遵守特定协议，或者类型参数和关联类型必须保持一致。也可以用于在 case 中提供额外条件，用于满足控制表达式。

• 增加判断条件

for i in 0…3 where i % 2 == 0  
{  
    print(i) //打印 0 和 2  
}

• 协议使用where， 只有基类实现了当前协议才能添加扩展。 换个说法， 多个类实现了同一个协议，该语法根据类名分别为这些类添加扩展， 注意是分别(以类名区分)！！！

protocol SomeProtocol {
    func someMethod()
}

class A: SomeProtocol {
    let a = 1

    func someMethod() {
       print("call someMethod")
    }
}

class B {
    let a = 2
}

//基类A继承了SomeProtocol协议才能添加扩展
extension SomeProtocol where Self: A {
    func showParamA() {
        print(self.a)
    }
}
//反例，不符合where条件
extension SomeProtocol where Self: B {
    func showParamA() {
        print(self.a)
    }
}
let objA = A()
let objB = B()  //类B没实现SomeProtocol， 所有没有协议方法
objA.showParamA()  //输出1

super：在子类中，暴露父类的方法、属性、下标。

class Person  
{  
    func printName()  
    {  
        print("Printing a name. ")  
    }  
}

class Programmer : Person  
{  
    override func printName()  
    {  
        super.printName()  
        print("Hello World!")  
    }  
}

let aDev = Programmer()  
aDev.printName() //打印 Printing a name. Hello World!

throw：用于在当前上下文，显式抛出 error。
throws：指明在一个函数、方法、初始化方法中可能会抛出 error。
//"throws" 表明在调用方法时，需要使用 try，try?，try!
true：Swift 用于表示布尔值的两个常量值之一，表示为真。

以#开头的关键字

*#file：特殊字面量表达式，返回当前代码所在源文件的名称。 *
#colorLiteral：在 playground 中使用的字面表达式，用于创建颜色选取器，选取后赋值给变量。

let aColor = #colorLiteral //创建颜色选取器

#imageLiteral：playground 字面量语法，创建图片选取器，选择并返回 UIImage 实例。
#fileReference：playground 字面量语法，用于创建文件选取器，选取并返回 NSURL 实例。
**#sourceLocation：行控制语句，可以指定与原先完全不同的行数和源文件名。通常在 Swift 诊断、debug 时使用。
#column：一种特殊的字面量表达式，用于获取字面量表示式的起始列数。

class Person  
{  
    func printInfo()  
    {  
        print("Some person info - on column (#column)")
    }  
}

let aPerson = Person()  
aPerson.printInfo() //Some person info - on column 53

#function：特殊字面量表达式，返回函数名称。在方法中，返回方法名。在属性的 getter 或者 setter 中，返回属性名。在特殊的成员中，比如 init 或 subscript 中，返回关键字名称。在文件的最顶层时，返回当前所在模块名称。

class Person  
{  
    func printInfo()  
    {  
        print("Some person info - inside function (#function)")
    }  
}

let aPerson = Person()  
aPerson.printInfo() //Some person info - inside function printInfo()

#line：特殊字面量表达式，用于获取当前代码的行数。

class Person  
{  
    func printInfo()  
    {  
        print("Some person info - on line number (#line)")
    }  
}

let aPerson = Person()  
aPerson.printInfo() //Some person info - on line number 5

#selector：用于创建 Objective-C selector 的表达式，可以静态检查方法是否存在，并暴露给 Objective-C。

//静态检查，确保 doAnObjCMethod 方法存在  
control.sendAction(#selector(doAnObjCMethod), to: target, forEvent: event)

#available：基于平台参数，通过 if，while，guard 语句的条件，在运行时检查 API 的可用性。

if #available(iOS 10, *)  
{  
    print("iOS 10 APIs are available")  
}

convenience：
在 Swift 中，为保证安全性，init 方法只能调用一次，且在 init 完成后，保证所有非 Optional 的属性都已经被初始化。

每个类都有指定的初始化方法：designated initializer，这些初始化方法是子类必须调用的，为的就是保证父类的属性都初始化完成了。

而如果不想实现父类的 designated initializer，可以添加 convenience 关键字，自己实现初始化逻辑。
convenience 初始化不能调用父类的初始化方法，只能调用同一个类中的 designated initializer。
由于 convenience 初始化不安全，所以 Swift 不允许 convenience initializer 被子类重写，限制其作用范围。

class People {

    var name: String

    init(name: String) {
        self.name = name
    }
}

通过extension给原有的People类增加init方法:

// 使用convenience增加init方法
extension People {
    convenience init(smallName: String) {
        self.init(name: smallName)
    }
}

结下来，Student类继承父类People

class Student: People {
    var grade: Int

    init(name: String, grade: Int) {
        self.grade = grade
        super.init(name: name)
        // 无法调用
        // super.init(smallName: name)
    }

    // 可以被重写 
    override init(name: String) {
        grade = 1
        super.init(name: name)
    }

    // 无法重写，编译不通过
    override init(smallName: String) {
        grade = 1
        super.init(smallName: smallName)
    }
}

子类对象调用父类的convenience的init方法：只要在子类中实现重写了父类convenience方法所需要的init方法的话，我们在子类中就可以使用父类的convenience初始化方法了

class People {

    var name: String

    init(name: String) {
        self.name = name
    }
}
// 使用convenience增加init方法
extension People {
    convenience init(smallName: String) {
        self.init(name: smallName)
    }
}

// 子类
class Teacher: People {

    var course: String

    init(name: String, course: String) {
        self.course = course
        super.init(name: name)
    }

    override init(name: String) {
        self.course = "math"
        super.init(name: name)
    }
}

// 调用convenience的init方法
let xiaoming = Teacher(smallName: "xiaoming")

• 总结：子类的designated初始化方法必须调用父类的designated方法，以保证父类也完成初始化。

@dynamic && @objc

1，@objc
OC 是基于运行时，遵循了 KVC 和动态派发，而 Swift 为了追求性能，在编译时就已经确定，而不需要在运行时的，在 Swift 类型文件中，为了解决这个问题，需要暴露给 OC 使用的任何地方（类，属性，方法等）的生命前面加上 @objc 修饰符
如果用 Swift 写的 class 是继承 NSObject 的话， Swift 会默认自动为所有非 private 的类和成员加上@objc

在Swift中，我们在给button添加点击事件时，对应的点击事件的触发方法就需要用@objc来修饰

2，@dynamic
Swift 中的函数可以是静态调用，静态调用会更快。当函数是静态调用的时候，就不能从字符串查找到对应的方法地址了。这样 Swift 跟 Objective-C 交互时，Objective-C 动态查找方法地址，就有可能找不到 Swift 中定义的方法。

这样就需要在 Swift 中添加一个提示关键字，告诉编译器这个方法是可能被动态调用的，需要将其添加到查找表中。这个就是关键字 dynamic 的作用。

final

• final修饰符只能修饰类，表明该类不能被其他类继承，也就是它没资格当父类。
• final修饰符也可以修饰类中的属性、方法和下标，但前提是该类并没有被final修饰过。
• final不能修饰结构体和枚举。

final正确的使用场景 - 权限控制
也就是说这个类或方法不希望被继承和重写，具体情况如下：

• 类或者方法的功能确实已经完备了
  这种通常是一些辅助性质的工具类或者方法，特别那种只包含类方法而没有实例方法的类。比如MD5加密类这种，算法都十分固定，我们基本不会再继承和重写。

• 避免子类继承和修改造成危险
  有些方法如果被子类继承重写会造成破坏性的后果，导致无法正常工作，则需要将其标为final加以保护。

• 为了让父类中某些代码一定会执行
  父类的方法如果想要其中一些关键代码在继承重写后仍必须执行（比如状态配置、认证等）。我们可以把父类的方法定义成final，同时将内部可以继承的部分剥离出来，供子类继承重写。下面通过一段代码演示：

class Parent {
   final func method1() {
       //权限验证（必须执行）
       //.....

       method2()

       //下面是日志记录（必须执行）
       //..........
   }

   func method2(){
       //父类的实现
       //......
   }
}

class Child : Parent {
   //只能重写父类的method2方法，不能重写method1方法
   override func method2() {
       //子类的实现
       //......
   }
}

mutating
在Swift中，包含三种类型(type): structure,enumeration,class
其中structure和enumeration是值类型(value type),class是引用类型(reference type)
Swift中protocol的功能比OC中强大很多，不仅能再class中实现，同时也适用于struct、enum。但是struct、enum都是值类型，每个值都是有默认的，所以在实例方法中不能改变，因此就要用mutating关键字，这个关键字可以让在此方法中值的改变，会返回到原始结构里边

protocol Vehicle {
    var numberOfWheels: Int {get}
    var color: UIColor {get set}
    mutating func changeColor()
}

struct MyCar: Vehicle {
    let numberOfWheels = 4
    var color = UIColor.blue
    mutating func changeColor() {
        color = .red
    }
}

subscript

• 下标（subscript）在数组和字典中使用，但是你可以给任何类型（枚举，结构体，类）增加 下标subscript 的功能；
• subscript的语法类似实例方法、计算属性，其本质就是方法；

struct Person {
    var age = 0
    var no  = 0
    subscript(index: Int) -> Int {
        set {
            if index == 0 {
                age = newValue
            } else {
                no = newValue
            }
        }
        get {
            if index == 0 {
                return age
            } else {
                return no
            }
        }
    }
}

var p = Person()
p[0] = 10
p[1] = 20

print(p.age)  // 10
print(p[0])   // 10

print(p.no)  // 20
print(p[1])  // 20

• subscript 的返回值类型决定了：
  1.get 方法的返回值类型；
  2.set 方法中 newValue 的类型；
• subscript 可以接受多个参数，并且是任意类型；
• subscript 可以没有 set 方法，但必须要有 get 方法；
• 如果只有 get 方法，可以省略；

struct Person {
    var age = 30

    subscript(index: Int) -> Int {
        if index == 0 {
            return age
        } else {
            return age * 2
        }
    }
}

var p = Person()
print(p[0])  // 30
print(p[1])  // 60

nonmutating

nonmutating关键字，一般配合set使用。如

protocol Settings {
    subscript(key: String) -> AnyObject? { get nonmutating set }
}

它告诉编译器不会修改实例内部的值，也就是set时，不会改变任何其他的变量。

struct Test2 {

    var b: Int {
        get {
            return  2
        }
        nonmutating set {
            print("/(newValue)")
        }
    }
}

let t = Test2()
t.b = 3
print(t.b)

unowned && weak

• weak:弱引用对象的引用计数不会+1, 必须为可选类型变量
  在声明弱引用对象是必须用var关键字, 不能用let.
  因为弱引用变量在没有被强引用的条件下会变为nil, 而let常量在运行的时候不能被改变.

class XDTest {
    //会报错
    weak let tentacle = Tentacle() //let is a constant! All weak variables MUST be mutable.
}

• unowned:相当于__unsafe_unretained, 不安全. 必须为非可选类型.
  unowned引用是non-zeroing(非零的), 在ARC销毁内存后，不会被赋为nil, 这表示着当一个对象被销毁时, 它指引的对象不会清零. 也就是说使用unowned引用在某些情况下可能导致dangling pointers(野指针). 所以在访问无主引用的时候，要确保其引用正确，不然会引起内存崩溃.

throw && rethrow

• throws的使用很简单，只需要在可能出现异常的函数或者方法后面添加throws。
  经过这个关键字修饰的函数，在调用的时候，需要程序员加上do-catch来调用.
• rethrows是异常往上传递的关键字。上面说了throws用在可能出现异常的函数或者方法中，而rethrows针对的不是函数或者方法的本身，而是它携带的闭包类型的参数，当它的闭包类型的参数throws的时候，我们要使用rethrows继续将这个异常往上传递， 直到被调用者使用到。这相比throws多一个传递的环节。

@dynamicMemberLookup
这个特性中文可以叫动态查找成员。在使用@dynamicMemberLookup标记了对象后（对象、结构体、枚举、protocol），实现了subscript(dynamicMember member: String)方法后我们就可以访问到对象不存在的属性。如果访问到的属性不存在，就会调用到实现的 subscript(dynamicMember member: String)方法，key 作为 member 传入这个方法。

@dynamicMemberLookup
struct Person {
   subscript(dynamicMember member: String) -> String {
       let properties = ["nickname": "Zhuo", "city": "Hangzhou"]
       return properties[member, default: "undefined"]
   }
}

//执行以下代码
let p = Person()
print(p.city)
print(p.nickname)
print(p.name)

dynamic：这意味着对这个成员的访问是使用 Objective-C运行时进行动态派发的。

{
//隐式指明含有 "objc" 属性
//这对依赖于 Objc-C 黑魔法的库或者框架非常有用
//比如 KVO、KVC、Swizzling
dynamic var name:String?
}

image

@autoclosure，他可以让我们的表达式自动封装成一个闭包。