常量&變量

什么是常量和變量

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

基本使用

let a : Int = 10
// 錯誤寫法,當一個字段定義為常量時是不可以修改的
// a = 20

var b : Int = 20
// 因為b定義為變量,因此是可以修改的
b = 30

使用注意

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

// 注意:聲明為常量不可以修改的意思是指針不可以再指向其他對象.但是可以通過指針拿到對象,修改其中的屬性
// view : UIView = [[UIView alloc] init];
// Swift對象中不需要*
var view : UIView = UIView()
view = UIView()
let view1 : UIView = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
view1.backgroundColor = UIColor.redColor()
// 枚舉類型的用法:類型.枚舉的值
let btn : UIButton = UIButton(type: UIButtonType.Custom)
btn.backgroundColor = UIColor.blueColor()
btn.setTitle("按鈕", forState: UIControlState.Normal)
btn.frame = CGRect(x: 20, y: 20, width: 60, height: 30)
view1.addSubview(btn)

數據類型

類型的介紹

• 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浮點型(默認)

    // 定義一個Int類型的變量m,并且賦值為10
    var m : Int = 10
    // 定義一個Double類型的常量n,并且賦值為3.14
    let n : Double = 3.14
    

類型推導

• Swift是強類型的語言

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

• 注意:

  • 如果定義一個標識符時有直接進行賦值,那么標識符后面的類型可以省略.
  • 因為Swift有類型推導,會自動根據后面的賦值來決定前面的標識符的數據類型

  // 定義變量時沒有指定明確的類型,但是因為賦值給i一個20.20為整型.因此i為整型
  var i = 20
  // 錯誤寫法:如果之后賦值給i一個浮點型數值,則會報錯
  // i = 30.5
  // 正確寫法
  var j = 3.33
  j = 6.66
  

基本運算

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

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

• 數據類型的轉化

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

  let a = 10
  let b = 3.14
  // 錯誤寫法
  // let c = a + b
  // let c = a * b
  // 正確寫法
  let c = Double(a) + b
  let d = a + Int(b)
  

邏輯分支

if分支語句

• 和OC中if語句有一定的區別

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

  // 演練一:
  let a = 10
  // 錯誤寫法:
  //if a {
  //    print("a")
  //}
  // 正確寫法
  if a > 9 {
      print(a)
  }
  // 演練二:
  let score = 87
  if score < 60 {
      print("不及格")
  } else if score <= 70 {
      print("及格")
  } else if score <= 80 {
      print("良好")
  } else if score <= 90 {
      print("優秀")
  } else {
      print("完美")
  }
  // 演練三:
  // 這個是可選類型,因為只有聲明成可選類型后,才可以判斷是否為空
  // 可選類型會在后續講解,可先了解即可
  let view : UIView? = UIView()
  // 判斷如果view有值,則設置背景
  // 錯誤寫法
  //if view {
  //    view.backgroundColor = UIColor.redColor()
  //}
  if view != nil {
      view!.backgroundColor = UIColor.redColor()
  }
  

三目運算符

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

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

switch分支

• switch的簡單使用
  • 基本用法和OC用法一致
  • 不同之處:
  • switch后可以不跟()
  • case后可以不跟break(默認會有break)
• 例子:

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

• 使用補充:

  • 一個case判斷中,可以判斷多個值
  • 多個值以,隔開

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

• 簡單使用補充:

  • 如果希望出現之前的case穿透,則可以使用關鍵字fallthrough

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

• Switch支持多種數據類型

  • 浮點型的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
  }
  print(result)
  

• switch支持區間判斷

  • swift中的區間常見有兩種
    • 開區間:0..<10 表示:0~9,不包括10
    • 閉區間: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("優秀")
  default:
      print("滿分")
  }
  

循環的介紹

for循環的寫法

• 最常規寫法

// 傳統寫法
for var i = 0; i < 10; i++ {
    print(i)
}

• 區間for循環

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

• 特殊寫法
  • 如果在for循環中不需要用到下標i

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

while和do while循環

• while循環

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

  var a = 0
  while a < 10 {
      a++
  }
  

• do while循環

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

  let b = 0
  repeat {
      print(b)
      b++
  } while b < 20
  

字符串

字符串的介紹

• 字符串在任何的開發中使用都是非常頻繁的
• OC和Swift中字符串的區別
  • 在OC中字符串類型時NSString,在Swift中字符串類型是String
  • OC中字符串@"",Swift中字符串""
• 使用 String 的原因
  • String 是一個結構體，性能更高
  • NSString 是一個 OC 對象，性能略差
  • String 支持直接遍歷
  • Swift 提供了 String 和 NSString 之間的無縫轉換

字符串的使用

• 遍歷字符串

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

• 字符串拼接

  • 兩個字符串的拼接

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

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

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

• 字符串的格式化

  • 比如時間:03:04

  let min = 3
  let second = 4
  let time = String(format: "%02d:%02d", arguments: [min, second])
  

• 字符串的截取

  • Swift中提供了特殊的截取方式
    • 該方式非常麻煩
    • Index創建較為麻煩
  • 簡單的方式是將String轉成NSString來使用
    • 在標識符后加:as NSString即可

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

數組

數組介紹

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

數組的初始化

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

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

// 定義一個不可變數組
let array2 : [NSObject] = ["why", 18]

• 在聲明一個Array類型的時候可以使用下列的語句之一

var stuArray1:Array<String>
var stuArray2: [String]

• 聲明的數組需要進行初始化才能使用，數組類型往往是在聲明的同時進行初始化的

// 定義時直接初始化
var array = ["ni", "hao", "ya"]

// 先定義,后初始化
var array : Array<String>
array = ["ni", "hao", "ya"]

對數組的基本操作

// 添加數據
array.append("yz")

// 刪除元素
array.removeFirst()

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

// 取值
array[1]
數組的遍歷

遍歷數組

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

// forin方式
for item in array {
    print(item)
}

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

數組的合并

// 數組合并
// 注意:只有相同類型的數組才能合并
var array = ["ni", "hao", "ya"]
var array1 = ["James", "Wade"]
var array2 = array + array1;

// 不建議一個數組中存放多種類型的數據
var array3 = [2, 3, "Wade"]
var array4 = ["Kobe", 23]
array3 + array4

字典

字典的介紹

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

字典的初始化

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

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

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

• 在聲明一個Dictionary類型的時候可以使用下面的語句之一

var dict1: Dictionary<Int, String>
var dict2: [Int: String]

• 聲明的字典需要進行初始化才能使用，字典類型往往是在聲明的同時進行初始化的

// 定時字典的同時,進行初始化
var dict = ["name" : "James", "age" : 18]

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

字典的基本操作

// 添加數據
dict["height"] = 1.88
dict["weight"] = 70.0
dict

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

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

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

字典的遍歷

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

// 遍歷所有的鍵值對
for (key, value) in dict {
    print(key)
    print(value)
}

字典的合并

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

元祖

元祖的介紹

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

元祖的定義

• 元祖的常見寫法有兩種

("1001", "張三", 30, 90)
(id:"1001", name:"張三", english_score:30, chinese_score:90)

元祖的簡單使用

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

// 元祖:HTTP錯誤
// let array = [404, "Not Found"]
// 寫法一:
let error = (404, "Not Found")
print(error.0)
print(error.1)

// 寫法二:
let error = (errorCode : 404, errorInfo : "Not Found")
print(error.errorCode)
print(error.errorInfo)

// 寫法三:
let (errorCode, errorIno) = (404, "Not Found")
print(errorCode)
print(errorIno)

可選類型

可選類型的介紹

• 注意:
  • 可選類型時swift中非常難理解的一個知識點
  • 暫時先了解,多利用Xcode的提示來使用
  • 隨著學習的深入,慢慢理解其中的原理和好處
• 概念:
  • 在OC開發中,如果一個變量暫停不使用,可以賦值為0(基本屬性類型)或者賦值為空(對象類型)
  • 在swift開發中,nil也是一個特殊的類型.因為和真實的類型不匹配是不能賦值的(swift是強語言)
  • 但是開發中賦值nil,在所難免.因此推出了可選類型
• 可選類型的取值:
  • 空值
  • 有值

定義可選類型

• 定義一個可選類型有兩種寫法
• 最基本的寫法
• 語法糖(常用)

// 錯誤寫法
// let string : String = nil
// 正確寫法:
// 寫法一:定義可選類型
let string : Optional<String> = nil

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

可選類型的使用

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

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

// 打印結果
print(string)
// 結果:Optional("Hello world")\n
// 因為打印出來的是可選類型,所有會帶Optional


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

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

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

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

真實應用場景

• 目的:讓代碼更加嚴謹

// 通過該方法創建的URL,可能有值,也可能沒有值
// 錯誤寫法:如果返回值是nil時,就不能接收了
// 如果字符串中有中文,則返回值為nil
let url : NSURL = NSURL(string: "www.baidu.com")

// 正確寫法:使用可選類型來接收
let url : NSURL? = NSURL(string: "www.baidu.com")

// 通過url來創建request對象
// 該語法成為可選綁定(如果url有值就解包賦值給tempURL,并且執行{})
if let tempUrl = url {
    let request = NSURLRequest(URL: tempUrl)
}

函數

函數的介紹

• 函數相當于OC中的方法
• 函數的格式如下

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

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

常見的函數類型

// 1.沒有參數,沒用返回值
func about() -> Void {
    print("iphone6s plus")
}
// 調用函數
about()

// 簡單寫法
// 如果沒用返回值,Void可以寫成()
func about1() -> () {
    print("iphone6s plus")
}
// 如果沒有返回值,后面的內容可以都不寫
func about2() {
    print("iphone6s plus")
}

about2()

// 2.有參數,沒用返回值
func callPhone(phoneNum : String) {
    print("打電話給\(phoneNum)")
}
callPhone("+86 110")

// 3.沒用參數,有返回值
func readMessage() -> String {
    return "吃飯了嗎?"
}
var str = readMessage()
print(str)

// 4.有參數,有返回值
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}
var result = sum(20, num2: 30)
print(result)

函數的使用注意

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

// num1和a是外部參數的名稱
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)

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

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

func makecoffee(type :String = "卡布奇諾") -> String {
    return "制作一杯\(type)咖啡。"
}
let coffee1 = makecoffee("拿鐵")
let coffee2 = makecoffee()

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

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)

• 注意四: 引用類型(指針的傳遞)
  • 默認情況下,函數的參數是值傳遞.如果想改變外面的變量,則需要傳遞變量的地址
  • 必須是變量,因為需要在內部改變其值
  • 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 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)")

• 函數的嵌套使用(暫時了解即可)
  • swift中函數可以嵌套使用
  • 即函數中包含函數,但是不推薦該寫法

// 函數的嵌套
let value = 55
func test() {
    func demo() {
        print("demo \(value)")
    }
    print("test")
    demo()
}
demo() // 錯誤
test()

Swift中類的定義

類的介紹

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

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

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

如何定義類的屬性

類的屬性介紹

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

存儲屬性

• 存儲屬性是最簡單的屬性，它作為類實例的一部分，用于存儲常量和變量
• 可以給存儲屬性提供一個默認值，也可以在初始化方法中對其進行初始化
• 下面是存儲屬性的寫法
  • age和name都是存儲屬性,用來記錄該學生的年齡和姓名
  • chineseScore和mathScore也是存儲屬性,用來記錄該學生的語文分數和數學分數

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 = "why"

stu.chineseScore = 89.0
stu.mathScore = 98.0

計算屬性

• 計算屬性并不存儲實際的值，而是提供一個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)

類屬性

• 類屬性是與類相關聯的，而不是與類的實例相關聯
• 所有的類和實例都共有一份類屬性.因此在某一處修改之后,該類屬性就會被修改
• 類屬性的設置和修改,需要通過類來完成
• 下面是類屬性的寫法
  • 類屬性使用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)

監聽屬性的改變

• 在OC中我們可以重寫set方法來監聽屬性的改變
• Swift中可以通過屬性觀察者來監聽和響應屬性值的變化
• 通常是監聽存儲屬性和類屬性的改變.(對于計算屬性，我們不需要定義屬性觀察者，因為我們可以在計算屬性的setter中直接觀察并響應這種值的變化)
• 我們通過設置以下觀察方法來定義觀察者
  • willSet：在屬性值被存儲之前設置。此時新屬性值作為一個常量參數被傳入。該參數名默認為newValue，我們可以自己定義該參數名
  • didSet：在新屬性值被存儲后立即調用。與willSet相同，此時傳入的是屬性的舊值，默認參數名為oldValue
  • willSet與didSet只有在屬性第一次被設置時才會調用，在初始化時，不會去調用這些監聽方法
• 監聽的方式如下:
  • 監聽age和name的變化

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

let p : Person = Person()

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

類的構造函數

構造函數的介紹

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

構造函數的基本使用

構造函數的基本使用

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

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

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

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

初始化時給屬性賦值

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

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

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

// 創建一個Person對象
let p = Person(name: "James", age: 18)

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

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

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

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

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

字典轉模型(利用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" : "James", "age" : 18]
let p = Person(dict: dict)

閉包

閉包的介紹

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

閉包的使用

block的用法回顧

• 定義網絡請求的類

@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

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

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

• block寫法總結:

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

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

使用閉包代替block

• 定義網絡請求的類

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()
             })
        }
    }
}

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

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

• 閉包寫法總結:

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

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

• 閉包的簡寫

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

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

  • 尾隨閉包寫法:
    • 如果閉包是函數的最后一個參數,則可以將閉包寫早()后面
    • 如果函數只有一個參數,并且這個參數是閉包,那么()可以不寫

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

閉包的循環引用

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

class HttpTool: NSObject {

    // 定義屬性,來強引用傳入的閉包
    var callBack : (()->())?

    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()
             })
        }

        self.callBack = callBack
    }
}
swift中解決循環引用的方式
    // weak var weakSelf = self;
    // [weak self] () -> () in
    // [unowned self] () -> () in
    httpTool.loadRequest { [unowned self] () -> () in
        self.view.backgroundColor = UIColor.redColor()
        print("回到主線程", NSThread.currentThread());
    }

懶加載

懶加載的介紹

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

懶加載的使用

• 格式

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

• 懶加載的使用

// 懶加載的本質是,在第一次使用的時候執行閉包,將閉包的返回值賦值給屬性
// lazy的作用是只會賦值一次
lazy var array : [String] = {
    () -> [String] in
    return ["James", "Wade", "Kobe"]
}()