字典

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

var dict: [String: String] = ["abacus": "算盘", "abnormal": "异常的", "hello" : "你好", "good": "好的"]

通过键获取对应的值(可空类型, 因为给的键有可能没有与之对应的值)

print(dict["hello"]!)
print(dict["abcxyz"])

输出结果为：

你好
nil

• 添加元素

dict["apple"] = "🍎"
dict["delicious"] = "美味的"
print(dict)

• 删除元素

dict["hello"] = nil

或者
dict.removeValueForKey("hello")

• 修改元素

dict["shit"] = "牛粪"
print(dict)

• 遍历字典中所有的值

for value in dict.values {
    print(value)
}

• 遍历字典中所有的键

for key in dict.keys {
    print("\(key) ---> \(dict[key])")
}

• 直接通过一个元组获得字典中的键和值(原始类型)

for (key, value) in dict {
    print("\(key) ---> \(value)")
}

函数

• 定义函数：
  func 函数名(参数列表) -> 返回类型 { 函数的执行体 }
  Swift中函数的参数可以设定默认值
  如果调用函数的时候没有给该参数赋值就直接使用默认值

func sayHello(personName: String, alreadyGreeted: Bool = false) -> String {
if alreadyGreeted {
        return "怎么又是你, " + personName + "!"
    }
    else {
        return "你好, " + personName + "!"
    }
}

• 调用函数
  调用Swift的函数时, 在默认情况下从第二个参数开始需要写参数名,如果没有给第二个参数赋值那么就直接使用默认值false.
  print(sayHello("王大锤", alreadyGreeted: true))
  let str = sayHello("Jack")
  print(str)
  Swift中函数的参数列表可以是可变参数列表(参数的个数是任意多个)

func sum(nums: Int...) -> Int {
    var total = 0
    for num in nums {
        total += num
    }
    return total
}
print(sum())
print(sum(999))
print(sum(90, 82, 37, 68, 55, 11, 99))

inout - 输入输出参数(不仅将数据传入函数还要从函数中取出数据)

func createX(inout x: Int) {
    x = 1000
}
var x = 1

• 函数实例
  设计一个函数传入两个正整数m和n, 计算从m加到n的和

func sum(m: Int, _ n: Int) -> Int {
    let (a, b) = m > n ? (n, m) : (m, n)
    var value = 0
    for i in a...b {
        value += i
    }
    return value
}
print(sum(1, 100))

实现函数的过滤，映射，缩减

• 过滤
  let newArray1 = array.filter { $0 > 50 }
  print(newArray1)
• 映射
  let newArray2 = array.map { $0 * $0 }
  print(newArray2)
• 缩减

let result1 = array.reduce(0, combine: +)
print(result1)
let result2 = array.reduce(1, combine: *)
print(result2)
let result3 = array.reduce(array[0]) {
    $1 > $0 ? $1 : $0
}
print(result3)

闭包

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

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 sum
}

  let a = [1, 2, 3, 4, 5]

当调用foo函数时第二个参数可以传什么?

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

print(foo(a) { (a, b) -> Int in
    return a + b
})
print(foo(a) { $0 + $1 })

面向对象

面向对象（OOP）是现代流行的程序设计方法，是一种主流的程序设计规范。其基本思想是使用对象、类、继承、封装、属性、方法等基本概念来进行程序设计。从现实世界中客观存在的事物出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。
面向对象有三步：
步骤1: 定义类(如果你要用的类苹果已经提供了就直接进入第2步)，定义类就可以创建出新的类型
步骤2: 创建对象(调用初始化方法)
步骤3: 给对象发消息(通过给对象发消息来解决问题)
实例：

class Student {
    // 变量定义到类的外面就叫变量 - variable
    // 变量定义到类的里面就叫属性 - property
    // 数据抽象 - 找到和学生相关的属性(找名词)
    var name: String
    var age: Int
    // 初始化方法(构造方法/构造器) - constructor
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    // 函数写到类的外面就叫函数 - function
    // 函数写到类的里面就叫方法 - method
    // 行为抽象 - 找到和学生相关的方法(找动词)
    func eat() {
        print("\(name)正在吃饭.")
    }
    func study(courseName: String) {
        print("\(name)正在学习\(courseName).")
    }
}
let stu1 = Student(name: "骆昊", age: 35)
stu1.eat()
stu1.study("Swift程序设计")
let stu2 = Student(name: "王大锤", age: 15)
stu2.eat()
stu2.study("中国近代史")

Swift中使用初始化方法来创建并初始化对象，我们可以在一个类中定义多个初始化方法，而且提供了一种叫做便利初始化方法（调用了其他的初始化方法的初始化方法）的语法，便利初始化方法会调用指派初始化方法来创建对象。
示例：

class Point {
    var x: Double
    var y: Double
    // 便利初始化方法
    convenience init() {
        self.init(x: 0, y: 0)
    }
    // 便利初始化方法
    convenience init(point: (Double, Double)) {
        self.init(x: point.0, y: point.1)
    }
    // 指派初始化方法 
    init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }
    
    func distanceTo(other: Point) -> Double {
        let dx = x - other.x
        let dy = y - other.y
        return sqrt(dx * dx + dy * dy)
    }
}

继承

在Swift中， 一个类可以继承另一个类的方法，属性和其它特性。当一个类继承其它类，继承类叫子类，被继承类叫父类。一旦某个类继承了它的父类，就同时有了父类的属性和方法。在子类中可以重写父类的方法也可以调用父类的方法。

class Cat: Pet {
    // 父类有的方法子类可以重新实现，这个过程叫方法重写
    // 需要在方法前添加override关键字
    override func play() {
        super.play()      //调用父类方法
        print("\(nickname)正在玩毛线球.")
    }
    
    override func shout() {
        print("\(nickname): 喵喵喵……")
    }
}

类扩展

如果在某个特定的应用场景中你发现现有的类缺少了某项功能，那么可以通过类扩展(extension)的方式现场添加这项功能

extension Point {
    var cgPoint: CGPoint {
        get { return CGPointMake(CGFloat(x), CGFloat(y)) }
    }
}

多态

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

1. 方法重写(子类在继承父类的过程中对父类已有的方法进行重写, 而且不同的子类给出各自不同的实现版本)
2. 对象造型(将子类对象当成父类型来使用)

let empsArray = [
    Manager(name: "王大锤"),
    Programmer(name: "余婷"),
    Salesman(name: "广告莎")]
for emp in empsArray {
    if let worker = emp as? Programmer {
        print("请输入\(worker.name)本月工作时间: ", terminator: "")
        worker.workingHour = inputInt()
    }
    else if let worker = emp as? Salesman {
        print("请输入\(worker.name)本月销售额: ", terminator: "")
        worker.sales = inputDouble()
    }
    print("\(emp.name)本月工资为: ￥\(emp.salary)元")
}

• 面向对象终极原则: 高内聚, 低耦合
  面向对象七原则:
  1. 单一职责原则(SRP)
  2. 开闭原则(OCP)
  3. 依赖倒转原则(面向抽象编程, DIP)
  4. 里氏替换原则(LSP) - 能用父类型的地方就一定可以使用子类型
  5. 接口隔离原则(ISP)
  6. 合成聚合复用原则(CARP)
  7. 迪米特法则(LoD)