今天没有没有心灵砒霜。
那是因为独木舟曾说过——那一刻你的心里有场海啸，可你静静地，没让任何人知道......

Point 1：集合

//1.集合的创建
var a:Set<Int> = [2,3,12,24,3,2]
//其实集合的创建多了个Set类型

print(a)
//打印结果：[12,24,2,3]
//这里排除了所有重复的元素，并且由哈希算法进行的无序排位

//2.集合的元素添加以及删除
a.insert(100)
//在集合a中插入"100"这个元素
a.remove(2)
//在集合a中删除"2"这个元素

//3.集合的运算
var a:Set<Int> = [2,3,12,24,3,2]
var b: Set<Int> = [3, 5, 7, 9, 11]
a.intersect(b)
//交集（a和b都有的元素）
//打印结果为：[3]
a.union(b)
// 并集(a和b的所有元素)
//打印结果为：[12, 2, 9, 5, 7, 24, 3, 11]
print(a.subtract(b))
// 差集(a有b没有的元素)
//打印结果为:[12, 24, 2]

Point 2：字典——是语言就该有字典，程序语言也不例外

①.字典是存放键值对组合的容器，字典中的每个元素都是由两部分构成的, 冒号前面是键冒号后面是值。

var dict: [String : String] = ["1" : "吃饭" , "2" : "睡觉" , "3" : "打豆豆"]
//字典的定义

print(dict["1"])
//过键获取对应的值
//打印结果：吃饭

②.元素的增删改

//元素的添加
dict["4''] = "去成都看海" //关键字[键] = 值 和数组有点相似
print(dict)
//打印结果： ["1" : "吃饭" , "2" : "睡觉" , "3" : "打豆豆" , "4" : "去成都看海"]

//元素的删除
dict.removeValueForKey("2")
print(dict)
//打印结果：["1" : "吃饭" , "3" : "打豆豆" , "4" : "去成都看海"]

dict["3"] = nil
print(dict)
//["1" : "吃饭" , "4" : "去成都看海"]

//元素的修改
dict["4"] = "去成都看海看海看海"
print(dict)
//["1" : "吃饭" , "4" : "去成都看海看海看海"]

③.字典的遍历——和数组一样有 字典名.属性（属性通常是keys、values）

//// 遍历字典中所有的值
for value in dict.values {
    print(value)
}

// 遍历字典中所有的键
for key in dict.keys {
    print("\(key) ---> \(dict[key])")
}

// 直接通过一个元组获得字典中的键和值(原始类型)___★★★★★
          
for (key, value) in dict {
    print("\(key) ---> \(value)")
}

Point 3：数组又解

let array = [23, 37, 96, 55, 40, 92, 68, 88]

// 1. 过滤
let newArray1 = array.filter { $0 > 50 }
print(newArray1)
//打印结果：[96, 55, 92, 68, 88]

let newArray2 = array.filter { $0 % 2 == 0 }
print(newArray2)
//打印结果：[96, 40, 92, 68, 88]
// 2. 映射
let newArray3 = array.map { $0 * $0 }
print(newArray3)
//打印结果：[529, 1369, 9216, 3025, 1600, 8464, 4624, 7744]

// 3. 缩减
let result1 = array.reduce(0, combine: +)
print(result1)
//打印结果：499

Point 4：函数

//函数的构建
由关键字func引导 + 函数名(参数)+ -> 返回值类型 {
      函数体
      //如果函数的返回类型不是void 那么函数中一定有return语句
}
例：
func sayHello(personName: String) -> String {
    let greeting = "Hello, " + personName + "!"
    return greeting
print(sayHello("Xyk_"))

// 调用Swift的函数时, 在默认情况下从第二个参数开始需要写参数名
//第一个参数名加上，第二个到以后的参数名都加上，就构成了外部参数名。
//录入时记得加上（代码提示功能会自动补全）
func sum(a a:Int = 0,b b:Int = 0,c c:Int = 0) -> Int{
    return a + b + c
}
print(sum())
print(sum(a: 1, b: 2, c: 3))
// 函数调用传参都是传值

// Swift中函数的参数列表可以是可变参数列表(参数的个数是任意多个)
func sum(nums: Int...) -> Int {
    var total = 0
    for num in nums {
        total += num
    }
    return total
}

inout 用于内部函数名前面，不仅可以作为输入参数还可以作为输出函数
// inout - 输入输出参数(不仅将数据传入函数还要从函数中取出数据)
func createX(inout x: Int) {
    x = 1000
}

var x = 1
// inout类型的参数前要加上&符号
createX(&x)
print(x)
// 可以使用元组(tuple)让函数一次返回多条数据

函数的扩展
在Swift中函数是一种类型
这也就意味着函数可以作为变量或常量的类型
同理函数也可以作为另一个函数的参数或返回值

func sum(a a: Int,  b: Int) -> Int {
    return a + b
}

// 当调用foo函数时第二个参数可以传什么?
func foo(array: [Int], fn: (Int, Int) -> Int) -> Int {
    var sum = array[0]
    for x in array[1..<array.count] {
        sum = fn(sum, x)
    }
    return 0
}

func sum(a: Int, _ b: Int) -> Int {
    return a + b
}


let a = [1, 2, 3, 4, 5]
//回答如下：
// 1. 所有自定义的(Int, Int) -> Int类型的函数
print(foo(a, fn: sum))
// 2. 传入已有的二元运算符: +-*/%(因为运算符也是函数)
print(foo(a, fn: +))
// 3. 传入匿名函数(闭包)
// 3.1 完整的闭包写法
print(foo(a, fn: { (a, b) -> Int in
    return a + b
}))
// 3.2 省略掉类型和不必要的括号
print(foo(a, fn: { a, b in a + b }))
// 3.3 省略参数名
print(foo(a, fn: { $0 + $1 }))
// 3.4 尾随闭包
print(foo(a) { (a, b) -> Int in
    return a + b
})
print(foo(a) { $0 + $1 })

// 如果函数的最后一个参数是闭包可以写成尾随闭包的形式
// 也就是将闭包放到函数参数的圆括号外面写在一对花括号中
// 如果函数后面有尾随闭包且函数的圆括号中没有参数
// 那么函数的圆括号也可以省略(仅限于有尾随闭包的场景)
array.sortInPlace { $0 > $1 }

Point5：自定义类

步骤1: 定义类(如果你要用的类苹果已经提供了就直接进入第2步)

class 类名 {
       定义类的属性，
      //var name: String

     // 初始化方法(构造方法/构造器) - constructor
      init(参数:类型) { //例如：name: String 是要传出去调用的
     //self.name = name 因为重名，所以用self
      }

   func 方法名 {
       方法的执行体
    }
}

步骤2: 创建对象(调用初始化方法)

let stu1 = 类名(参数名:参数值)

步骤3: 给对象发消息(通过给对象发消息来解决问题)

stu1.上述的方法名() 

类的拓展1
知识点：
1.1 级联编程
1.2 运算符重载
1.3 注释

这次以一个例题来讲解这三个知识点——分数的计算
本次的分数计算的代码有点多，仅写一个加法方法的注释块代码来演示，所以我在这里先将里面的大纲提取出来：
　　1.首先先创建一个叫做Fraction的分数类，其中包含分子分母的存储属性定义、初始化函数的构造
　　2.分别写上加减乘除的方法，其中的参数是另一个Fraction，返回值类型也是Fraction类型。_num * other._num 就表示自身有的分子和传入的分子相乘。
　　3.对相乘后的函数进行简化（simplify()）和符号正规化（normalize()）——ps:gcd()函数用于分数的化简
　　4.最后是函数的运算符重载

代码演示：

// 短除法 -  x和y的最大公约数跟y%x和x的最大公约数是一样的
func gcd(x: Int, _ y: Int) -> Int {  //求最大公约数函数
    if x > y {
        return gcd(y, x)
    }
    else if y % x != 0 {
        return gcd(y % x, x)
    }
    else {
        return x
    }
}

//创建一个叫做Fraction的类
class Fraction {
    private var _num: Int //分子
    private var _den: Int //分母
    
    var info: String {
        get {
            return _num == 0 || _den == 1 ? "\(_num)" : "\(_num)/\(_den)"
        }
    }

    init(num: Int, den: Int) {
        _num = num
        _den = den 
    }
    /**
    加法函数
    - parameter other: 传入的另外一个Fraction类型的参数
    - returns: 返回的是一个数值
    */
    func add(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._den + other._num * _den, den: _den * other._den).simplify(). normalize()
    }

    func sub(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._den - other._num * _den, den: _den * other._den).simplify(). normalize()
    }

    func mul(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._num, den: _den * other._den).simplify(). normalize()
    }

    func div(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._den, den: _den * other._num).simplify(). normalize()
    }

    func normalize() -> Fraction { //符号正规化函数
        if _den < 0 {
            _num = -_num
            _den = -_den
        }
        return self
    }

    func simplify() -> Fraction { //化简函数
        if _num == 0 {
            _den = 1
        }
        else {
            let x = abs(_num)
            let y = abs(_den)
            let g = gcd(x, y)
            _num /= g
            _den /= g
        }
        return self
    }
}

// 运算符重载(为自定义的类型定义运算符)

func +(one: Fraction, two: Fraction) -> Fraction {
    return one.add(two)
}

func -(one: Fraction, two: Fraction) -> Fraction {
    return one.sub(two)
}

func *(one: Fraction, two: Fraction) -> Fraction {
    return one.mul(two)
}

func /(one: Fraction, two: Fraction) -> Fraction {
    return one.div(two)
}

类的拓展2
知识点解释：
2.1 级联编程
　　如上的四个函数，return的最后面的写法，先对分数进行化简，再把分数进行正规化显示。
2.2 运算符重载
　　将函数名换成符号，重调上面的相对应的函数，而此时的参数就需要调用两个了

2.3 注释
　　如上述的在（接下面）
/**

*/
之内的注释，将在你调用函数时显示名称，帮助代码阅读者理解，显示效果为：

屏幕快照 2016-08-13 10.30.45.png

类的拓展3
知识点：
　　3.1.继承：从已有的类创建新类的过程。其中提供继承信息的称为父类(超类/基类)，得到继承信息的称为子类(派生类/衍生类)。通常子类除了得到父类的继承信息还会增加一些自己特有的东西，所以子类的能力一定比父类更强大。
　　继承的意义在于子类可以复用父类的代码并且增强系统现有的功能

//创建一个宠物类：包含阿猫阿狗等小动物
//所以在这里就需要理清 —— 宠物是一个大类，即父类；
//阿猫阿狗等小动物是子类。子类继承父类的信息。
//因而，最初就应该创建一个包含了具有相同属性的父类——宠物类。
//代码演示如下：
enum Gender { //这是一个枚举类型来定义性别，之后可直接调用
    case Male
    case Female
}

class Pet {
    var nickname: String
    var gender: Gender
    var age: Int
    
    init(nickname: String, gender: Gender, age: Int) {
        self.nickname = nickname
        self.gender = gender
        self.age = age
    }
    
    func eat() {
        print("\(nickname)正在吃东西.")
    }
    
    func play() {
        print("\(nickname)正在玩耍.")
    }
    
    func shout() {
        print("\(nickname)发出了叫声.")
    }
}

class Dog: Pet { //这里的阿狗继承了宠物类
    var isLarge: Bool //只写特有属性
    
    init(nickname: String, gender: Gender, age: Int, isLarge: Bool) {
        self.isLarge = isLarge //只初始化特有属性
        super.init(nickname: nickname, gender: gender, age: age)
        //super调用父类公用的属性    
}
    
    override func play() {  //重写玩这个属性，稍后做解释
        print("\(nickname)正在接飞碟.")
    }

    override func shout() {
        print("\(nickname): 汪汪汪……")
    }
    
    func keepTheDoor() {
        if isLarge {
            print("\(nickname)正在看门.")
        }
        else {
            print("\(nickname)太小了，你怎么忍心放它出来看门？!!!")
        }
    }
}

此时就已经建立好了一个父类（Pet）和一个子类（Dog），接下来我们来看一下他们之间的调用。

let dog = Dog(nickname: "大黄", gender: .Male, age: 1, isLarge: true)
dog.play()
//打印结果：大黄正在接飞碟

如上所示：dog为Dog类，在创建时，会继承父类的属性信息，如：姓名，性别等等......而方法的重写又可以使子类的实现不一样的“行为”，在子类又可以实现自己的特有属性和特殊“行为”。

3.2 多态：同样的对象类型(Pet类型)接收相同的消息(调用相同的方法)，但是做了不同的事情，这就是多态(polymorphism)。

在简单的知道了多态之后，我们要如何创建一个多态呢？答案如下：

**实现多态的关键步骤: **
　①. 方法重写(子类在继承父类的过程中对父类已有的方法进行重写, 而且不同的子类给出各自不同的实现版本)

ps: 父类有的方法子类可以重新实现，这个过程叫方法重写；
     需要在方法前添加override关键字；
     重写有时也被称为置换/覆盖/覆写。
     如上的继承讲解里出现的一样：

    override func play() {  //重写玩这个属性，在这里做了解释
        print("\(nickname)正在接飞碟.")
}

②. 对象造型(将子类对象当成父类型来使用)

    //如上的继承一致，再创建一个阿猫类：
    class Cat: Pet {
    var hairColor: String?
    
    // 父类有的方法子类可以重新实现 这个过程叫方法重写
    // 需要在方法前添加override关键字
    // 重写有时也被称为置换/覆盖/覆写
    
    override func play() {
        print("\(nickname)正在玩毛线球.")
    }
    
    override func shout() {
        print("\(nickname): 喵喵喵……")
    }
    
    func catchTheMouse() {
        print("\(nickname)正在抓老鼠.")
    }
}

所以在这里就有两个类——阿狗类和阿猫类继承了宠物类

let petsArray = [
    Cat(nickname: "加菲", gender: .Female, age: 2),
    Dog(nickname: "大黄", gender: .Male, age: 1, isLarge: false) ]

for pet in petsArray {
    pet.eat()
    pet.play()

    pet.shout()
    // 可以通过if+as?将父类型安全的转换成子类型然后再调用子类特有方法
    if let dog = pet as? Dog {
        dog.keepTheDoor()
    }
    else if let cat = pet as? Cat {
        cat.catchTheMouse()
    }
}

//打印结果:
          加菲正在吃东西.
          加菲正在玩毛线球.
          加菲: 喵喵喵……
          加菲正在抓老鼠.
          大黄正在吃东西.
          大黄正在接飞碟.
          大黄: 旺旺旺……
          大黄太小了，你怎么忍心放它出来看门？!!!

根据以上的打印结果的解释—— 加菲和大黄吃的东西都在调用的父类的eat()这个方法，玩耍、嚎叫和各自的看家本领都是自己重写函数后的新体现，这就是多态，不同的类调用相同的方法，在复写后，执行出了不同的效果

若此时出现了人类，人类就不能继承这个宠物类了，用脚想都不会继承，也没有谁愿意继承。而人就是一个单独的、平行的类。
人类要领养动物时候，传入的参数则是宠物类，而不是阿猫阿狗类，详见代码：

class Person {
    var name: String
    var pet: Pet?       // Person和Pet之间是HAS-A(关联)
    
    init(name: String) {
        self.name = name
    }
    func adopt(pet: Pet) {
        print("\(name)领养了\(pet.nickname).")
        self.pet = pet
    }
    func play() {
        if let pet = pet {
            print("\(name)正在和\(pet.nickname)玩耍.")
        }
        else {
            print("\(name)正在吃手!")
        }
    }
}

let person = Person(name: "Xyk_")
let dog = Dog(nickname: "二黄", gender: .Male, age: 1, isLarge: true)
person.adopt(dog)
person.play()
//打印结果：
          王大锤领养了二黄.
          王大锤正在和二黄玩耍.

今天没有心灵鸡汤。
张嘉佳说：“云和海分居两地，人和人相聚别离。希望有一天听到你的消息，海醒过来，风吹过去，你正和花一起生活。我们互道再见，我们还会再见。”
　　　　　　　　　　　　　　　　　　　　　　　　　　　 ——写在最后