作品鏈接：http://www.lxweimin.com/users/1e0f5e6f73f6/top_articles

1.Swift初體驗

1.Playground是什么?

• 從Xcode6開始出現(Swift開始出現)

  • 翻譯為:操場/游樂場

  • 對于學習Swift基本語法非常方便

    • 所見即所得(快速查看結果)
    • 語法特性發生改變時,可以快速查看

2.Swift最基本的語法變化

• 導入框架 import UIKit

• 定義標識符時，必須聲明該標識符是變量還是常量

  • 聲明標識符的格式:變量/常量關鍵字 名稱 : 數據類型
    • 注意 數據類型首字母必須大寫

• 語句結束時不需要加;

  • 如果同一行有多個語句,則依然需要加
  • 但是不建議一行多條語句
  • Swift中的打印語句:print(打印的內容)

• 當一行語句結束時,不再需要寫;

  • 但是:如果一行中有多條語句,則需要通過;將其分割.
  • 注意:不建議一行中寫多條語句

3.Swift的常量與變量

1.什么是常量和變量

• 在Swift中規定:在定義一個標識符時必須明確說明該標識符是一個常量還是變量
• 使用let來定義常量,定義之后不可以修改
• 使用var來定義變量,定義之后可以修改

2.常量和變量的基本使用

/********** 1.常量和變量的基本使用 **********/

var age : Int = 18
   age是變量值可以改變
    age = 20

let a : Double = 3.234

//    a = 3.44
   a是常量值不能改變

/********** 2.常量和變量的使用注意 **********/

• 注意：
  • 是指向的對象不可以再進行修改.但是可以通過指針獲得對象后,修改對象內部的屬性
  • 在真實使用過程中,建議先定義常量（let）,如果需要修改再修改為變量（var）(更加安全)

• 在Swift中創建對象.類()

let view : UIView = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))

// 錯誤寫法
// view = UIView()
view.backgroundColor = UIColor.redColor()

// 在swift中使用枚舉:類型.具體的類型
let btn : UIButton = UIButton(type: UIButtonType.ContactAdd)
// btn = UIButton()
btn.center = CGPoint(x: 50, y: 50)

view.addSubview(btn)

Swift中數據類型

1.Swift類型的介紹

 Swift中的數據類型也有:整型/浮點型/對象類型/結構體類型等等
先了解整型和浮點型
整型
    有符號
        Int8 : 有符號8位整型
        Int16 : 有符號16位整型
        Int32 : 有符號32位整型
        Int64 : 有符號64位整型
        Int : 和平臺相關(默認,相當于OC的NSInteger)
    無符號
        UInt8 : 無符號8位整型
        UInt16 : 無符號16位整型
        UInt32 : 無符號32位整型
        UInt64 : 無符號64位整型
        UInt : 和平臺相關(常用,相當于OC的NSUInteger)(默認)
浮點型
    Float : 32位浮點型
    Double : 64浮點型(默認)

2.Swift中的類型推導

• Swift是強類型的語言
• Swift中任何一個標識符都有明確的類型

注意:

如果定義一個標識符時有直接進行賦值,那么標識符后面的類型可以省略.
因為Swift有類型推導,會自動根據后面的賦值來決定前面的標識符的數據類型
可以通過option+鼠標左鍵來查看變量的數據類型

var a = 5

var b = 30.1

3.Swift中基本運算

• Swift中在進行基本運算時必須保證類型一致,否則會出錯

  • 相同類型之間才可以進行運算
  • 因為Swift中沒有隱式轉換

• 數據類型的轉化

  • Int類型轉成Double類型:Double(標識符)
  • Double類型轉成Int類型:Int(標識符)

let c = Int(b) + a
print(c)

let d = Double(a) - b
print(d)

var m = Double(a) * b
print(m)

var n = Int(b) / a
print(n)

4.邏輯分支

1.分支的介紹

• 分支即if/switch/三目運算符等判斷語句
• 通過分支語句可以控制程序的執行流程

2.if分支語句

• 和OC中if語句有一定的區別
  • 判斷句可以不加()
  • 在Swift的判斷句中必須有明確的真假
    • 不再有非0即真
    • 必須有明確的Bool值
    • Bool有兩個取值:false/true

// 例子1
let a = 10

if a > 5 {
    print("a > 5")
} else {
    print("a <= 5")
}


// 例子2
let score = 89

if score < 60 {
    print("不及格")
} else if score < 70 {
    print("及格")
} else if score < 90 {
    print("良好")
} else if score <= 100 {
    print("優秀")
} else {
    print("成績錯誤")
}

3.三目運算符

• Swift 中的 三目 運算保持了和 OC 一致的風格

let age = 16

let result = age >= 22 ? "可以結婚" : "還需繼續長大"

print(result)

4.guard的使用

• guard是Swift2.0新增的語法
• 它與if語句非常類似，它設計的目的是提高程序的可讀性
• guard語句必須帶有else語句，它的語法如下：
  • 當條件表達式為true時候跳過else語句中的內容，執行語句組內容
  • 條件表達式為false時候執行else語句中的內容，跳轉語句一般是return、break、continue和throw

guard 條件表達式 else {
    // 條換語句
    break
}
語句組

• 例子

func onLine(age : Int) -> Bool {
    guard age >= 22 else{
        // 如果判斷句為假,會執行else
        print("還需繼續長大")
        return false
    }
    // 如果為真,繼續執行
    print("可以結婚")
    return true
}

onLine(20)

onLine(27)

5.switch分支

1.switch的介紹

Switch作為選擇結構中必不可少的語句也被加入到了Swift中
只要有過編程經驗的人對Switch語句都不會感到陌生
但蘋果對Switch進行了大大的增強，使其擁有其他語言中沒有的特性

2.switch的簡單使用

基本用法和OC用法一致
不同之處:
    switch后可以不跟()
    case后可以不跟break(默認會有break)

// season 為0，表示春季 1 為夏季  2  為秋季  3  冬季

let season = 2

switch season {
case 0:
    print("春季")
case 1:
    print("夏季")
case 2:
    print("秋季")
case 3:
    print("冬季")
default:
    print("錯誤")
}

3.有case穿透,可以在語句后加fallthrough

switch season {
case 0:
    print("春季")
case 1:
    print("夏季")
case 2:
    print("秋季")
    fallthrough
case 3:
    print("冬季")
default:
    print("錯誤")
}

4.case中可以判斷多個條件

• 如果想判斷多個條件,可以通過,分割

switch season {
case 0, 1 :
    print("上半年")
case 2, 3:
    print("下半年")
default:
    print("錯誤")
}

5.switch可以判斷浮點型

let b = 3.14

switch b {
case 3.14:
    print("Double")
default:
    print("Int")

6.switch可以判斷字符串

let m = 20
let n = 25

let opration = "+"
var result1 :Int

switch opration {
case "+":
    result1 = m + n
case "-":
    result1 = m - n
case "*":
    result1 = m * n
case "/":
    result1 = m / n
default:
    print("非法操作符")
}

7.switch中可以判斷區間

• 區間表示方法:
  • 閉區間:0~10 [0, 10] swift: 0...10
  • 開區間:0~9 [0, 10) swift: 0..<10

let age1 = 17

switch age1 {
case 0..<3:
    print("嬰兒")
case 3..<6:
    print("兒童")
case 6..<12:
    print("少年")
case 12..<18:
    print("青少年")
case 18..<30:
    print("青年")
case 30..<55:
    print("壯年")
case 55..<100:
    print("老年")
default:
    print("錯誤")
}

5.循環

1.循環的介紹

• 在開發中經常會需要循環
• 常見的循環有:for/while/do while.

2.for循環的寫法

1.常規寫法

for (var i = 0; i < 10; i++){
    print(i)
}

2.區間for循環

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

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

3.如果for循環中沒有用到i,可以將i用_代理

for _ in 0..<10 {
    print("abc")
}

3.while和do while循環

• while循環

  • while的判斷句必須有正確的真假(Bool),沒有非0即真
  • while后面的()可以省略

var a = 5

while a < 15 {
    a += 1
    print("abc")
}

• do while循環

  • 使用repeat關鍵字來代替了do

repeat {
    a += 1
    print("abc")
} while a < 20

6.字符串

1.字符串的介紹

• OC和Swift中字符串的區別
  • 在OC中字符串類型時NSString,在Swift中字符串類型是String
  • OC中字符串@"",Swift中字符串""
• 使用 String 的原因
  • 1.String 是一個結構體，性能更高
  • 2.NSString 是一個 OC 對象，性能略差
  • 3.String 支持直接遍歷
  • 4.Swift 提供了 String 和 NSString 之間的無縫轉換

2.字符串的使用

1.遍歷字符串

var str = "Hello, playground"

for s in str.characters {
    print(s)
}

2.String的拼接

• 兩個字符串之間的拼接

let str1 = "my name is"
var str2 = " why"
str2 = str1 + str2

• 字符串和其他類型的拼接

  • 在字符串中拼接其他類型的變量/常量
  • 格式:(變量/常量名字)

let age = 18
let height = 1.88
let str3 = "age is \(age), height is \(height)"

3.字符串的格式化

let min = 5
let second = 9
// 方法一
let tim = "0\(min):0\(second)"
// 方法二
let time = String(format: "%02d:%02d", arguments:[min, second])

4.字符串的截取

• Swift中提供了特殊的截取方式

  • 簡單的方式是將String轉成NSString來使用
  • 在標識符后加:as NSString即可

• 注意:不要使用String方法截取.index非常不好創建 urlString.substringFromIndex(index: Index)

let urlString = "www.baidu.com"

let prefixString = (urlString as NSString).substringToIndex(3)
let middleString = (urlString as NSString).substringWithRange(NSRange(location: 4, length: 5))
let subfixString = (urlString as NSString).substringFromIndex(10)

7.數組

1.數組的介紹

• 數組（Array）是一串有序的由相同類型元素構成的集合
  • 數組中的集合元素是有序的，可以重復出現
• Swift中的數組
  • swift數組類型是Array，是一個泛型集合

2.數組的初始化

• 數組分成:可變數組和不可變數組
  • 使用let修飾的數組是不可變數組
  • 使用var修飾的數組是可變數組

1.不可變數組

// 數組定義的寫法一:
let names : Array<String> = ["花花","阿黃","兮兮","餅餅"]
names[2]

// 數組定義的寫法二:常用
let name1 : [String] = ["花花","阿黃","兮兮","餅餅"]

// 數組定義的寫法三:類型推導
let names2 = ["花花","阿黃","兮兮","餅餅"]

2.可變數組

// 數組定義的寫法一:
var names3 : [String] = ["wpf","ixm"]
names3.append("cf")
// 寫法二
var names4 :[String] = Array()

// 寫法二
var names5 : [String] = [String]()
names5.append("lj")

3.對數組的基本操作

• 定義一個可變數組
  • Swift開始中,可以使用AnyObject代替NSObject

var names6 :[AnyObject] = [AnyObject]()

// 1.對數組的基本操作
// 1> 添加元素
names6.append("123")
names6.append("abc")
names6.append("jkh")
names6.append("ggg")
names6.append("000")
names6.append("jxm")
// 2> 刪除元素
names6.removeAtIndex(3)
names6.removeLast()
names6

// 3> 修改元素
names6[0] = "wpf"
names6

// 4> 取出數組中的值
names6[2]

4.數組的遍歷

1> 通過下標值遍歷

for i in 0..<names6.count {
    print(names6[i])
}

2> forin方式

for item in names6 {
    print(item)
}

** 3> 區間遍歷**

for i in 0..<2{
    print(names6[i])
}

for item in names6[1...3] {
    print(item)
}

5.數組的合并

1.類型相同的數組合并

let array1 = ["123", "456", "abc"]

let array2 = ["vhs", "jksc"]

let array3 = array1 + array2

** 2> 類型不同的數組的合并**

let words = ["文化","書法","體育"]
let ages = [12, 23, 34]

var array4 = [AnyObject]()

for item in words {
   array4.append(item)
}

for item in ages {
    array4.append(item)
}

array4

8.字典

1.字典的介紹

• 字典允許按照某個鍵來訪問元素
  • 字典是由兩部分集合構成的，一個是鍵（key）集合，一個是值（value）集合
  • 鍵集合是不能有重復元素的，而值集合是可以重復的，鍵和值是成對出現的
• Swift中的字典
  • Swift字典類型是Dictionary，也是一個泛型集合

2. 字典的初始化

• Swift中的可變和不可變字典
  • 使用let修飾的數組是不可變數組
  • 使用var修飾的數組是可變數組

1.不可變字典

// 1>方式一:
let dict1 : Dictionary<String, AnyObject> = ["name" : "wpf", "age" : 18]

// 2>方式二:
let dict2 : [String : AnyObject] = ["name" : "wpf", "age" : 18]

// 3>方式三:
let dict3 = ["name" : "wpf", "age" : 18]

2.可變字典

// 1> 方式一:
var dict4 = Dictionary<String, AnyObject>()

// 2> 方式二:
var dict5 = [String : AnyObject]()

// 3> 方式三:
var dict6 = ["name" : "wpf", "age" : 18]

3.字典的基本操作

• 定義一個可變字典

var dict = [String : AnyObject]()
// 1> 添加元素
dict["name"] = "wpf"
dict["age"] = 18
dict["height"] = 1.78
dict["weight"] = 70.0

dict

// 2> 刪除元素
//dict.removeAll()
dict.removeValueForKey("age")

// 3> 修改元素
// 注意:通過該方式來修改元素,如果有對應的鍵,則修改.如果沒有對應的鍵,則添加元素
dict["name"] = "jxm"
dict["adress"] = "sq"

dict

// 4> 取出

dict["name"]

4.字典的遍歷

** 1> 遍歷字典中的所有的鍵**

for key in dict.keys {
    print(key)
}

** 2> 遍歷字典中所有的值**

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

3> 遍歷所有的鍵值對

for (key, value) in dict {
    print(key)
    print(value)
}

5.字典的合并

// 注意:字典無論類型是否一致,都不可以直接相加來合并
//let dict9 = dict7 + dict8

let dict7 = ["name" : "wpf", "age" : 18]

var dict8 = ["phone" : "huaewei"]

for (key7, value7) in dict7 {
    dict8[key7] = value7 as? String
}
dict8

9.元祖

1.元祖的介紹

• 元組是Swift中特有的
  • 它是什么呢?
    • 它是一種數據結構，在數學中應用廣泛。
    • 類似于數組或者字典
    • 可以用于定義一組數據

2.元祖的定義

• 元祖的常見寫法有兩種

// 方式一:
let a = ("wpf", 18, 1.75)

// 方式二:常用
let b = (name : "wpf", age : "18", height : 1.88)

// 方式三:
let (name, age, height) = ("wpf", 18, 1.75)

3.元祖的簡單使用

• 用元組來描述一個HTTP的錯誤信息

// 方法1
let error = (404, "Not Found")
error.0
error.1

// 方法2
let error1 = (errorCode : 404, errorInfo : "Not Found")
error1.errorCode
error1.errorInfo

// 方法3
let (errorCode1, errorInfo1) = (404, "Not Found")
errorCode1
errorInfo1

10.可選類型

1.可選類型的介紹

• 概念:

• 在OC開發中,如果一個變量暫停不使用,可以賦值為0(基本屬性類型)或者賦值為空(對象類型)

• 在swift開發中,nil也是一個特殊的類型.因為和真實的類型不匹配是不能賦值的(swift是強語言)

• 可選類型的取值:

  • 空值
  • 有值

2.定義可選類型

1.最基本的寫法

// 1> 方式一:Optional<String>
var name : Optional<String>

// 2> 給可選類型賦值
name = " wpf"

// 3> 錯誤寫法
// let info = "my name is " + name

// 4> 打印可選類型:Optional("wpf")

print(name)

// 5> 取出可選類型中的值
// 取值:可選類型+!,強制解包
print(name!)

let info = "my name is" + name!

2.語法糖(常用)

// 1> 方式二:語法糖String?
var phoneNum : String? = nil
phoneNum = " 12398765"

// 2>使用注意:如果一個可選類型中沒有值,強制解包會報錯

// * 判斷方式一:在強制解包之前,最好對可選類型進行判斷.如果有值,在進行解包

if phoneNum != nil {
    let phoneInfo = "my phoneNum is" + phoneNum!

}


// * 判斷方式二:可選綁定:判斷phoneNum是否有值
// 1>如果沒有值,則直接跳過{}
// 2>如果有值,將可選類型進行解包,并且將解包后的值賦值給tempPhoneNum

if let tempPhoneNumb = phoneNum {
    print(tempPhoneNumb)
//    print(phoneNum)
}

3.真實應用場景

• 目的:讓代碼更加嚴謹

// 通過該方法創建的URL,可能有值,也可能沒有值
// 錯誤寫法:如果返回值是nil時,就不能接收了
let urlString = "http://www.baidu.com/中文"
// 正確寫法:使用可選類型來接收
let url : NSURL? = NSURL(string: urlString)

// 判斷url是否有值,來決定是否創建NSURLRequest對象
if url != nil {
    NSURLRequest(URL: url!)
}

// 通過url來創建request對象
if let tempUrl = url {
    NSURLRequest(URL: tempUrl)
}

11.函數

1.函數的介紹

• 函數的格式如下

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

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

2.常見的函數類型

1.沒有參數,沒有返回值的函數

func about() -> Void{
    print("手機型號是iPhone6s Plus玫瑰金")
}

about()

// 注意,如果一個函數沒有返回值,那么:(-> Void) 省略
func about1() {
     print("手機型號是iPhone6s Plus玫瑰金")
}

about1()

2.有參數,沒有返回值的函數

• OC: - (void)callPhone:(String *)phoneNum

func callPhone(phoneNum : String) {
    print("打電話給:" + phoneNum)
}

callPhone("+ 12347")

3.沒有參數,有返回值的函數

func readMassage() -> String {
    return "最近過的好嗎？？"
}

print(readMassage())

4.有參數,有返回值的函數

• 注意:如果有多個參數,則參數使用,分割

func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}

sum(30, num2: 29)

3.函數的使用注意

1.外部參數和內部參數

• 在函數內部可以看到的參數,就是內部參數
• 在函數外面可以看到的參數,就是外部參數
• 默認情況下,從第二個參數開始,參數名稱既是內部參數也是外部參數
• 如果第一個參數也想要有外部參數,可以設置標簽:在變量名前加標簽即可
• 如果不想要外部參數,可以在參數名稱前加_

func sum1(num1 num1 : Int, _ num2 : Int, num3 : Int) -> Int {
    return num1 + num3 + num2
}

sum1(num1: 20, 30, num3: 40)

2.默認參數

• 某些情況,如果沒有傳入具體的參數,可以使用默認參數

func makeCoffee(coffeeName : String = "卡布奇諾") -> String {
    return "制作一杯\(coffeeName)"
}

makeCoffee("速溶咖啡")
makeCoffee()

3.可變參數

• swift中函數的參數個數可以變化，它可以接受不確定數量的輸入類型參數
• 它們必須具有相同的類型
• 我們可以通過在參數類型名后面加入（...）的方式來指示這是可變參數

func sumNum(nums : Int...) -> Int {
    var result = 0
    for n in nums {
        result += n
    }
   return result
}

sumNum(22,12,23,123,144,45)

4.引用類型(指針的傳遞)

• 默認情況下,函數的參數是值傳遞.如果想改變外面的變量,則需要傳遞變量的地址
• 必須是變量,因為需要在內部改變其值
• Swift提供的inout關鍵字就可以實現

// 函數一:值傳遞
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)")

// 函數二:指針的傳遞
func swapNum(inout m : Int, inout n : Int) {
    let temp = m
    m = n
    n = temp
    print("a:\(m), b:\(n)")
}

swapNum(&a, n: &b)
print("a:\(a), b:\(b)")

5.函數的嵌套使用

• swift中函數可以嵌套使用
  • 即函數中包含函數,但是不推薦該寫法

func test() {
    func demo() {
        func demo1(){
            print("abc")
        }
    }
}

test()

12.Swift中類的定義

1.類的介紹

• Swift也是一門面向對象開發的語言
• 面向對象的基礎是類,類產生了對象
• 在Swift中如何定義類呢?
  • class是Swift中的關鍵字,用于定義類

class 類名 : SuperClass {
    // 定義屬性和方法
}

• 注意:
  • 定義的類,可以沒有父類.那么該類是rootClass
  • 通常情況下,定義類時.繼承自NSObject(非OC的NSObject)

2.如何定義類的屬性

1.類的屬性介紹

• Swift中類的屬性有多種
  • 存儲屬性:存儲實例的常量和變量
  • 計算屬性:通過某種方式計算出來的屬性
  • 類屬性:與整個類自身相關的屬性

2.存儲屬性

• 存儲屬性是最簡單的屬性，它作為類實例的一部分，用于存儲常量和變量
• 可以給存儲屬性提供一個默認值，也可以在初始化方法中對其進行初始化
• 下面是存儲屬性的寫法

  • age和name都是存儲屬性,用來記錄該學生的年齡和姓名

  • chineseScore和mathScore也是存儲屬性,用來記錄該學生的語文分數和數學分數

  • 注意:

    • 1> 如果類型是結構體或者類.通常定義為可選類型
    • 2> 如果是基本屬性類型,可以在定義的時候直接初始化為0/0.0

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

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

// 創建學生對象
let stu = Student()

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

stu.chineseScore = 89.0
stu.mathScore = 98.0

3.計算屬性

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

• 下面是計算屬性的寫法
  • averageScore是計算屬性,通過chineseScore和mathScore計算而來的屬性
  • 在setter方法中有一個newValue變量,是系統指定分配的

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是系統分配的變量名,內部存儲著新值
        set {
            self.averageScore = newValue
        }
    }
}

// 獲取計算屬性的值
print(stu.averageScore)

4.類屬性

• 類屬性是與類相關聯的，而不是與類的實例相關聯
• 所有的類和實例都共有一份類屬性.因此在某一處修改之后,該類屬性就會被修改
• 類屬性的設置和修改,需要通過類來完成
• 下面是類屬性的寫法
  • 類屬性使用static來修飾
  • courseCount是類屬性,用來記錄學生有多少門課程

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是系統分配的變量名,內部存儲著新值
        set {
            self.averageScore = newValue
        }
    }

    // 類屬性
    static var corseCount : Int = 0
}

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

4.監聽屬性的改變

• 在OC中我們可以重寫set方法來監聽屬性的改變

• Swift中可以通過屬性觀察者來監聽和響應屬性值的變化

• 通常是監聽存儲屬性和類屬性的改變.
  (對于計算屬性，我們不需要定義屬性觀察者，因為我們可以在計算屬性的setter中直接觀察并響應這種值的變化)

• 我們通過設置以下觀察方法來定義觀察者

     willSet：在屬性值被存儲之前設置。此時新屬性值作為一個常量參數被傳入。該參數名默認為newValue，我們可以自己定義該參數名
        didSet：在新屬性值被存儲后立即調用。與willSet相同，此時傳入的是屬性的舊值，默認參數名為oldValue
        willSet與didSet只有在屬性第一次被設置時才會調用，在初始化時，不會去調用這些監聽方法
    監聽的方式如下:
        監聽age和name的變化

class Person: NSObject {
    var name : String? {
        // 在willSet方法中,系統提供一個標識符.
        // newValue : 用于記錄新傳入的數據
        // 自定義newValue和oldValue的名稱
        // willSet (new)
        willSet (new) {
            print(name)
            print(new)
        }

        // 在didSet方法中,系統提供一個標識符.
        // oldValue : 用戶記錄之前的值
        // didSet (old)
        didSet (old) {
            print(name)
            print(old)
        }
    }
    var age : Int = 0
}

let p = Person()
p.name = "wpf"
p.age = 18

13.類的構造函數

1.構造函數的介紹

• 構造函數類似于OC中的初始化方法:init方法
• 默認情況下載創建一個類時,必然會調用一個構造函數
• 即便是沒有編寫任何構造函數，編譯器也會提供一個默認的構造函數。
• 如果是繼承自NSObject,可以對父類的構造函數進行重寫

2.構造函數的基本使用

1.構造函數的基本使用

• 類的屬性必須有值
• 如果不是在定義時初始化值,可以在構造函數中賦值

class Person: NSObject {
    var name : String?
    var age : Int = 0

    // 重寫了NSObject(父類)的構造方法
    override init() {
        name = ""
        age = 0
    }
}

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

2.初始化時給屬性賦值

• 很多時候,我們在創建一個對象時就會給屬性賦值
• 可以自定義構造函數
• 注意:如果自定義了構造函數,會覆蓋init()方法.即不在有默認的構造函數

class Person: NSObject {

    // var name : Optional<String>
    var name :String?
    var age : Int

    override init() {
        // 重寫之后是否需要調用super.init()
        // 可以不調用,如果沒有主動調用,那么系統會默認調用
    }

    // 自定義構造函數,初始化時直接傳入名字和年齡
    init (name : String, age : Int) {
        self.age = age
        self.name = name
    }
}
// 創建一個Person對象
let p = Person(name: "wpf", age: 18)

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

• 真實創建對象時,更多的是將字典轉成模型
  • 注意:
    • 去字典中取出的是NSObject,任意類型.
    • 可以通過as!/?轉成需要的類型,再賦值(不可以直接賦值)

class Person: NSObject {
    var name : String?
    var age : Int = 0

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

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

4.字典轉模型(利用KVC轉化)

• 利用KVC字典轉模型會更加方便
  • 注意:
  • KVC并不能保證會給所有的屬性賦值
  • 因此屬性需要有默認值
    • 基本數據類型默認值設置為0
    • 對象或者結構體類型定義為可選類型即可(可選類型沒有賦值前為nil)

class Person: NSObject {
    // 結構體或者類的類型,必須是可選類型.因為不能保證一定會賦值
    var name : String?

    // 基本數據類型不能是可選類型,否則KVC無法轉化
    var age : Int = 0

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

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

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

3.方法的重載

• 方法的重載
  • 1.方法名字相同,但是參數不同,就是方法的重載
  • 2.參數不同:1>參數個數不同 2>參數的類型不同

   // 注意：參數類型不同時，類不能繼承NSObject
    func sum(num1 : Int, num2 : Int) -> Int {
        return num1 + num2
    }

    func sum(num1 : Int, num2 : Int, num3 : Int) -> Int {
        return num1 + num2 + num3
    }

    func sum(num1 : Double,num2 : Double) -> Double {
        return num1 + num2
    }

14.閉包

1.閉包的介紹

• 閉包和OC中的block非常相似
  • OC中的block是匿名的函數
  • Swift中的閉包是一個特殊的函數
  • block和閉包都經常用于回調

2.block的用法回顧

1.定義網絡請求的類

@interface HttpTool : NSObject
- (void)loadRequest:(void (^)())callBackBlock;
@end

@implementation HttpTool
- (void)loadRequest:(void (^)())callBackBlock
{
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"加載網絡數據:%@", [NSThread currentThread]);

        dispatch_async(dispatch_get_main_queue(), ^{
            callBackBlock();
        });
    });
}
@end

2.進行網絡請求,請求到數據后利用block進行回調

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    [self.httpTool loadRequest:^{
        NSLog(@"主線程中,將數據回調.%@", [NSThread currentThread]);
    }];
}

3.block寫法總結

block的寫法:
    類型:
    返回值(^block的名稱)(block的參數)

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

3.閉包的使用

1.定義網絡請求的類

class HttpTool: NSObject {

    func loadRequest(callBack : ()->()){
        dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
            print("加載數據", [NSThread.currentThread()])

             dispatch_async(dispatch_get_main_queue(), { () -> Void in
                callBack()
             })
        }
    }
}

2.進行網絡請求,請求到數據后利用閉包進行回調

 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        // 網絡請求
        httpTool.loadRequest ({ () -> () in
            print("回到主線程", NSThread.currentThread());
        })
    }

3.閉包寫法總結

閉包的寫法:
    類型:(形參列表)->(返回值)
    技巧:初學者定義閉包類型,直接寫()->().再填充參數和返回值

    值:
    {
        (形參) -> 返回值類型 in
        // 執行代碼
    }

4.閉包的簡寫

1.如果閉包沒有參數,沒有返回值.in和in之前的內容可以省略

httpTool.loadRequest({
        print("回到主線程", NSThread.currentThread());
    })

2.尾隨閉包寫法

• 如果閉包是函數的最后一個參數,則可以將閉包寫早()后面

 httpTool.loadRequest() {
        print("回到主線程", NSThread.currentThread());
    }

• 如果函數只有一個參數,并且這個參數是閉包,那么()可以不寫

// 開發中建議該寫法
    httpTool.loadRequest {
        print("回到主線程", NSThread.currentThread());
    }

5.閉包的循環引用

1.如果在HttpTool中有對閉包進行強引用,則會形成循環引用

class HttpTool: NSObject {

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

    // 閉包的類型:(參數列表)->(返回值)
    // 建議:以后寫閉包類型直接:()->()

    func requestData(callBack : ()->()) {
        self.callBack = callBack

        dispatch_async(dispatch_get_global_queue(0, 0)) {
            print("正在網絡請求\(NSThread .currentThread())")

            dispatch_async(dispatch_get_main_queue(), {

                callBack()
            })
        }
    }

}

2.swift中解決循環引用的方式
1.解決循環引用的方式一:

        weak var weakSelf : ViewController? = self

        httpTool.requestData {
            print("已經請求到網絡數據")
            print("更新界面\(NSThread.currentThread())")
            weakSelf!.view.backgroundColor = UIColor.greenColor()
        }

2.解決循環引用的方式二:

    // 該方式不能省略賦值時的:() -> () in

    httpTool.requestData { [weak self] () -> () in

        print("已經請求到網絡數據")
        print("更新界面\(NSThread.currentThread())")
        self!.view.backgroundColor = UIColor.greenColor()

        }

3.解決循環引用的方式三:

        // 該方式不能省略賦值時的:() -> () in
        //  unowned
        /*
         __weak:當弱指針指向的對象銷毀時,指針自動指向nil
         __unsafe_unretained:當不安全指針指向的對象銷毀時,指針依然指向之前的內存地址(野指針)
         */

        httpTool.requestData { [unowned self] () -> () in
            print("已經請求到網絡數據")
            print("更新界面\(NSThread.currentThread())")
            self.view.backgroundColor = UIColor.greenColor()
        }

15.懶加載

1.懶加載的介紹

• swift中也有懶加載的方式
  • (蘋果的設計思想:希望所有的對象在使用時才真正加載到內存中)
• 和OC不同的是swift有專門的關鍵字來實現懶加載
• lazy關鍵字可以用于定義某一個屬性懶加載

2.懶加載的使用

• 格式

lazy var 變量: 類型 = { 創建變量代碼 }()

• 懶加載的使用

// 懶加載的本質是,在第一次使用的時候執行閉包,將閉包的返回值賦值給屬性
     1>數據用到時再加載
     2> lazy的作用是只會賦值一次
    lazy var names : [String] = {
        print("加載數據")
        return ["wpf","jxm"]
    }()