簡單介紹一下Swift

Swift 語言由蘋果公司在 2014 年推出弊决，用來撰寫 OS X 和 iOS 應用程序胀糜，Swift語言讓應用開發(fā)更簡單观蜗、更快咧栗、更穩(wěn)定逆甜，確保最終應用有著更好的質量更多了解Swift可以去 《The Swift Programming Language》中文版，這次分享給大家是Swift基礎知識致板，如果你耐心看完本篇文章交煞，并且可以理解Swift的編程技巧和方法，恭喜你可以順利的使用Swift開發(fā)了斟或，已經(jīng)掌握了Swift的基本語法素征，想要真正從事蘋果開發(fā)，還需要在以后的學習中不斷探索和挖掘Swift
在接下來的文章中，直接深入主題御毅，不做過多沒必要的文字說明根欧，提高大家閱讀和吸收能力

一、常量和變量
常量：使用let來定義常量端蛆，定義之后不可以修改
變量：使用var來定義變量凤粗，定義之后可以修改
在使用過程中建議先定義常量,如果需要修改再修改為變量

import UIKit
let a : Int = 10
var b : Int = 20
b = 30 變量可以修改
// a = 20是錯誤的，常量是不能修改的

二今豆、數(shù)據(jù)類型
1嫌拣、類型介紹
Swift中的數(shù)據(jù)類型也有:整型/浮點型/對象類型/結構體類型等，整型分為有符號整型和無符號整型晚凿，例如Int亭罪、UInt，浮點型分為Float和Double

// 定義一個Int類型
var m : Int = 10
// 定義一個Double類型
let n : Double = 3.14

2歼秽、類型推導
Swift是強類型的語言爽冕，Swift中任何一個標識符都有明確的類型朗伶，如果定義一個標識符時有直接進行賦值,那么標識符后面的類型可以省略，Swift會自動根據(jù)后面的賦值來決定前面的標識符的數(shù)據(jù)類型，同時可以通過option+鼠標左鍵來查看變量的數(shù)據(jù)類型

Swift會自動識別a是整數(shù)吊说，如果之后再賦值給a一個其他類型(比如浮點型)數(shù)值,則會報錯
var a = 20
// 正確寫法
var b = 3.33
b = 6.66

3曙咽、基本運算
Swift中在進行基本運算時必須保證類型一致,否則會出錯去枷，相同類型之間才可以進行運算久免，Swift中沒有隱式轉換
Swift中數(shù)據(jù)類型的轉化，Int類型轉成Double類型是Double(標識符)谢揪，Double類型轉成Int類型是Int(標識符)

let a = 12
let b = 3.14

// 錯誤寫法蕉陋，形同類型之間才可以進行運算
// let c = a + b
// let c = a * b

// 正確寫法，轉換類型進行運算
let c = Double(a) + b
let d = a + Int(b)

三拨扶、邏輯分支
1凳鬓、分支的了解
分支即if、switch患民、三目運算符等判斷語句缩举，通過分支語句可以控制程序的執(zhí)行流程
2、if分支語句
和OC不同匹颤，Swift判斷句可以不加()仅孩，在Swift的判斷句中必須有明確的真假，不再有非0即真印蓖，必須有明確的Bool值辽慕，Bool有兩個取值:false、true赦肃，沒有Yes溅蛉、NO的使用

例1
確定值存在的判斷
let a = 12

// 錯誤寫法绞旅，在Swift的判斷句中必須有明確的真假，不再有非0即真
//if a {
//    print("a")
//}

// 正確寫法
if a > 9 {
    print(a)
}

例2
可選類型的判斷温艇，判斷如果view有值,則設置背景
let view : UIView? = UIView()
// 錯誤寫法
//if view {
//    view.backgroundColor = UIColor.red
//}

if view != nil {
    view!.backgroundColor = UIColor.red
}

3、三目運算符
Swift 中的 三目 運算符和 OC 的用法是一樣的

var a = 12
var b = 24

var result = a > b ? a : b
println(result)

4堕汞、guard的使用
guard是很重要的勺爱，在以后的開發(fā)中會經(jīng)常用到，來判斷該值是否是可選類型讯检，guard在Swift2.0就出現(xiàn)了琐鲁，與if語句非常類似，它設計的目的是提高程序的可讀性
guard語句必須帶有else語句人灼，當條件表達式為true時候跳過else語句中的內(nèi)容围段，執(zhí)行語句組內(nèi)容，條件表達式為false時候執(zhí)行else語句中的內(nèi)容投放，跳轉語句一般是return奈泪、break、continue和throw

例1
guard用法說明
guard 條件表達式 else {
    // 條換語句灸芳，走這里的都是錯誤的涝桅，判斷不符合要求的
    break
}
語句組，正確的執(zhí)行這里

例2
簡單使用guard的用法
 func gotToSchool(time:Int) -> Void {
        guard time > 6 else {
            print("去上學")
            return
        }
        print("不去上學")
    }
gotToSchool(time: 5)

5烙样、switch分支
Switch作為選擇結構中必不可少的語句也被加入到了Swift中冯遂，只要有過編程經(jīng)驗的人對Switch語句都不會感到陌生，蘋果對Switch進行了大大的增強谒获，使其擁有其他語言中沒有的特性
基本用法和OC用法一致蛤肌，switch后可以不跟()，case后可以不跟break(默認會有break)

例1
switch對整數(shù)的判斷

let sex = 0
switch sex {
case 0 :
    print("男")
case 1 :
    print("女")
default :
    print("其他")
}

例2
一個case判斷中,可以判斷多個值批狱，多個值以,隔開

let sex = 0
switch sex {
case 0, 1:
    print("正常人")
default:
    print("其他")
}

例3
希望出現(xiàn)之前的case穿透,則可以使用關鍵字fallthrough

let sex = 0
switch sex {
case 0:
    fallthrough
case 1:
    print("正常人")
default:
    print("其他")
}

Switch支持多種數(shù)據(jù)類型

① 浮點型的switch判斷

let f = 3.14
switch f {
case 3.14:
    print("π")
default:
    print("not π")
}

② 支持字符串類型

let m = 5
let n = 10
var result = 0

let opration = "+"

switch opration {
    case "+":
        result = m + n
    case "-":
        result = m - n
    case "*":
        result = m * n
    case "/":
        result = m / n
default:
    result = 0
}

③ switch支持區(qū)間判斷
開區(qū)間:0..<10 表示:0~9,不包括10
閉區(qū)間:0...10 表示:0~10

let score = 88
switch score {
case 0..<60:
    print("不及格")
case 60..<80:
    print("幾個")
case 80..<90:
    print("良好")
case 90..<100:
    print("優(yōu)秀")
default:
    print("滿分")
}

四裸准、循環(huán)
在開發(fā)中經(jīng)常會需要循環(huán)，常見的循環(huán)有：for精耐、while狼速、do while
1、for循環(huán)

① 傳統(tǒng)寫法
for var i = 0; i < 10; i++ {
    print(i)
}

② 區(qū)間for循環(huán)
for i in 0..<10 {
    print(i)
}

for i in 0...10 {
    print(i)
}

③ 特殊寫法
如果在for循環(huán)中不需要用到下標i卦停，用`_`標示
for _ in 0..<10 {
    print("hello")
}

2向胡、while和do while循環(huán)

① while的判斷句必須有正確的真假,沒有非0即真，while后面的()可以省略
var a = 0
while a < 10 {
    a++
}

② do while循環(huán)惊完，使用repeat關鍵字來代替了do
let b = 0
repeat {
    print(b)
    b++
} while b < 20

五僵芹、字符串
OC和Swift中字符串的區(qū)別，在OC中字符串類型時NSString,在Swift中字符串類型是String小槐，OC中字符串@"",Swift中字符串""
Swift中的String 是一個結構體拇派，性能更高荷辕，NSString 是一個 OC 對象，性能略差件豌，String 支持直接遍歷疮方，Swift 提供了 String 和 NSString 之間的無縫轉換，可以使用as或者as?進行轉換
1茧彤、遍歷字符串

// 字符串遍歷
var str = "Hello, Swift"
for c in str.characters {
    print(c)
}

2骡显、字符串拼接

例1
let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2

例2
let name = "why"
let age = 18
let info = "my name is \(name), age is \(age)"

例3
字符串的格式化
let min = 3
let second = 4
let time = String(format: "%02d:%02d", arguments: [min, second])

3、字符串的截取
Swift中提供了特殊的截取方式曾掂，該方式非常麻煩惫谤，簡單的方式是將String轉成NSString來使用，在標識符后加:as NSString即可

let myStr = "www.baidu.com"
var subStr = (myStr as NSString).substringFromIndex(4)
subStr = (myStr as NSString).substringToIndex(3)
subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))

六珠洗、數(shù)組
數(shù)組（Array）是一串有序的由相同類型元素構成的集合溜歪，數(shù)組中的集合元素是有序的，可以重復出現(xiàn)许蓖，swift數(shù)組類型是Array蝴猪，是一個泛型集合
1、數(shù)組的初始化
數(shù)組分成可變數(shù)組和不可變數(shù)組蛔糯，使用let修飾的數(shù)組是不可變數(shù)組拯腮，使用var修飾的數(shù)組是可變數(shù)組

// 定義一個可變數(shù)組，必須初始化才能使用
var array1 : [String] = [String]()

// 定義一個不可變數(shù)組
let array2 : [NSObject] = ["xiaoming", 18]

在聲明一個Array類型的時候可以使用下列的語句之一
var stuArray1:Array<String>
var stuArray2: [String]

聲明的數(shù)組需要進行初始化才能使用蚁飒，數(shù)組類型往往是在聲明的同時進行初始化的
// 定義時直接初始化
var array = ["xm", "xl", "my"]

// 先定義,后初始化
var array : Array<String>
array = ["xm", "xl", "my"]

2动壤、對數(shù)組的基本操作

// 添加數(shù)據(jù)
array.append("xiaoming")

// 刪除元素
array.removeFirst()

// 修改元素
array[0] = "xiaoming"

// 取值
array[1]

3、數(shù)組的遍歷

// 遍歷數(shù)組
for i in 0..<array.count {
    print(array[i])
}

// forin方式淮逻，經(jīng)常使用
for item in array {
    print(item)
}

// 設置遍歷的區(qū)間
for item in array[0..<2] {
    print(item)
}

4琼懊、數(shù)組的合并

// 數(shù)組合并
// 注意：只有相同類型的數(shù)組才能合并
var array = ["xm", "xl","my"]
var array1 = ["haha", "wsz"]
var array2 = array + array1;

// 不建議一個數(shù)組中存放多種類型的數(shù)據(jù)
var array3 = [2, 3, "why"]
var array4 = ["yz", 23]
array3 + array4

七、字典
字典是由兩部分集合構成的爬早，一個是鍵（key）集合哼丈，一個是值（value）集合，鍵集合是不能有重復元素的筛严，而值集合是可以重復的醉旦，鍵和值是成對出現(xiàn)的，Swift字典類型是Dictionary桨啃，也是一個泛型集合
1车胡、Swift中的可變和不可變字典，使用let修飾的數(shù)組是不可變字典照瘾，使用var修飾的數(shù)組是可變字典

// 定義一個可變字典
var dict1 : [String : NSObject] = [String : NSObject]()

// 定義一個不可變字典
let dict2 = ["name" : "xl", "age" : 18]

在聲明一個Dictionary類型的時候可以使用下面的語句之一
var dict1: Dictionary<Int, String>
var dict2: [Int: String]

聲明的字典需要進行初始化才能使用匈棘，字典類型往往是在聲明的同時進行初始化的
// 定義字典的同時,進行初始化
var dict = ["name" : "why", "age" : 18]

// swift中任意對象,通常不使用NSObject,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name" : "why", "age" : 18]

2、字典的基本操作

// 添加數(shù)據(jù)
dict["height"] = 1.80
dict["weight"] = 65.0

// 刪除字段
dict.removeValueForKey("height")

// 修改字典
dict["name"] = "lmj"

// 查詢字典
dict["name"]

3析命、字典的遍歷

// 遍歷字典中所有的值
for value in dict.values {
    print(value)
}
// 遍歷字典中所有的鍵
for key in dict.keys {
    print(key)
}
// 遍歷所有的鍵值對
for (key, value) in dict {
    print(key)
    print(value)
}

4主卫、字典的合并

// 字典的合并
var dict1 = ["name" : "xl", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
    dict2[key] = value
}

八逃默、元組
元組是Swift中特有的,OC中并沒有相關類型，類似于數(shù)組或者字典簇搅，可以用于定義一組數(shù)據(jù)完域，組成元組類型的數(shù)據(jù)可以稱為“元素”
1、元組的定義

元組的常見寫法
// 使用元組描述一個人的信息
("1001", "張三", 30, 90)
// 給元素加上元素名稱,之后可以通過元素名稱訪問元素
(id:"1001", name:"張三", english_score:30, chinese_score:90)

2瘩将、元祖的簡單使用

// 元祖使用

// 寫法一:
let object = (xiaoming, "18")
print(object.0)
print(object.1)

// 寫法二:
let object = (name : xiaoming, age : "18")
print(object.name)
print(object.age)

// 寫法三:
let (name, age) = (xiaoming, "18")
print(name)
print(age)

九筒主、可選類型
在OC開發(fā)中,如果一個變量暫停不使用,可以賦值為0(基本屬性類型)或者賦值為空(對象類型)，在swift開發(fā)中鸟蟹，nil也是一個特殊的類型.因為和真實的類型不匹配是不能賦值的(swift是強類型語言)，但是開發(fā)中賦值nil使兔，在所難免建钥，因此推出了可選類型
可選類型的取值：空值或者有值
1、定義可選類型

// 寫法一:定義可選類型
let name : Optional<String> = nil

// 寫法二:定義可選類型,語法糖(常用)
let name : String? = nil

2虐沥、可選類型的使用

// 定義可選類型
var string : Optional<String> = nil

// 給可選類型賦值
string = "Hello world"

// 打印結果
print(string)
// 結果:Optional("Hello world")\n

// 取出可選類型的真實值(解包)
print(string!)
// 結果:Hello world\n

// 注意:如果可選類型為nil熊经，強制取出其中的值(解包)，會出錯
string = nil
print(string!) // 報錯

// 正確寫法:
if string != nil {
    print(string!)
}

// 簡單寫法:為了讓在if語句中可以方便使用string
// 可選綁定
if let str = string {
    print(str)
}

十欲险、函數(shù)
1镐依、函數(shù)介紹
函數(shù)相當于OC中的方法，函數(shù)的格式如下

func 函數(shù)名(參數(shù)列表) -> 返回值類型 {
    代碼塊
    return 返回值
}

func是關鍵字天试，多個參數(shù)列表之間可以用逗號（,）分隔槐壳，也可以沒有參數(shù)，使用箭頭“->”指向返回值類型喜每，如果函數(shù)沒有返回值务唐，返回值為Void.并且“-> 返回值類型”部分可以省略

2、常見的函數(shù)類型

① 沒有參數(shù)带兜，沒用返回值
func about() -> Void {
    print("iphone6s plus")
}
// 調(diào)用函數(shù)
about()

如果沒用返回值,Void可以寫成()
func about1() -> () {
    print("iphone6s plus")
}
// 如果沒有返回值枫笛，后面的內(nèi)容可以都不寫
func about2() {
    print("iphone6s plus")
}
about2()

② 有參數(shù)，沒用返回值
func callPhone(phoneNum : String) {
    print("打電話給\(phoneNum)")
}
callPhone("+86 110")

③ 沒用參數(shù)刚照，有返回值
func readMessage() -> String {
    return "吃飯了嗎?"
}
var str = readMessage()
print(str)

④ 有參數(shù)刑巧，有返回值
func sum(num1 : Int，num2 : Int) -> Int {
    return num1 + num2
}
var result = sum(20无畔，num2: 30)
print(result)

3啊楚、函數(shù)的使用
① 外部參數(shù)和內(nèi)部參數(shù)
在函數(shù)內(nèi)部可以看到的參數(shù),就是內(nèi)部參數(shù)，在函數(shù)外面可以看到的參數(shù),就是外部參數(shù)檩互，默認情況下,從第二個參數(shù)開始,參數(shù)名稱既是內(nèi)部參數(shù)也是外部參數(shù)特幔，如果第一個參數(shù)也想要有外部參數(shù)，可以設置標簽闸昨，在變量名前加標簽即可蚯斯，如果不想要外部參數(shù),可以在參數(shù)名稱前加_

// num1和a是外部參數(shù)的名稱
func ride(num1 num1 : Int, a num2 : Int, b num3 : Int) -> Int {
    return num1 * num2 * num3
}
var result1 = ride(num1: 20, a: 4, b: 5)

// 方法的重載:方法名稱相同薄风，但是參數(shù)不同，可以稱之為方法的重載(了解)
func ride(num1: Int, _ num2 :Int) -> Int {
    return num1 * num2
}

var result2 = ride(20, 20)

② 默認參數(shù)
如果沒有傳入具體的參數(shù),可以使用默認參數(shù)

func makecoffee(type :String = "卡布奇諾") -> String {
    return "制作一杯\(type)咖啡拍嵌。"
}

let coffee1 = makecoffee("鐵觀音")
let coffee2 = makecoffee()

③ 可變參數(shù)
Swift中函數(shù)的參數(shù)個數(shù)可以變化遭赂，它可以接受不確定數(shù)量的輸入類型參數(shù)，它們必須具有相同的類型横辆，我們可以通過在參數(shù)類型名后面加入（...）的方式來指示這是可變參數(shù)

func sum(numbers:Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(100.0, 20, 30)
sum(30, 80)

④ 引用類型(指針的傳遞)
默認情況下撇他，函數(shù)的參數(shù)是值傳遞，如果想改變外面的變量狈蚤，則需要傳遞變量的地址困肩，必須是變量，因為需要在內(nèi)部改變其值脆侮，Swift提供的inout關鍵字就可以實現(xiàn)

// 函數(shù)一：值傳遞
func swap(var a : Int, var b : Int) {
    let temp = a;
    a = b;
    b = temp
    print("a:\(a), b:\(b)")
}

var a = 10
var b = 20
swap(a, b: b)
print("a:\(a), b:\(b)")

// 函數(shù)二:指針的傳遞
func swap1(inout a : Int, inout b : Int) {
    let temp = a
    a = b
    b = temp

    print("a:\(a), b:\(b)")
}

swap1(&a, b: &b)
print("a:\(a), b:\(b)")

⑤ 函數(shù)的嵌套使用
swift中函數(shù)可以嵌套使用锌畸，即函數(shù)中包含函數(shù),但是不推薦該寫法
十一、類的使用
1靖避、類的介紹和定義
Swift也是一門面向對象開發(fā)的語言潭枣，面向對象的基礎是類，類產(chǎn)生了對象幻捏，class是Swift中的關鍵字盆犁，用于定義類

定義的類,可以沒有父類.那么該類是rootClass，通常情況下篡九，定義類時谐岁，繼承自NSObject(非OC的NSObject)
class 類名 : SuperClass {
    // 定義屬性和方法
}

2、定義類的屬性
Swift中類的屬性有多種：存儲屬性榛臼，存儲實例的常量和變量翰铡；計算屬性，通過某種方式計算出來的屬性讽坏；類屬性锭魔，與整個類自身相關的屬性
① 存儲屬性
存儲屬性是最簡單的屬性，它作為類實例的一部分路呜，用于存儲常量和變量迷捧，可以給存儲屬性提供一個默認值，也可以在初始化方法中對其進行初始化

// 給存儲屬性賦值
stu.age = 10
stu.name = "xiaoming"

stu.chineseScore = 89.0
stu.mathScore = 98.0

② 計算屬性
計算屬性并不存儲實際的值胀葱，而是提供一個getter和一個可選的setter來間接獲取和設置其它屬性漠秋，計算屬性一般只提供getter方法，如果只提供getter抵屿，而不提供setter庆锦，則該計算屬性為只讀屬性,并且可以省略get{}

class Student : NSObject {
    // 存儲屬性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0

    // 計算屬性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) / 2
        }

        // 沒有意義,因為之后獲取值時依然是計算得到的
        // newValue是系統(tǒng)分配的變量名，內(nèi)部存儲著新值
        set {
            self.averageScore = newValue
        }
    }
}

③ 類屬性
類屬性是與類相關聯(lián)的轧葛，而不是與類的實例相關聯(lián)搂抒，類屬性的設置和修改,需要通過類來完成艇搀，類屬性使用static來修飾

class Student : NSObject {
    // 類屬性
    static var corseCount : Int = 0
}

// 設置類屬性的值
Student.corseCount = 3
// 取出類屬性的值
print(Student.corseCount)

④ 監(jiān)聽屬性的改變
在OC中我們可以重寫set方法來監(jiān)聽屬性的改變，在Swift中可以通過屬性觀察者來監(jiān)聽和響應屬性值的變化求晶，通常是監(jiān)聽存儲屬性和類屬性的改變焰雕，(對于計算屬性，我們不需要定義屬性觀察者芳杏，因為我們可以在計算屬性的setter中直接觀察并響應這種值的變化)
willSet：在屬性值被存儲之前設置矩屁，此時新屬性值作為一個常量參數(shù)被傳入，該參數(shù)名默認為newValue爵赵，我們可以自己定義該參數(shù)名吝秕；didSet：在新屬性值被存儲后立即調(diào)用，與willSet相同空幻，此時傳入的是屬性的舊值郭膛，默認參數(shù)名為oldValue；
willSet與didSet只有在屬性第一次被設置時才會調(diào)用氛悬，在初始化時，不會去調(diào)用這些監(jiān)聽方法

class Person : NSObject {
    var name : String? {
        // 可以給newValue自定義名稱
        willSet (new){ // 屬性即將改變,還未改變時會調(diào)用的方法
            // 在該方法中有一個默認的系統(tǒng)屬性newValue耘柱，用于存儲新值
            print(name)
            print(new)
        }
        // 可以給oldValue自定義名稱
        didSet (old) { // 屬性值已經(jīng)改變了,會調(diào)用的方法
            // 在該方法中有一個默認的系統(tǒng)屬性oldValue如捅，用于存儲舊值
            print(name)
            print(old)
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在賦值時,監(jiān)聽該屬性的改變
// 在OC中是通過重寫set方法
// 在swift中,可以給屬性添加監(jiān)聽器
p.name = "xiaoming"

十二、類的構造函數(shù)
構造函數(shù)類似于OC中的初始化方法init方法调煎，默認情況下載創(chuàng)建一個類時,必然會調(diào)用一個構造函數(shù)镜遣，即便是沒有編寫任何構造函數(shù)，編譯器也會提供一個默認的構造函數(shù)士袄，如果是繼承自NSObject悲关，可以對父類的構造函數(shù)進行重寫
1、構造函數(shù)的基本使用
① 類的屬性必須有值娄柳，如果不是在定義時初始化值,可以在構造函數(shù)中賦值

class Person: NSObject {
    var name : String
    var age : Int
    // 重寫了NSObject(父類)的構造方法
    override init() {
        name = ""
        age = 0
    }
}

// 創(chuàng)建一個Person對象
let p = Person()

② 初始化時給屬性賦值
我們在創(chuàng)建一個對象時就會給屬性賦值寓辱，可以自定義構造函數(shù)，如果自定義了構造函數(shù),會覆蓋init()方法赤拒，即不在有默認的構造函數(shù)

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

    // 自定義構造函數(shù),會覆蓋init()函數(shù)
    init(name : String, age : Int) {
        self.name = name
        self.age = age
    }
}

// 創(chuàng)建一個Person對象
let p = Person(name: "xiaoming", age: 18)

③ 字典轉模型(初始化時傳入字典)

例1
class Person: NSObject {
    var name : String
    var age : Int

    // 自定義構造函數(shù),會覆蓋init()函數(shù)
    init(dict : [String : NSObject]) {
        name = dict["name"] as! String
        age = dict["age"] as! Int
    }
}

// 創(chuàng)建一個Person對象
let dict = ["name" : "xiaoming", "age" : 18]
let p = Person(dict: dict)

例2
利用KVC字典轉模型
class Person: NSObject {
    // 結構體或者類的類型秫筏，必須是可選類型，因為不能保證一定會賦值
    var name : String?

    // 基本數(shù)據(jù)類型不能是可選類型挎挖，否則KVC無法轉化
    var age : Int = 0

    // 自定義構造函數(shù)这敬，會覆蓋init()函數(shù)
    init(dict : [String : NSObject]) {
        // 必須先初始化對象
        super.init()

        // 調(diào)用對象的KVC方法字典轉模型
        setValuesForKeysWithDictionary(dict)
    }
}

// 創(chuàng)建一個Person對象
let dict = ["name" : "xiaoming", "age" : 18]
let p = Person(dict: dict)

十三、閉包
Swift閉包和OC中的block非常相似蕉朵，OC中的block是匿名的函數(shù)崔涂，Swift中的閉包是一個特殊的函數(shù)，block和閉包都經(jīng)常用于回調(diào)
1始衅、OC中Block的使用

首先介紹一下OC中Block寫法
① 第一種Block方式

@property (nonatomic, copy) void(^callBack)(NSString *name);
callBack 是block對象
回調(diào)方法
if(_callBack){
_callBack(name)
}

② 第二種Block方式

typedef void(^CallBack)(NSString *str);
@property (nonatomic, copy) CallBack callback;
callback是block對象
回調(diào)方法
if(_callBack){
_callBack(name)
}

③ 第三種Block方式

- (void)setUpWith:(void(^)(NSString *str))callback;
callback是block對象
回調(diào)方法
if(_callBack){
_callBack(name)
}

總結
Block的寫法:
    類型：
    返回值類型(^block的名稱)(block的參數(shù))

    值:
    ^(參數(shù)列表) {
        // 執(zhí)行的代碼
    };

2冷蚂、Swift中閉包的使用
① 第一種閉包方式

var callBack : (()->())?

② 第二種閉包方式

func loadRequest(callBack : ()->()){
                callBack()
    }

總結
閉包的寫法:
   callBack: (形參列表) -> (返回值類型)
    類型:(形參列表) -> (返回值類型)
    值:
    {
        (形參) -> 返回值類型 in
        // 執(zhí)行代碼
    }

閉包的簡寫缭保，如果閉包沒有參數(shù)，沒有返回值帝雇，in和in之前的內(nèi)容可以省略

尾隨閉包寫法
① 如果閉包是函數(shù)的最后一個參數(shù)涮俄，則可以將閉包寫在()后面
    httpTool.loadRequest() {
        print("回到主線程", NSThread.currentThread());
    }
② 如果函數(shù)只有一個參數(shù),并且這個參數(shù)是閉包,那么()可以不寫
    // 開發(fā)中建議該寫法
    httpTool.loadRequest {
        print("回到主線程", NSThread.currentThread());
    }

3、閉包的循環(huán)引用
如果在HttpTool中有對閉包進行強引用,則會形成循環(huán)引用尸闸，在Swift中檢測一個對象是否銷毀,可以實現(xiàn)對象的deinit函數(shù)

// 析構函數(shù)(相當于OC中dealloc方法)
    deinit {
        print("ViewController----deinit")
    }

4彻亲、swift中解決循環(huán)引用的方式
① 使用weak,對當前控制器使用弱引用
但是因為self可能有值也可能沒有值，因此weakSelf是一個可選類型吮廉，在真正使用時可以對其強制解包(該處強制解包沒有問題苞尝，因為控制器一定存在,否則無法調(diào)用所在函數(shù))

解決一
weak var weakSelf = self
    httpTool.loadData {
        print("加載數(shù)據(jù)完成,更新界面:", NSThread.currentThread())
        weakSelf!.view.backgroundColor = UIColor.redColor()
    }

② 可以寫在閉包中,并且在閉包中用到的self都是弱引用

解決二
 httpTool.loadData {[weak self] () -> () in
        print("加載數(shù)據(jù)完成,更新界面:", NSThread.currentThread())
        self!.view.backgroundColor = UIColor.redColor()
    }

③ 使用關鍵字unowned
unowned 更像OC中的 unsafe_unretained，unowned 表示即使它原來引用的對象被釋放了宦芦，仍然會保持對被已經(jīng)釋放了的對象的一個 "無效的" 引用宙址，它不能是 Optional 值，也不會被指向 nil

解決三
httpTool.loadData {[unowned self] () -> () in
        print("加載數(shù)據(jù)完成,更新界面:", NSThread.currentThread())
        self.view.backgroundColor = UIColor.redColor()
    }

十四调卑、懶加載
swift中也有懶加載的方式抡砂，希望所有的對象在使用時才真正加載到內(nèi)存中，和OC不同的是swift有專門的關鍵字來實現(xiàn)懶加載恬涧，lazy關鍵字可以用于定義某一個屬性懶加載
1注益、懶加載普通方式

lazy var 變量：類型 = 系統(tǒng)類()
lazy var button：UIButton = UIButton()

2、懶加載升級方式

lazy var array : [String] = {
        () -> [String] in
        return ["xiaoming", "xl", "lisi"]
    }()

心得體會：
Swift好用溯捆，如果你讀完本篇文章基本上掌握了Swift基礎知識丑搔，剩下的就是實戰(zhàn)了，實戰(zhàn)會增加你編寫Swift的能力提揍，對Swift有更深的理解啤月，后期也會補充新的Swift知識，也會分享自己的開源Swift項目共大家學習討論劳跃，請關注下我的github賬號lb2281075105谎仲，開始分享自己的項目和Demo，如果更好的意見請及時給我說哦刨仑，合理我會毫不猶豫采納强重，謝謝，您的點贊會更加激勵我的熱情贸人。