集合

集合：Set，定義一個(gè)集合可以寫成：var 集合名 : Set<集合類型> = [集合元素]，具體的集合應(yīng)用如下：

    var a : Set<Int> = [1,2,3,4,6,2,4,8,3,1,14]
    print(a)
    //添加、刪除元素
    a.insert(435)         //添加元素
    a.remove(2)           //刪除元素
    
    print(a)
    //集合遍歷
    for x in a {
        print(x)
    }
    
    var b:Set<Int> = [3,5,7,9,11]
    
    print(a.intersect(b)) //求交集(a和b都有的元素)
    print(a.union(b))     //求并集(a和b的所有元素)
    print(a.subtract(b))  //求差集(a有b沒有的元素)
    
    print(a == b)
    print(b.isSubsetOf(a))
    
    let c:Set<Int> = [1,3]
    print(c.isSubsetOf(a))   //判斷是不是c的子集
    print(c.isSupersetOf(a)) // 判斷a是不是c的超集
    
    let d:Set<Int> = [5,1000,1351351]
    print(a.isDisjointWith(d)) //判斷兩個(gè)集合是否相交

字典

與數(shù)組把相同類型的值存放在一個(gè)有序鏈表里不同，字典是把相同類型的值存放在一個(gè)無(wú)序集合里

//字典（存放鍵值對(duì)組合的容器）
//字典中的每個(gè)元素都是由兩部分構(gòu)成的，冒號(hào)前面是鍵，冒號(hào)后面是值

var dict:[String:String] = ["abacus":"算盤","abnormal":"異常的",
"hello":"你好","good":"好的"]
//通過鍵獲取對(duì)應(yīng)的值（可空類型，因?yàn)榻o的鍵有可能沒有與之對(duì)應(yīng)的值）
//key ----> value
print(dict["good"]!)
print(dict["abcdefw"])

//添加元素
dict["shit"] = "??"
dict["delicious"] = "美味的"
print(dict)

//刪除元素
//dict.removeValueForKey("hello")
dict["hello"] = nil
print(dict)
print(dict["hello"])

//修改元素
dict["shit"] = "??"
print(dict)

//遍歷字典中所有值
for value in dict.values {
    print(value)
}
//遍歷字典中所有的鍵
for key in dict.keys {
    print("\(key) ---> \(dict[key])")
}
//直接通過一個(gè)元組獲得字典中的鍵和值(原始類型)
for (key,value) in dict {
    print("\(key) ---> \(value)")
}

函數(shù)

函數(shù)是用來(lái)執(zhí)行特定任務(wù)的功能模塊，并且可重復(fù)使用
定義函數(shù)：
1.func 函數(shù)名(參數(shù)列表) -> 返回類型 {函數(shù)的執(zhí)行體}
2.Swift中函數(shù)的參數(shù)可以設(shè)定默認(rèn)值,如果調(diào)用函數(shù)的時(shí)候沒有給該參數(shù)賦值，就直接使用默認(rèn)值

func sayHello(personName:String,alreadyGreeted:Bool = false) -> String {
    // let greeting = "Hello," + personName + "!"
    // 如果函數(shù)的返回類型不是Void，那么函數(shù)中一定有return語(yǔ)句
    // return greeting
    // personName = "***" // 編譯錯(cuò)誤
    if alreadyGreeted {
        return "怎么又是你," + personName + "~"
    }
    else {
        return "你好," + personName + "!"
    }
    
}

調(diào)用函數(shù):
函數(shù)名(參數(shù)值),調(diào)用Swift的函數(shù)時(shí)，在默認(rèn)情況下從第二個(gè)參數(shù)開始需要寫參數(shù)名

print(sayHello("帝辛", alreadyGreeted: true))
// 如果沒有給第二個(gè)參數(shù)賦值，那么就直接使用默認(rèn)值false
let str = sayHello("姒癸")
print(str)

// 函數(shù)的參數(shù)名
// 函數(shù)名(外部參數(shù)名 內(nèi)部參數(shù)名：類型，外部參數(shù)名 內(nèi)部參數(shù)名：類型)
// 如果不寫外部參數(shù)名，那么內(nèi)部參數(shù)名也是外部參數(shù)名
// 可以使用下劃線_來(lái)作為外部參數(shù)名表示省略外部參數(shù)名
func myMin(a x:Int, b y:Int) -> Int {
    return x < y ? x :  y
}
// 調(diào)用函數(shù)的時(shí)候要寫外部參數(shù)名
print(myMin(a: 3,b: 5))

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

print(sum(a: 1,b: 2,c: 3))
print(sum())
print(sum(c: 100))
print(sum(c: 100,a: 200))

// Swift中函數(shù)的參數(shù)列表可以是可變參數(shù)列表(參數(shù)的個(gè)數(shù)是任意多個(gè))
func sum(nums: Int...) -> Int {
    var total = 0
    for num in nums {
        total  += num
    }
    return total
}

print(sum())
print(sum(32))
print(sum(1,2,3,4,2,3,486,48,5))
print(sum(1,23,36))


// 可以使用元組(tuple)讓函數(shù)一次返回多個(gè)結(jié)果
func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty {
        return nil
    }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

if let b = minMax([41,12,86,64,31,34,635,13,12,0,2,1]) {
    print(b.min)        //print(b.0)
    print(b.max)        //print(b.1)
}
else {
    print("數(shù)組中沒有元素")
}


func swap(inout a : Int ,inout _ b :Int ) -> Void {
    //(a, b) = (b, a)
    let temp = a
    a = b
    b = temp
}



var a = 15343 , b = 1553
// 函數(shù)調(diào)用傳參都是傳值
swap(&a, &b)
print("a = \(a)")
print("b = \(b)")

//    // inout - 輸入輸出參數(shù)(不僅將數(shù)據(jù)傳入函數(shù)還要從函數(shù)中取出數(shù)據(jù))
//    func createX(inout x: Int) {
//        x = 1000
//    }
//    var x = 1
//    // inout類型的參數(shù)前要加上&符號(hào)
//    createX(&x)
//    print(x)

//使用switch分支結(jié)構(gòu)
func sayHello(name:String) ->String {
    let date = NSDate()
    let cal = NSCalendar.currentCalendar()
    let hour = cal.component(.Hour, fromDate: date)
    
    let greeting: String
    
    switch hour {
    case 0...5:     // 不同的分支可以有重疊的部分
        greeting = "怎么還沒睡呀"
       // fallthrough   //繼續(xù)執(zhí)行下一個(gè)case(自動(dòng)執(zhí)行下一個(gè)分支)
    case 3...10:    //匹配了一個(gè)分支之后不再匹配其他的分支
        greeting = "早起的鳥兒有蟲吃"
    case 11...13:
        greeting = "中午好"
    case 14...18:
        greeting = "下午好"
    default:
        greeting = "晚上好"
    }
    return name + "," + greeting + "!"
}

print(sayHello("wuli小凡"))

// 設(shè)計(jì)一個(gè)函數(shù)傳入兩個(gè)整數(shù)m和n,計(jì)算從m到n的和

func sum(n: Int ,m: Int) -> Int {
    let (a, b) = m > n ? (n, m) : (m, n)
    var s = 0
    for i in a...b {
        s += i
    }
    return s
}
print(sum(5, m: 3))

// 設(shè)計(jì)一個(gè)函數(shù)輸入三條邊的長(zhǎng)度判斷能不能構(gòu)成三角形

func side(a:Int,b:Int,c:Int) -> Bool {
    let d = a + b > c && a + c > b && b + c > a ? true : false
    return d
}
print(side(12, b: 14, c: 27))

設(shè)計(jì)一個(gè)函數(shù)傳入年月日返回該日期是這一年的第幾天,下面是設(shè)計(jì)出的函數(shù)

func daysOfYear(year: Int,month: Int,day: Int) ->Int {
    var daysOfMonth = [31,28,31,30,31,30,31,31,30,31,30,31]
    var sum = 0
    if isLeapYear(year) && month > 2 {
        daysOfMonth[1] = 29
    }
    for days in daysOfMonth[0..<month - 1] {
        sum += days
    }
    return sum + day
}
func isLeapYear(year:Int) -> Bool {
    return year % 4 == 0 && year % 100 != 0 || year % 400 == 0
}

print(daysOfYear(2100, month: 9, day: 8))

求階乘
函數(shù)遞歸調(diào)用(一個(gè)函數(shù)直接或間接的調(diào)用自身)
1.遞歸公式
2.收斂條件

func factorial(n: Int) -> Double {
    if n == 0 || n == 1 {
        return 1
    }
    return Double(n) * f(n - 1)
}

var counter = 1

漢諾伊塔

漢諾伊塔游戲->
游戲目的：將a上的圈移動(dòng)到b上，且仍然是按照最大的圈在最下面最下的圈在最上面的順序依次放置。
規(guī)則：
1.在移動(dòng)的過程中一次只能移動(dòng)一個(gè)圈
2.在游戲過程中始終保證小圈在大圈上面

var counter = 1
func hanoi(n: Int, _ a: String, _ b: String, _ c: String) {
    if n > 0 {
        hanoi(n - 1, a, c, b)
        print("\(counter)\(a)--->\(b)")
        counter += 1
        hanoi(n - 1, c, b, a)
    }
}

// 用遞歸計(jì)算1 - n的和
func sum(n: Int) -> Int {
    if n == 1 {
        return 1
    }
    return n + sum(n - 1)
}

// 設(shè)計(jì)一個(gè)函數(shù)計(jì)算組合數(shù)(C(m,n)) = m!/(n!*(m-n)!)

    // 調(diào)用上面用遞歸方式設(shè)計(jì)出的階乘函數(shù)
    func combine(m: Int,n: Int) -> Int {
        //assert(m >= n,"m必須大于等于n")
        let p = factorial(m)
        let q = factorial(n)
        let r = factorial(m - n)
        let c = p / (q * r)
        
        return Int(c)
    }
    print(combine(5, n: 3))

閉包

閉包(Closures)是自包含的功能代碼塊，可以在代碼中使用或者用來(lái)作為參數(shù)傳值。
Swift 中的閉包與 C 和 Objective-C 中的代碼塊（blocks）以及其他一些編程語(yǔ)言中的 匿名函數(shù)比較相似。
全局函數(shù)和嵌套函數(shù)其實(shí)就是特殊的閉包。

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


func mul(a: Int, _ b: Int) -> Int {
    return a * b
}

在Swift中函數(shù)是一種類型,這也就意味著函數(shù)可以作為變量或常量的類型,同理函數(shù)也可以作為另一個(gè)函數(shù)的參數(shù)或返回值。

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]
// 當(dāng)調(diào)用foo函數(shù)時(shí)，第二個(gè)參數(shù)可以傳什么？
// 1.所有自定義的(Int, Int) -> Int類型的函數(shù)
print(foo(a, fn: sum))
// 2.傳入二元運(yùn)算符: + - * / %(因?yàn)檫\(yùn)算符也是函數(shù))
print(foo(a, fn: +))
// 3.傳入匿名函數(shù)(閉包)
// 3.1 完整的閉包寫法
print(foo(a, fn: { (a: Int, b: Int) -> Int in
    return a + b
//    return a * b
//    return a / b
//    return a - b
//    return a % b
}))
// 3.2 省略掉類型和不必要的括號(hào)
print(foo(a, fn: { a, b in a + b}))
// 3.3 省略參數(shù)名
print(foo(a, fn: {$0 + $1}))
// 3.4 尾隨閉包
print(foo(a) { (a, b) -> Int in
    return a + b
})    
print(foo(a) {$0 + $1})

// 數(shù)組排序使用閉包方法

var array = ["hello","game","water","cat","dog","elephant",
"monkey","food","young","fuyuanhui","love"]
// array.sortInPlace() 默認(rèn)升序
// array.sortInPlace(>)
// array.sortInPlace({ $0 > $1 })
// array.sortInPlace() {$0 > $1}
// array.sortInPlace {$0 > $1}
// 如果函數(shù)的最后一個(gè)參數(shù)是閉包可以寫成尾隨閉包的形式
// 也就是將閉包放到函數(shù)參數(shù)的圓括號(hào)外面寫在一對(duì)花括號(hào)中
// 如果函數(shù)后面有尾隨閉包且函數(shù)的圓括號(hào)中沒有參數(shù)
// 那么函數(shù)多圓括號(hào)也可以省略(僅限于有尾隨閉包的場(chǎng)景)
    //array.sortInPlace { (one: String, two: String) -> Bool in
    //    return one.characters.count > two.characters.count
    //}
// 可省略成:
array.sortInPlace {
    if $0.characters.count == $1.characters.count {
        return $0 > $1
    }
    return $0.characters.count > $1.characters.count
}
print(array)

數(shù)組使用閉包方法進(jìn)行過濾、映射和縮減：

let array = [23,46,87,5,66,18,53,12,2,48,3,1,42]

// 1.過濾
let newArray1 = array.filter {$0 > 50}
print(newArray1)

let newArray2 = array.filter {$0 % 2 == 0}
print(newArray2)

// 2.映射
let newArray3 = array.map { $0 * $0 }
print(newArray3)
let newArray4 = array.map {sqrt(Double($0))}
print(newArray4)
// 3.縮減
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)

let strArray = ["fu","yuan","hui"]
let result4 = strArray.reduce("") { $0 + "" + $1 }
print(result4)

類

Swift 類是構(gòu)建代碼所用的一種通用且靈活的構(gòu)造體。我們可以為類定義屬性（常量、變量）和方法。
與其他編程語(yǔ)言所不同的是，Swift 并不要求你為自定義類去創(chuàng)建獨(dú)立的接口和實(shí)現(xiàn)文件。你所要做的是在一個(gè)單一文件中定義一個(gè)類，系統(tǒng)會(huì)自動(dòng)生成面向其它代碼的外部接口。
如何定義一個(gè)類(過程)：

步驟1:定義類(如果你要用的類蘋果沒有那么就要自己定義了)

如果已經(jīng)有了就直接進(jìn)行第二步
定義類就可以創(chuàng)建出新的類型

    // 學(xué)生類
    class Student {
        // 變量定義到類的外面就叫變量 － variable
        // 變量定義到類的里面就叫屬性 － property
        // 數(shù)據(jù)抽象 － 找到和學(xué)生相關(guān)的屬性(找名詞)
        var name: String
        var age: Int
        
        // 初始化方法(構(gòu)造方法/構(gòu)造器) － constructor - 創(chuàng)建對(duì)象要使用的方法
        init(name: String, age: Int) {
            self.name = name
            self.age = age
        }
        
        // 函數(shù)寫到類的外面就叫函數(shù) － function
        // 函數(shù)寫到類的里面就叫方法 － method
        // 行為抽象 － 找到和學(xué)生相關(guān)的方法(找動(dòng)詞)
        func eat() {
            print("\(name)正在吃飯。")
        }
        
        func study(courseName: String) {
            print("\(name)正在學(xué)習(xí)\(courseName)。")
        }
        
        func watchTV() {
            if age >= 18 {
                print("\(name)正在觀看《人與自然》。")
            }
            else {
                print("親愛的\(name)，我們推薦你觀看《熊出沒》!")
            }
        }
    }

步驟2: 創(chuàng)建對(duì)象(調(diào)用初始化方法)

    let stu1 = Student(name: "張三", age: 30)

步驟3: 給對(duì)象發(fā)消息(通過給對(duì)象發(fā)消息來(lái)解決問題)

    stu1.study("Swift程序設(shè)計(jì)")
    stu1.eat()
    stu1.watchTV()

    let stu2 = Student(name: "小二", age: 15)
    stu2.eat()
    stu2.study("數(shù)學(xué)")
    stu2.watchTV()

例如：定義一個(gè)計(jì)算時(shí)間的類，用于報(bào)表：

    class Clock {
        var hour: Int
        var minute: Int
        var second: Int
        
        init() {
            let date = NSDate()
            let cal = NSCalendar.currentCalendar()
            hour = cal.component(.Hour, fromDate: date)
            minute = cal.component(.Minute, fromDate: date)
            second = cal.component(.Second, fromDate: date)
        }
        
        func showTime() -> String {
            return "\(hour):\(minute):\(second)"
        }
        
        func run() {
            second += 1
            if second == 60 {
                second = 0
                minute += 1
                if minute == 60 {
                    minute = 0
                    hour += 1
                    if hour == 24 {
                        hour = 0
                    }
                }
            }
        }
    }

    let clock = Clock()
    while true {
        print(clock.showTime())
        sleep(1)
        clock.run()
    }

下面是一個(gè)小游戲：系統(tǒng)產(chǎn)生一個(gè)1-100的隨機(jī)數(shù)讓人猜，如果猜大了就提示“大了”，猜小了就提示“小了”，直到猜對(duì)了給出提示“游戲結(jié)束”。
1??.首先定義一個(gè)能產(chǎn)生隨機(jī)數(shù)又能將人猜的數(shù)與之進(jìn)行比較的類：

// 將這個(gè)能產(chǎn)生隨機(jī)數(shù)的類稱之為機(jī)器人(Robot)
class Robot {
    // 數(shù)據(jù)抽象
    var answer: Int    // 正確答案
    var counter: Int   // 猜的次數(shù)
    var hint: String   // 提示信息
    
    // 初始化方法
    // 該保證所有的存儲(chǔ)屬性都被初始化(有值)
    init() {
        answer = Int(arc4random_uniform(100)) + 1
        counter = 0
        hint = ""
    }
    
    // 行為抽象
    // 判斷
    func judge(thyAnswer: Int) -> Bool {
        counter += 1
        if thyAnswer < answer {
            hint = "大一點(diǎn)"
        }
        else if thyAnswer > answer {
            hint = "小一點(diǎn)"
        }
        else {
            hint = "恭喜您猜對(duì)了！您一共猜了\(counter)次"
            return true
        }
        return false
    }
    
}

2??.在類以外調(diào)用機(jī)器人這個(gè)類以及類中的方法：

let r = Robot()
var isGameOver = false
repeat {
    print("請(qǐng)輸入你猜的數(shù)字: ",terminator:"")
    let thyAnswer = inputInt()
    isGameOver = r.judge(thyAnswer)
    print(r.hint)
}while !isGameOver

if r.counter > 7 {
    print("智商??！")
}
else if r.counter <= 3 {
    print("神")
}

奧特曼打怪獸

小時(shí)候看過的奧特曼打怪獸也可以設(shè)計(jì)成一個(gè)簡(jiǎn)單的游戲，游戲的設(shè)定是一群怪獸一起攻擊奧特曼，奧特曼有三種攻擊方式：普通攻擊、大招、群體魔法傷害，而怪獸只有普通攻擊，但是傷害比奧特曼的普通攻擊要高。
那么：
1.首先定義奧特曼類

func randomInt(min: UInt32, _ max: UInt32) -> Int {
    return Int(arc4random_uniform(max - min + 1) + min)
}

class Ultraman {
    private var _name: String
    private var _HP: Int
    private var _MP: Int
    
    var isAlive: Bool {
        get {
            return _HP > 0
        }
    }
    
    var name: String {
        get { return _name }
    }
    
    var HP: Int {
        get { return _HP }
        set { _HP = newValue > 0 ? newValue : 0 }
    }
    
    var MP: Int {
        get { return _MP }
    }
    
    init(name: String,HP: Int,MP: Int) {
        _name = name
        _HP = HP
        _MP = MP
    }
    
    func attack(monster: Monster) {
        let injury = randomInt(1740, 3605)
        monster.HP -= injury
        _MP = _MP + 50 > 13000 ? 13000 : _MP + 50
    }
    
//    func hugeAttack(monster: Monster) {
//        let ap  = randomInt(21350, 35481)
//        monster.HP -= ap
//        _MP -= 1250
//    }
    
    func hugeAttack(monster: Monster) {
        let injury = 
        monster.HP * 3 / 4 >= 500000 ? monster.HP * 3 / 4 : 500000
        monster.HP -= injury
        
    }
    
//    func magicalAttack(monsters: [Monster]) {
//        let AP = randomInt(10000, 15000)
//        for i in monsters {
//            i.HP -= AP
//        }
//        _MP -= 2000
//    }
    
    func magicalAttack(monsters: [Monster]) -> Bool {
        if self.MP >= 4000 {
            for monster in monsters {
                if monster.isAlive {
                    monster.HP -= randomInt(10000, 15000)
                }
            }
            _MP -= 2000
            return true
        }
        return false
    }
    
    
}

2.定義怪獸類

class Monster {
    private var _name: String
    private var _HP: Int
    
    var isAlive: Bool {
        get { return _HP > 0 }
    }
    
    var name: String {
        get {
            return _name
        }
    }
    
    var HP: Int {
        get {
            return _HP
        }
        set {
            _HP = newValue > 0 ? newValue : 0
//            if newValue > 0 {
//                _HP = newValue
//            }
//            else {
//                _HP = 0
//            }
        }
    }
    
    init(name: String,HP: Int) {
        _name = name
        _HP = HP
    }
    
    func attack(ultraman: Ultraman) {
        let injury = randomInt(8813, 16350)
        ultraman.HP -= injury
    }
}

3.創(chuàng)建對(duì)象調(diào)用這兩個(gè)類進(jìn)行游戲

// 奧特曼打怪獸

// 從一群怪獸中挑選一只活著的怪獸
func pickOneMonster(mArray: [Monster]) -> Monster {
    var monster: Monster
    repeat {
        let randomIndex = randomInt(0, UInt32(mArray.count - 1))
        monster = mArray[randomIndex]
    }while !monster.isAlive
    return monster
}

// 判斷怪獸是否全部死光
func isAllDead(mArray: [Monster]) -> Bool {
    for monster in mArray {
        if monster.isAlive {
            return false
        }
    }
    return true
}

let u = Ultraman(name: "夢(mèng)比優(yōu)斯", HP: 450000, MP: 38000)
let mArray = [
    Monster(name: "宇宙恐龍王杰頓", HP: 180000),
    Monster(name: "加拉雷斯", HP: 49000),
    Monster(name: "雷德王", HP: 68000)
]

//let m = Monster(name: "黑暗炸雞", HP: 120)
var round = 1
repeat {
    
    let m = pickOneMonster(mArray)
    
    let factor = randomInt(1, 10)
    switch factor {
    case 1...7:
        u.attack(m)
        if m.isAlive {
            m.attack(u)
        }
    case 8...9:
        print("\(u.name)奧特曼使用了寶塔鎮(zhèn)河妖技能")
        if u.magicalAttack(mArray) {
            for m in mArray {
                if m.isAlive {
                    m.attack(u)
                }
            }
        }
        else {
            u.attack(m)
            if m.isAlive {
                m.attack(u)
            }
        }
    default:
        print("\(u.name)奧特曼使用了動(dòng)感十字光波技能")
        u.hugeAttack(m)
    }

    u.attack(m)
    if m.isAlive {
        m.attack(u)
    }

鏈?zhǔn)骄幊?/h3>

在一個(gè)類中，有時(shí)為了方便而在init初始化的時(shí)候調(diào)用自身創(chuàng)建的方法以實(shí)現(xiàn)簡(jiǎn)化代碼等功能。
比如：
分?jǐn)?shù)的四則運(yùn)算：

普通方法找最大公約數(shù)

func gcd(x: Int, _ y: Int) -> Int {
    var a = x < y ? x : y
    while a > 1 {
        if x % a == 0 && y % a == 0 {
            return a
        }
        a -= 1
    }
    return 1
}

短除法(歐幾里德算法)找最大公約數(shù)

// x和y的最大公約數(shù)跟y%x和x的最大公約數(shù)是一樣的
// 找到分子和分母的最大公約數(shù)用于化簡(jiǎn)
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
    }
}


class Fraction {
    private var _num: Int
    private var _den: Int
    
    init(num: Int,den: Int) {
        _num = num
        _den = den
        normalize()    // 調(diào)用的自身所創(chuàng)建的方法
        simplify()    // 在每個(gè)運(yùn)算方法使用的時(shí)候自動(dòng)調(diào)用，就叫做鏈?zhǔn)骄幊?    }
    
    var info: String {
        get {
            return _num == 0 || _den == 1 ? "\(_num)" : "\(_num)/\(_den)"
        }
    }
    
    func add(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._den + other._num * _den , 
        den: _den * other._den)
    }

    func sub(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._den - other._num * _den , 
        den: _den * other._den)
    }
    
    func mul(other: Fraction) -> Fraction {
        return Fraction(num: other._num * _num, den: _den * other._den)
    }
    
    func divide(other: Fraction) -> Fraction {
        return Fraction(num: _num * other._den , den: _den * other._num)
    }
    
    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 normalize() -> Fraction {
        if _den < 0 {
            _num = -_num
            _den = -_den
        }
        return self
    }
    
    let f = Fraction(num: 3,den: -4)
    let f2 = Fraction(num: -8,den: 9)
    print(f.info)

    let f3 = f.add(f2)
    print(f3.info)

    let f4 = f.sub(f2)
    print(f4.info)

    let f5 = f.mul(f2)
    print(f5.info)

    let f6 = f.divide(f2)
    print(f6.info)

   
}

運(yùn)算符重載

在上面的分?jǐn)?shù)的運(yùn)算中將四種運(yùn)算簡(jiǎn)化，即運(yùn)算符重載，可以使得創(chuàng)建的對(duì)象調(diào)用該方法時(shí)更加簡(jiǎn)便
簡(jiǎn)化的過程(運(yùn)算符重載):

// 運(yùn)算符重載(為自定義的類型定義運(yùn)算符)

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.divide(two)
}

調(diào)用的過程:

let f = Fraction(num: 3,den: -4)
let f2 = Fraction(num: -8,den: 9)
print(f.info)

let f3 = f + f2 + f
print(f3.info)

let f4 = f - f2
print(f4.info)

let f5 = f * f2
print(f5.info)

let f6 = f / f2
print(f6.info)

便利構(gòu)造器和文檔注釋

便利構(gòu)造器就是創(chuàng)建類的時(shí)候進(jìn)行的舒適化方法也叫構(gòu)造方法或構(gòu)造器。
文檔注釋是用于創(chuàng)建對(duì)象調(diào)用類時(shí)產(chǎn)生的代碼提示消息，可以讓使用者了解到該類的方法和各種屬性。

文檔注釋的基本格式：

/**
名稱
parameter:
return:
*/

示例：

// 存儲(chǔ)屬性通常是private的 因?yàn)閿?shù)據(jù)要保護(hù)起來(lái)
// 方法一般是public的 因?yàn)榉椒ㄊ菍?duì)象接受的消息
// 如果自定義的類沒有打算在其他項(xiàng)目中使用 可以不寫訪問修飾符
// 直接使用默認(rèn)的internal修飾符表示在本項(xiàng)目中公開對(duì)其他項(xiàng)目私有

/// 學(xué)生類
public class Student {
    // 變量定義到類的外面就叫變量 － variable
    // 變量定義到類的里面就叫屬性 － property
    // 數(shù)據(jù)抽象 － 找到和學(xué)生相關(guān)的屬性(找名詞)
    private var _name: String
    private var _age: Int

    // 初始化方法(構(gòu)造方法/構(gòu)造器) － constructor - 創(chuàng)建對(duì)象要使用的方法
    
    /**
    初始化方法
    - parameter name: 名字
    - parameter age: 年齡
    */
    
    public init(name: String, age: Int) {
        _name = name
        _age = age
    }
    /**
    姓名隱去最后一個(gè)字符
     */
    var name: String {
        get {
            let value = _name.characters.count > 2 ? -2 : -1
            //let displayName = _name.substringToIndex(_name.endIndex
              .predecessor())
            let displayName = _name.substringToIndex(_name.endIndex
            .advancedBy(value))
            return displayName + "*"
        }
    }

    ///學(xué)生的年齡
    public var age: Int {
        get {return _age}
    }
    // 函數(shù)寫到類的外面就叫函數(shù) － function
    // 函數(shù)寫到類的里面就叫方法 － method
    // 行為抽象 － 找到和學(xué)生相關(guān)的方法(找動(dòng)詞)
    
    
    /**
    吃飯
    */
    public func eat() {
        print("\(_name)正在吃飯。")
    }

    /**
     學(xué)習(xí)     
     - parameter courseName: 課程的名稱
     - parameter hour: 學(xué)習(xí)時(shí)間
     - returns: 學(xué)會(huì)了返回true,沒有學(xué)會(huì)返回false
     */
    public func study(courseName: String,hour: Int) -> Bool {
        print("\(_name)正在學(xué)習(xí)\(courseName)。")
        return hour > 180 ? true : false
    }
    /**
     看??
     */
    public func watchTV() {
        if _age >= 18 {
            print("\(_name)正在觀看《人與自然》。")
        }
        else {
            print("親愛的\(_name)，我們推薦你觀看《熊出沒》!")
        }
    }
}

計(jì)算屬性

計(jì)算屬性就是將函數(shù)中的方法用屬性的形式表示出來(lái)。
比如：

    var hasMoreCards: Bool {
        get { return cardsArray.count > 0 }
    }
    
    // 它的原型是：
    func hasMoreCards() -> Bool {
        return return cardsArray.count > 0 ? true : false
    }

下面是一個(gè)比較綜合的實(shí)例用來(lái)詳細(xì)闡述了如何創(chuàng)建一個(gè)類，計(jì)算屬性怎么使用等等問題。這是一個(gè)撲克游戲，首先定義一個(gè)類產(chǎn)生一張撲克牌，其次定義一個(gè)類產(chǎn)生一副牌，再定義一個(gè)類生成玩家，最后通過調(diào)用這幾個(gè)類完成游戲。

1.定義一張撲克牌類：

// GET: 枚舉是定義符號(hào)常量的最佳方式
// GET: 符號(hào)常量總是優(yōu)于字面常量
/**
    花色的枚舉

- Spade:   黑桃??
- Heart:   紅心??
- Club:    梅花??
- Diamond: 方塊??
*/

enum Suite: String {
    //case Spade = "??",Heart = "??",Club = "??",Diamond = "??"
    case Spade = "??"
    case Heart = "??"
    case Club = "??"
    case Diamond = "??"
}

/// 一張牌
class Card {
    var suite: Suite
    var face: Int
    
    /**
     初始化方法
     - parameter suite: 花色
     - parameter face:  點(diǎn)數(shù)
     */
    init(suite: Suite,face: Int) {
        self.suite = suite
        self.face = face
    }
    /// 牌的信息
    var info: String {
        get {
            var str = suite.rawValue
            switch face {
            case 1: str += "A"
            case 11: str += "J"
            case 12: str += "Q"
            case 13: str += "K"
            default:
                str += "\(face)"
            }
            return str
        }
    }
    
}

2.定義一副撲克牌類：

func randomInt(min: UInt32,max: UInt32) -> Int {
    return Int(arc4random_uniform(max - min + 1) + min)
}

/// 一副牌
class Poker {
    var cardsArray: [Card] = []
    
    init() {
        
        reset()
    }
    
    /**
     重置所有的牌
     */
    func reset() {
        
        cardsArray.removeAll()
        let suitesArray = [Suite.Spade, .Heart, .Club, .Diamond]
        for suite in suitesArray {
            for face in 1...13 {
                let card = Card(suite: suite, face: face)
                cardsArray.append(card)
            }
        }
    }
    
    /**
     洗牌
     */
    func shuffle() {
        // 洗牌之前先重置所有的牌
        reset()
        // 通過隨機(jī)亂序的方式打亂牌的位置
        for i in 0..<cardsArray.count {
            let j = randomInt(0, max: UInt32(cardsArray.count - 1))
            (cardsArray[i],cardsArray[j]) = (cardsArray[j],cardsArray[i])
        }
    }
    
    /**
     發(fā)牌
     - returns: 當(dāng)前剩下牌中的第一張牌或nil
     */
    func deal() -> Card? {
        if hasMoreCards {
            return cardsArray.removeLast()
        }
        return nil
    }
    
    /// 判斷還有沒有更多的牌?
    var hasMoreCards: Bool {
        get { return cardsArray.count > 0 }
    }
    
//    func hasMoreCards() -> Bool {
//        return cardsArray.count > 0 ? true : false
//    }
}

3.定義玩家類：

func <(one: Card,two: Card) -> Bool {
    return one.face < two.face
}

class Player {
    var nickname: String
    var cardsOnHand: [Card] = []
    
    init(nickname: String) {
        self.nickname = nickname
    }
    // 玩家獲得牌的行為
    func getOneCard(card: Card) {
        cardsOnHand.append(card)
    }
    // 玩家給手里的牌排序的方法
    func sortCards() {
        cardsOnHand.sortInPlace(<)
    }
    
}

4.通過創(chuàng)建對(duì)象調(diào)用類中的方法來(lái)使用這副牌，從而達(dá)到游戲目的：

func showPlayerCards(player: Player) {
    print("\(player.nickname)",terminator:":")
    player.sortCards()
    for card in player.cardsOnHand {
        print(card.info,terminator:" ")
    }
    print("")
}

// 創(chuàng)建對(duì)象調(diào)用類生成游戲
let p = Poker()
p.shuffle()

let playersArray = [
    Player(nickname: "張三"),
    Player(nickname: "李四"),
//    Player(nickname: "王二"),
//    Player(nickname: "大錘")
]

//while p.hasMoreCards {
//    for player in playersArray {
//        if p.hasMoreCards {
//            player.getOneCard(p.deal()!)
//        }
//    }
//}

for _ in 1...2 {
    for player in playersArray {
        if p.hasMoreCards {
            player.getOneCard(p.deal()!)
        }
    }
}

for player in playersArray {
    showPlayerCards(player)
}

到這里一個(gè)撲克游戲就產(chǎn)生了！

類擴(kuò)展

類的擴(kuò)展：在已有的類的現(xiàn)有功能不能滿足使用需求的時(shí)候，通過擴(kuò)展類的功能從而達(dá)到從新利用的目的。
比如：擴(kuò)展系統(tǒng)自帶的類： UIColor

extension UIColor {
    
    static func randomColor() -> UIColor {
        let r = CGFloat(randomInt(0, 255)) / 255.0
        let g = CGFloat(randomInt(0, 255)) / 255.0
        let b = CGFloat(randomInt(0, 255)) / 255.0
        return UIColor(red: r, green: g, blue: b, alpha: 1)
    }
    
}

系統(tǒng)自帶的UIColor類沒有隨機(jī)顏色的產(chǎn)生方法，我們可以通過擴(kuò)展該類的功能，添加隨機(jī)顏色的方法以達(dá)到這樣的效果，這樣我們?cè)谠俅握{(diào)用UIColor的時(shí)候，就可以使用隨機(jī)顏色的方法了。

繼承

繼承我們可以理解為一個(gè)類獲取了另外一個(gè)類的方法和屬性。當(dāng)一個(gè)類繼承其它類時(shí)，繼承類叫子類，被繼承類叫父類（或超類、基類)在 Swift 中，類可以調(diào)用和訪問父類的方法和屬性，并且可以重寫它們。
例如：我們可以定義一個(gè)類->人，再定義兩個(gè)類分別是學(xué)生和老師，學(xué)生和老師都是人，因此可以通過繼承人這個(gè)類，復(fù)用父類的代碼增強(qiáng)系統(tǒng)現(xiàn)有功能。

1.父類：人

// 枚舉性別
enum Gender {
    case Male
    case Female
}
//人
class Person {
    var name: String
    var age: Int
    var gender: Gender
    
    init(name: String,age: Int,gender: Gender) {
        self.name = name
        self.age = age
        self.gender = gender
    }
    
    // 身為人的最基本行為
    func eat() {
        print("\(name) 正在吃飯")
    }
    
}

2.子類：老師、學(xué)生

繼承: 從已有到類創(chuàng)建新類的過程
提供繼承信息的類稱為父類(超類/基類)
得到繼承信息的稱為子類(派生類/衍生類)
通常子類除了得到父類的繼承信息還會(huì)增加一些自己特有的東西
所以子類的能力一定比父類更強(qiáng)大
繼承的意義在于子類可以復(fù)用父類的代碼并且增強(qiáng)系統(tǒng)現(xiàn)有的功能

老師類

class Teacher: Person {

    var title: String
    
    init(name: String,age: Int,gender: Gender,title: String) {
        self.title = title
        super.init(name: name, age: age, gender: gender)
    }
    
    
    func teach(courseName: String) {
        print("\(name)正在教學(xué)生\(courseName)")
    }
}

學(xué)生類

class Student:Person {

    var major: String
    
    init(name: String,age: Int,gender: Gender,major: String) {
        self.major = major
        super.init(name: name, age: age, gender: gender)
    }
    

    func study(courseName: String) {
        print("\(name)是\(major)專業(yè)的學(xué)生")
        print("\(gender == .Male ? "他" : "她")\(name)正在學(xué)習(xí)\(courseName)")
    }
    
    
    
}

3.創(chuàng)建對(duì)象調(diào)用類

let p1 = Person(name: "大鐵錘", age: 35, gender: .Male)
p1.eat()

// 我們可以將子類型的對(duì)象賦值給父類型的變量(因?yàn)樽宇惛割愔g是IS-A關(guān)系)
// 學(xué)生是人，老師也是人，所以學(xué)生和老師的對(duì)象可以賦值給人類型的變量
let p2: Person = Student(name: "高漸離", age: 29, gender: .Male, 
        major: "??擊筑")
p2.eat()

// 如果要將父類型的變量轉(zhuǎn)換成子類型需要用as運(yùn)算符進(jìn)行類型轉(zhuǎn)換
// 如果能夠確認(rèn)父類型的變量中就是某種子類型的對(duì)象可以用as!進(jìn)行轉(zhuǎn)換
// 如果不確定父類型的變量中是哪種子類型可以用as?嘗試轉(zhuǎn)換
(p2 as! Student).study("彈琴")
if let temp = p2 as? Teacher {
    temp.teach("IOS")
}
else {
    print("\(p2.name)不是老師！")
}

let p3 = Teacher(name: "雪女", age: 28, gender: .Female, title: "舞蹈")
p3.teach("民族舞")

多態(tài)

多態(tài)可以簡(jiǎn)單的理解為同樣的對(duì)象類型接收相同的消息(調(diào)用了相同的方法)，但是做了不同的事情(結(jié)果不一樣)。
實(shí)現(xiàn)多態(tài)的步驟主要有兩點(diǎn)：
1.方法重寫(子類在繼承父類的過程中對(duì)父類已有的方法進(jìn)行重寫，而且不同的子類給出各自不同的實(shí)現(xiàn)版本)
2.對(duì)象造型(將子類對(duì)象當(dāng)成父類型來(lái)使用)
具體如下代碼：

// 定義父類和父類中的方法及屬性
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)發(fā)出了叫聲.")
    }
    
}

// 定義不同的子類及其特有的屬性，重寫父類已有的方法

// 定義第一種寵物：貓
// Cat和Pet是IS-A關(guān)系
class Cat: Pet {
    var hairColor: String?
    
//    init(nickname: String, gender: Gender, age: Int , 
           hairColor: String) {
//        self.hairColor = hairColor
//        super.init(nickname: nickname, gender: gender, age: age)
//    }
    
    override func play() {
        super.play()
        print("\(nickname)正在玩毛線球.")
    }
    
    // 父類有的方法子類可以重新實(shí)現(xiàn) 這個(gè)過程叫方法重寫
    // 需要在方法前添加override關(guān)鍵字
    // 重寫有時(shí)也被稱為置換/覆蓋/覆寫
    override func shout() {
        print("\(nickname):  喵喵喵...")
    }
    
    func catchTheMouse() {
        print("\(nickname)正在抓??.")
    }
}

// 定義第二種寵物：狗 
class Dog: Pet {
    
    var isLarge: Bool
    var variety: String
    
    init(nickname: String, gender: Gender, age: Int, 
    isLarge: Bool, variety: String) {
        self.isLarge = isLarge
        self.variety = variety
        super.init(nickname: nickname, gender: gender, age: age)
    }
    
    func keepTheDoor() {
        if isLarge {
            print("\(nickname)正在看門...")
        }
        else {
            print("\(nickname)太小了誰(shuí)也咬不過...請(qǐng)不要讓它看門!")
        }
    }
    
    func porter() {
        print("\(nickname)正在看門...")
    }
    
    override func shout() {
        super.shout()
        print("\(nickname)正在狂吠...")
    }
    
    func bite() {
        print("\(nickname)正在咬人...")
    }
    
    override func play() {
        super.play()
        print("\(nickname)正在玩耍球球...")
    }
    
    func mate() {
        print("\(nickname)正在交配中...")
    }
}

// 使用
let petsArray = [
    Cat(nickname:"湯姆", gender: .Female, age: 5),
    Dog(nickname: "旺財(cái)", gender: .Male, age: 3, isLarge: true, 
    variety: "斗牛犬"),
    Cat(nickname:"加菲", gender: .Male, age: 4),
    Dog(nickname: "大黃", gender: .Male, age: 3, isLarge: false, 
    variety: "土狗"),
    Monkey(nickname: "六耳", gender: .Male, age: 3000, clever: true) 
]

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

    // 同樣的對(duì)象類型(Pet類型)接收相同的消息(調(diào)用相同的方法)
    // 但是做了不同的事情 這就是多態(tài)(polymorphism)
    // 實(shí)現(xiàn)多態(tài)的關(guān)鍵步驟:
    // 1.方法重寫(子類在繼承父類的過程中對(duì)父類已有的方法進(jìn)行重寫
    // 而且不同的子類給出各自不同的實(shí)現(xiàn)版本)
    // 2.對(duì)象造型(將子類對(duì)象當(dāng)成父類型來(lái)使用)
    pet.shout()

    // 可以通過if ＋ as?將父類型安全的轉(zhuǎn)換成子類型然后再調(diào)用子類特有的方法
    if let dog = pet as? Dog {
        dog.keepTheDoor()
    }
    else if let cat = pet as? Cat {
        cat.catchTheMouse()
    }
    else if let monkey = pet as? Monkey {
        monkey.perform()
    }
}

本周總結(jié)

本周學(xué)習(xí)的內(nèi)容相對(duì)于上一周來(lái)說(shuō)簡(jiǎn)直是呈幾何型增長(zhǎng)啊，但是每一個(gè)知識(shí)點(diǎn)都有著大量的練習(xí)，雖然有時(shí)候是比較懵，但是只要多多練習(xí)就能狗掌握了，在這一周的時(shí)間里，我感覺我不僅學(xué)習(xí)到了Swift的相關(guān)語(yǔ)法知識(shí)，還讓我對(duì)于編程有了更大的信心。相比較以前一看到代碼就范頭疼以及一看到代碼就不知道怎么寫的窘迫，現(xiàn)如今也大為改觀了，也許是許多事看起來(lái)很恐怖，但是真正做起來(lái)的時(shí)候會(huì)是另一番效果吧。而且現(xiàn)在寫起代碼來(lái)也比原來(lái)更有點(diǎn)感覺了，也知道大致的方向了，希望能夠在以后的學(xué)習(xí)時(shí)間里不再懵逼，不再迷茫。