前言：
1.此文中的語法會(huì)根據(jù)Swift的升級(jí)變動(dòng)而更新。
2.如果需要請(qǐng)移步 -> swift2.2 語法（上）雳殊、swift 2.2語法（下）

函數(shù)

• 和C語言一樣，swift也有函數(shù)窗轩，性質(zhì)和我們熟悉的Objective-C的方法相當(dāng)

• 格式：
  
  
  

  func 函數(shù)名(參數(shù)列表) -> 返回值類型 {
      代碼塊
      //  如果設(shè)置了返回值類型夯秃，就需要返回相應(yīng)的返回值
      return 返回值
  }
  
  

  • func是swift內(nèi)的關(guān)鍵字，參數(shù)列表內(nèi)多個(gè)參數(shù)之間用 "," 隔開痢艺，可以沒有參數(shù)
  • "->" 指向返回值類型
  • 當(dāng)然仓洼，如果函數(shù)沒有返回值（返回值為Void），那么 "-> 返回值類型" 這部分可以省略不寫（默認(rèn)就是沒有返回值）

• 函數(shù)幾種定義方式：

  //  定義沒有參數(shù)堤舒，沒有返回值的函數(shù)
  
  //  標(biāo)準(zhǔn)寫法
  func test1() -> Void {
      print("沒有參數(shù)沒有返回值的函數(shù)")
  }
  //  簡寫方式一
  func test2() -> () {
      print("沒有參數(shù)沒有返回值的函數(shù)")
  }
  //  簡寫方式二
  func test3() {
      print("沒有參數(shù)沒有返回值的函數(shù)")
  }
  
  //  定義有參數(shù)色建，沒有返回值的函數(shù)
  
  //  標(biāo)準(zhǔn)寫法
  func test1(num : Int) -> Void {
      print("有參數(shù)沒有返回值的函數(shù)")
  }
  //  簡寫方式一
  func test2(num : Int) -> () {
      print("有參數(shù)沒有返回值的函數(shù)")
  }
  //  簡寫方式二
  func test3(num : Int) {
      print("有參數(shù)沒有返回值的函數(shù)")
  }
  
  //  定義沒有參數(shù)，有返回值的函數(shù)
  
  //  標(biāo)準(zhǔn)寫法
  func test1() -> Int {
      return 0
  }
  
  //  定義有返回值舌缤，有參數(shù)的函數(shù)
  
  //  標(biāo)準(zhǔn)寫法
  func test1(num1 : Int, num2 : Int) -> Int {
      return num1 + num2
  }
  
  //  定義一個(gè)有參數(shù)箕戳，且有多個(gè)返回值的函數(shù)
  
  //  標(biāo)準(zhǔn)寫法
  func test1(nums : [String]) -> (strCount : Int, spellString : String) {
  
      var strCount = 0
      var spellString = ""
  
      for num in nums {
          strCount++
      
          spellString = spellString + num
      }
  
      return (strCount, spellString)
  }
  //  調(diào)用函數(shù)
  print(test1(["abc", "def", "ghi"]))
  
  

• 函數(shù)的外部參數(shù)和內(nèi)部參數(shù)

  • 內(nèi)部參數(shù)：在函數(shù)內(nèi)部可以看到的參數(shù)
  • 外部參數(shù)：在函數(shù)外面可以看到的參數(shù)
  • 從第二個(gè)參數(shù)開始，參數(shù)名稱即是內(nèi)部參數(shù)也是外部參數(shù)（默認(rèn)）
    
    
    

  //  先來定義一個(gè)擁有多個(gè)參數(shù)的函數(shù)
  func test1(num1 : Int, num2 : Int, num3 : Int) -> Void {
      print(num1, num2, num3)
  }
  
  //  在調(diào)用函數(shù)的時(shí)候可以看下區(qū)別
  /*
  *  第一個(gè)函數(shù)沒有跟上我們定義參數(shù)時(shí)所給的標(biāo)簽
  *  后面的所有函數(shù)都有我們定義參數(shù)時(shí)所給的標(biāo)簽
  *  原因：從第二個(gè)參數(shù)開始国撵，參數(shù)名稱即是內(nèi)部參數(shù)也是外部參數(shù)（默認(rèn)）
  *  也就是說第一個(gè)參數(shù)默認(rèn)為內(nèi)部參數(shù)陵吸，所以不會(huì)顯示標(biāo)簽
  */
  test1(5, num2: 6, num3: 7)
  
  

  • 如果第一個(gè)參數(shù)也想有外部參數(shù)，可以設(shè)置標(biāo)簽：在變量名前增加標(biāo)簽
    
    
    

  //  先來定義一個(gè)擁有多個(gè)參數(shù)的函數(shù)介牙，但是這次我們要讓第一個(gè)參數(shù)也有外部參數(shù)
  
  func test1(num1 num1: Int, num2 : Int, num3 : Int) -> Void {
      print(num1, num2, num3)
  }
  
  //  現(xiàn)在再調(diào)用函數(shù)可以看到第一個(gè)參數(shù)也變擁有外部參數(shù)
  test1(num1: 5, num2: 6, num3: 7)
  
  

  • 在參數(shù)名稱前加 "_" 壮虫，表示不需要外部參數(shù)
    
    
    

  //  先來定義一個(gè)擁有多個(gè)參數(shù)的函數(shù),這次我們讓所有參數(shù)都為內(nèi)部參數(shù)
  
  func test1 (num1 : Int, _ num2 : Int, _ num3 : Int) -> Void {
      print(num1, num2, num3)
  }
  
  //  現(xiàn)在調(diào)用函數(shù)就會(huì)發(fā)現(xiàn)所有的參數(shù)都成為內(nèi)部參數(shù)了
  test1(5, 6, 7)
  
  

• 函數(shù)重載

  • 函數(shù)名稱相同，但參數(shù)不同环础，可以稱為函數(shù)重載
  • 參數(shù)擁有內(nèi)部參數(shù)或外部參數(shù)不同囚似，也被認(rèn)定為參數(shù)不同
    
    
    

  //  函數(shù)重載例：定義三個(gè)函數(shù)，函數(shù)名相同但函數(shù)的參數(shù)不同
  
  //  無返回值线得，第一個(gè)參數(shù)為內(nèi)部參數(shù)饶唤，第二個(gè)參數(shù)同時(shí)擁有外部和內(nèi)部參數(shù)
  func test(num1 : Int, num2 : Int) -> Void {
      print("第一個(gè)函數(shù)")
  }
  
  //  無返回值，且都同時(shí)沒有外部參數(shù)
  func test(num1 : Int, _ num2 : Int) -> Void {
      print("第二個(gè)函數(shù)")
  }
  
  //  無返回值框都，但同時(shí)擁有外部和內(nèi)部參數(shù)
  func test(num1 num1 : Int, num2 : Int) -> Void {
      print("第三個(gè)函數(shù)")
  }
  
  //  調(diào)用函數(shù)
  test(1, num2: 2)
  test(1, 2)
  test(num1: 1, num2: 2)
  
  

• 默認(rèn)參數(shù)

  • 在一些特定情況下搬素，調(diào)用函數(shù)時(shí)如果沒有傳入具體參數(shù)呵晨，可以使用默認(rèn)參數(shù)代替(相當(dāng)于我們?cè)诙x參數(shù)時(shí)就給參數(shù)一個(gè)默認(rèn)值)

  //  默認(rèn)參數(shù)
  
  func test(num : Int = 5) -> Int {
  
      return num
  }
  
  //  調(diào)用參數(shù)不給值魏保，返回的的就是默認(rèn)值 “5”
  test()
  
  

• 可變參數(shù)

  • swift函數(shù)的參數(shù)個(gè)數(shù)可以變化，可以接收不確定數(shù)量的輸入類型參數(shù)
  • 需要注意的是摸屠，這些參數(shù)必須具有相同的類型
  • 方法：在參數(shù)類型后面加 "..." 表示參數(shù)為可變參數(shù)
    
    
    

  //  定義函數(shù)谓罗，參數(shù)為可變參數(shù)
  func test(nums : Int...) -> Int {
  
      var sum : Int = 0
      //  遍歷內(nèi)部元素
      for temp in nums {
          sum += temp
      }
  
      return sum
  }
  
  //  調(diào)用函數(shù)，結(jié)果為202
  test(20, 15, 35, 32, 100)
  
  

• 指針傳遞（引用類型）

  • 函數(shù)的參數(shù)是通過值傳遞的方式季二，如果想改變外面的變量檩咱，需要傳遞變量地址（默認(rèn)）
  • swift提供了 "inout" 關(guān)鍵字來幫助我們實(shí)現(xiàn)
  • 需要注意的都是揭措，操作的必須是變量，因?yàn)樾枰趦?nèi)部改變值
    
    
    

  //  比如C語言中常見的問題：交換2個(gè)變量的值
  
  //  先來看看正常的值傳遞
  //  定義需要交換值的2個(gè)變量a,b
  var a = 6
  var b = 9
  
  //  值傳遞方式
  func test(var num1: Int, var num2: Int) -> (num1 : Int, num2 : Int) {
  
      let temp = num1
      num1 = num2
      num2 = temp
  
      return (num1,num2)
  }
  
  //  調(diào)用函數(shù)（交換的只是函數(shù)內(nèi)部參數(shù)的值刻蚯，而a,b的值并沒變）
  test(a, num2: b)    //  結(jié)果 9  6
  print(a, b) //  結(jié)果  6   9
  
  //  通過上面的方式可以明顯看出值傳遞并不能真實(shí)轉(zhuǎn)換外部變量的值绊含，在swift中我們可以通  過"inout"關(guān)鍵字來講外部變量的值傳給函數(shù)參數(shù)，再改變其值
  func test(inout num1 : Int, inout num2 : Int) -> (num1 : Int, num2 : Int) {
  
      let temp = num1
      num1 = num2
      num2 = temp
  
      return (num1, num2)
  
  }
  
  //  調(diào)用函數(shù)（因?yàn)閭魅氲氖莂,b的變量地址炊汹，等于拿到了外部變量躬充，函數(shù)內(nèi)部操作的num1,num2可以看成a,b，因?yàn)樗麄兊闹羔樦赶蛄薬,b）
  test(&a, num2: &b)
  print(a,b)
  
  

• 函數(shù)嵌套使用

  • swift中函數(shù)可以嵌套使用
  • 雖然可以嵌套使用讨便，但是這種做法降低了可讀性充甚，所以盡量不要這樣做
    
    

  //  函數(shù)嵌套
  
  let a = 100
  let b = 35
  
  func test() {
      func sum(num1 : Int, num2 : Int) {
          print("和為\(num1 + num2)")
      }
  
      print("test函數(shù)")
      sum(a, num2: b)
  }
  
  //  調(diào)用函數(shù)
  test()  //  先調(diào)用test函數(shù)，再調(diào)用sum函數(shù)
  
  

  注意：無法調(diào)用sum函數(shù)霸褒，因?yàn)樗莟est函數(shù)的一部分

• 函數(shù)類型

  • 每個(gè)函數(shù)都有屬于自己的類型伴找，由函數(shù)的參數(shù)類型和返回值類型組成
    
    
    

  //  函數(shù)類型：定義2個(gè)函數(shù)，且都為 (String, String) -> (String) 類型
  
  func test1(name : String, city : String) -> String {
      return name + city
  }
  
  func test2(tiele : String, iconUrl : String) -> String {
      return "圖片名稱:\(tiele)圖片地址為:\(iconUrl)"
  }
  
  

• 將函數(shù)作當(dāng)成變量傳遞

//  根據(jù)函數(shù)類型定義變量并將函數(shù)傳遞給變量
var tempFunction : (String, String) -> String = test1
//  使用變量名調(diào)用函數(shù)
tempFunction("sd", "lw")

• 將函數(shù)當(dāng)成參數(shù)使用

//  將函數(shù)當(dāng)成參數(shù)使用
func test3(str1 : String, str2 : String, tempFunction : (String, String) -> String) {
    print(tempFunction(str1, str2))
}

//  調(diào)用函數(shù)
test3("aa", str2: "bb", tempFunction: test1)    //  結(jié)果 aabb

• 函數(shù)當(dāng)成返回值

//  函數(shù)作為方法返回值
/**
 *  判斷一數(shù)是否為負(fù)數(shù)废菱，是負(fù)數(shù)返回0技矮，不是則返回原來的值
 */

//  正數(shù)調(diào)用此函數(shù)
func positive(num : Int) -> Int {
    
    return num
}
//  負(fù)數(shù)調(diào)用此函數(shù)
func negative(num : Int) -> Int {
    
    return 0
}

//  將函數(shù)作為返回值
func test(num : Int) -> (Int) -> Int {
    //  如果函數(shù)小于1就是負(fù)數(shù)，返回negative函數(shù)殊轴，如果大于1穆役，則是正數(shù)，返回positive函數(shù)
    return num < 0 ? negative : positive
}

//  獲取返回值（函數(shù)）
let function = test(-1) //  因?yàn)槭秦?fù)數(shù)梳凛，所以返回negative函數(shù)

//  調(diào)用方法（再將-1傳入返回的函數(shù)）
function(-1)   //  結(jié)果為 0

枚舉類型

• 枚舉用來定義一組通用類型的相關(guān)值耿币，可以讓達(dá)到讓使用者按照設(shè)計(jì)者的規(guī)范使用特定的值

• swift的枚舉非常靈活，可以給枚舉成員提供一個(gè)字符串韧拒，一個(gè)字符淹接，一個(gè)整型或浮點(diǎn)值，不必給每個(gè)枚舉成員提供值

• C語言和OC里面枚舉指定的一組相關(guān)成員為整型

• 枚舉類型定義

  • 使用 enum 關(guān)鍵詞叛溢，將定義放在{}內(nèi)
  • 使用 case 關(guān)鍵詞定義新枚舉成員
  • 需要注意的是塑悼，swift的枚舉在被創(chuàng)建的時(shí)候不會(huì)像C和OC那樣賦予默認(rèn)整型值

  //  枚舉定義
  enum testType {
      case testTypeOne
      case testTypeTwo
      case testTypeThree
  }
  //  當(dāng)然也可以簡寫成下面的方式（在枚舉成員特別多的情況下很好用）
  enum testType {
      case testTypeOne, testTypeTwo, testTypeThree
  }
  
  

• 枚舉類型賦值

• 枚舉類型賦值可以是整型、浮點(diǎn)型楷掉、字符厢蒜、字符串

  • 如果有給枚舉類型賦值，必須在枚舉類型后面明確類型使用的類型
    
    
    

  //  枚舉類型賦值
  enum testType1 : Int {
      case One = 1
      case Two = 2
      case Three = 3
  }
  //  或
  enum testType2 : Int{
      case One = 1, Two, Three
  }
  
  

• 枚舉類型使用

//  枚舉類型賦值(整型)
enum testType1 : Int {
    case One = 1
    case Two 
    case Three 
}

//  枚舉類型賦值(字符串)

enum testType2 : String{
    case One = "a", Two = "b", Three
}

let j = testType1(rawValue: 2)  //  獲取到枚舉成員Two

//  結(jié)果為Two
if let j = j {
    switch j {
    case .One:
        print("One")
    case .Two:
        print("Two")
    case .Three:
        print("Three")
    }
}

let i = testType2(rawValue: "a")    //  獲取到枚舉成員One

//  結(jié)果為One
if let i = i {
    switch i {
    case .One:
        print("One")
    case .Two:
        print("Two")
    case .Three:
        print("Three")
    }
}

注意：

1.如果明確了類型為整型且未設(shè)置初始值烹植，那么由0開始依次遞增（默認(rèn)）

2.如果明確了類型為整型但設(shè)置了初始值斑鸦，就由初始值依次遞增

結(jié)構(gòu)體（struct）

• 結(jié)構(gòu)體是一種數(shù)據(jù)結(jié)構(gòu)

• 結(jié)構(gòu)體在方法（函數(shù)）中傳遞時(shí)時(shí)值傳遞，是值類型

• 結(jié)構(gòu)體是由一組相同類型或不同類型的數(shù)據(jù)組成的數(shù)據(jù)集合

• 在特定情況下使用結(jié)構(gòu)體草雕，能使我們的代碼結(jié)構(gòu)更清晰

• 定義結(jié)構(gòu)體格式

struct 結(jié)構(gòu)體名稱 {
    屬性
}

• 結(jié)構(gòu)體使用

/**
 *  在手勢(shì)開發(fā)過程中巷屿，我們需要監(jiān)聽手指移動(dòng)的位置，這邊我們來判斷手指移動(dòng)的開始位置和結(jié)束位置距離是否大于50
 */
 
//  初始化結(jié)構(gòu)體
struct touchPoint {
    var x : Double
    var y : Double
}

//  定義函數(shù)
func Range(point : touchPoint) -> Bool {
    let tempX = point.x - startX
    let tempY = point.y - startY
    //  sqrt(n)用來計(jì)算n的平方根
    //  pow(x, n)用來計(jì)算x的n次方
    let range = sqrt(pow(tempX, 2) + pow(tempY,2))
    
    return range > 50
}

//  創(chuàng)建結(jié)構(gòu)體
let start = touchPoint(x:53.0, y:21.0)
let end = touchPoint(x: 120.0, y: 320.0)

//  調(diào)用函數(shù)
Range(point)    //  結(jié)果：true

• 結(jié)構(gòu)體增強(qiáng)
  • 擴(kuò)充構(gòu)造函數(shù)
    • 默認(rèn)情況下創(chuàng)建touchPoint時(shí)使用touchPoint(x:,y:)
    • 為了更加靈活地使用結(jié)構(gòu)體墩虹，swift支持對(duì)構(gòu)造函數(shù)進(jìn)行擴(kuò)充
    • 在擴(kuò)充的構(gòu)造函數(shù)中必須保證成員變量有值
    • 擴(kuò)充的構(gòu)造函數(shù)會(huì)覆蓋原有的構(gòu)造函數(shù)

截止至：5.17 —— 1：00 5.18繼續(xù)

類的定義

• swift也是面向?qū)ο箝_發(fā)的語言嘱巾，而面向?qū)ο蟮幕A(chǔ)是類憨琳，由類產(chǎn)生對(duì)象

• 在swift中定義類使用 class 關(guān)鍵字

• 類的注意點(diǎn)：

  • 定義的類可以沒有父類，也就是這個(gè)類就是rootClass
  • 一般情況下旬昭，定義類的時(shí)候篙螟，繼承自NSObject(但并不是OC中的NSObject)

• 格式：class 類名 : 父類 {
  屬性，方法
  }

• 類的屬性

  • siwft中類的屬性分為：
    • 存儲(chǔ)屬性： 存儲(chǔ)實(shí)例常量和變量的屬性
    • 類屬性：與整個(gè)類自身相關(guān)的屬性
    • 計(jì)算屬性：通過某些算法計(jì)算出來的屬性

• 存儲(chǔ)屬性

  • 存儲(chǔ)屬性是最簡單的屬性问拘，作為類實(shí)例的一部分闲擦，用于存儲(chǔ)變量和常量
  • 可給存儲(chǔ)屬性提供默認(rèn)值，也可以在初始化方法中對(duì)其進(jìn)行初始化
    
    
    

  //  定義person類
  class person: NSObject {
      //  定義存儲(chǔ)屬性
      var name : String?  //  名字
      var age : Int = 0   //  年齡
  }
  
  //  創(chuàng)建person對(duì)象
  let ps = person()
  
  //  給存儲(chǔ)屬性賦值
  ps.name = "stephen"
  ps.age = 23
  
  

• 類屬性

  • 類屬性是與類相關(guān)聯(lián)的屬性场梆，但不是與類實(shí)例相關(guān)聯(lián)的屬性
  • 所有的實(shí)例和類共有一份類屬性墅冷，所以只要有某一處修改，這個(gè)類的屬性就會(huì)被修改
  • 類屬性的設(shè)置和修改必須通過類來完成
  • 類屬性使用 static 來修飾
    
    
    

  //  定義person類
  class person: NSObject {
      //  定義存儲(chǔ)屬性
      var name : String?  //  名字
      var age : Int = 0   //  年齡
  
      //  類屬性
      static var nickName : String?
  }
  
  //  設(shè)置類屬性值
  person.nickName = "laoWang"
  //  打印
  print(person.nickName!) //  結(jié)果：laoWang
  
  

• 計(jì)算屬性

  • 計(jì)算屬性并不會(huì)存儲(chǔ)實(shí)際的值或油，而是提供一個(gè)getter和一個(gè)setter(可選類型)間接獲取和設(shè)置其它屬性
  • 一般情況下寞忿，只會(huì)提供getter方法，這種情況下的計(jì)算屬性為只讀屬性顶岸，可以省略 get{}
    
    
    

  //  定義person類
  class person: NSObject {
      //  定義存儲(chǔ)屬性
      var foodIntake : Double = 0.0 //    人的食量（一頓吃幾碗）
      var consume : Double = 0.0   //     消耗量
  
      //  定義計(jì)算屬性（差值）
      var difference : Double {
          get {
              return (foodIntake - consume)
          }
      
          //  newValue是系統(tǒng)自動(dòng)分配的變量名腔彰，內(nèi)部用來存儲(chǔ)新的值
          //  里面放的是get方法里面計(jì)算的值
          set {
              self.difference = newValue
          }
      }
  
  }
  
  //  創(chuàng)建person對(duì)象
  let  ps = person()
  
  ps.foodIntake = 50  //  吃的有點(diǎn)多肯定比我胖
  ps.consume = 25 //  消耗這么多驚呆小伙伴，看來是個(gè)肌肉男
  
  //  打印
  print(ps.difference)    //  結(jié)果 25.0
  
  

類的屬性改變監(jiān)聽

• OC里面我們可以重寫set方法來監(jiān)聽屬性值的改變
• swift則需要通過屬性觀察者來監(jiān)聽和相應(yīng)屬性值的變化
• 一般只會(huì)監(jiān)聽存儲(chǔ)屬性和類屬性改變辖佣，計(jì)算屬性我們不需要定義屬性觀察者霹抛，因?yàn)槲覀兛梢栽谟?jì)算屬性的setter中直接觀察并響應(yīng)其值得變化
• swift使用下面的觀察方法定義觀察者
  • willSet：在屬性值被存儲(chǔ)之前設(shè)置（新值會(huì)通過常量參數(shù)的方式傳入，這個(gè)參數(shù)就是newValue卷谈，我們可以給這個(gè)參數(shù)定義參數(shù)名杯拐，但一般保持默認(rèn)）
  • didSet：新值被存儲(chǔ)后立即調(diào)用這個(gè)方法，和willSet相同世蔗，這時(shí)傳入的值是屬性的舊值端逼，默認(rèn)的參數(shù)名叫oldValue
  • willSet和didSet只在屬性第一次被設(shè)置的時(shí)候才會(huì)調(diào)用，初始化的時(shí)候并不會(huì)調(diào)用這2個(gè)監(jiān)聽方法

class person: NSObject {
    var name : String? {
        
        willSet (newValue) {    //  屬性即將改變時(shí)調(diào)用
            //  會(huì)傳入系統(tǒng)默認(rèn)的屬性newValue污淋，用來存儲(chǔ)新值
            print("name:\(name), newValue:\(newValue)") //  結(jié)果：name:nil, newValue:Optional("laoWang")
        }
        
        didSet (oldValue) {
            //  會(huì)傳入系統(tǒng)默認(rèn)的屬性oldValue,用來存儲(chǔ)舊值
            print("name:\(name), oldValue\(oldValue)")  //  結(jié)果：name:Optional("laoWang"), oldValuenil
        }
    }
    
}

//  創(chuàng)建person對(duì)象
let ps : person = person()

ps.name = "laoWang"

類的構(gòu)造函數(shù)

• 默認(rèn)情況下創(chuàng)建一個(gè)類的時(shí)候顶滩，就會(huì)調(diào)用一個(gè)構(gòu)造函數(shù)

• 就算我們沒有編寫任何構(gòu)造函數(shù)，編譯器也會(huì)提供一個(gè)默認(rèn)的構(gòu)造函數(shù)

• 如果類繼承自NSObject,可以對(duì)父類的構(gòu)造函數(shù)進(jìn)行重寫

• 構(gòu)造函數(shù)和OC中的初始化方法init:相似

• 構(gòu)造函數(shù)使用

  • 類的屬性必須有值
  • 如果在定義時(shí)沒有初始化值寸爆，可以在構(gòu)造函數(shù)內(nèi)進(jìn)行賦值
    
    
    

  class person: NSObject {
  
      var name : String
  
      //  因?yàn)槔^承自NSObject礁鲁，我們就重寫（父類）的構(gòu)造方法
      //  override關(guān)鍵字表示調(diào)用父類方法
      override init() {
          //  在初始化name屬性時(shí)沒有給它賦值，所以可以在構(gòu)造函數(shù)里面進(jìn)行賦值
          name = "laoWang"
      }
  }
  
  //  創(chuàng)建person對(duì)象
  let ps : person = person()
  
  print(ps.name)  //  結(jié)果：laoWang
  
  

• 初始化時(shí)給屬性賦值

  • 一般我們?cè)趧?chuàng)建一個(gè)對(duì)象的時(shí)候就會(huì)同時(shí)給屬性賦值赁豆，這時(shí)候我們可以自定義構(gòu)造函數(shù)
  • 需要注意的：如果我們自定義了構(gòu)造函數(shù)仅醇，就會(huì)覆蓋init:方法，也就是說不會(huì)有默認(rèn)構(gòu)造函數(shù)
    
    
    

  class person: NSObject {
  
      var name : String
  
      //  自定義構(gòu)造函數(shù)歌憨，覆蓋init:函數(shù)
      init(name : String) {
          //  在初始化self.name屬性時(shí)沒有給它賦值着憨，所以可以在構(gòu)造函數(shù)里面進(jìn)行賦值
          self.name = name
      }
  
  }
  
  //  創(chuàng)建person對(duì)象
  let ps : person = person(name: "laoWang")
  
  print(ps.name)  //  結(jié)果：laoWang
  
  

• 字典轉(zhuǎn)模型方式一

  • 開發(fā)中，我們經(jīng)常會(huì)將字典轉(zhuǎn)換成模型在來使用务嫡，這邊就以此做例子
  • 需要注意的是：字典中取出的數(shù)據(jù)類型為NSObject,我們可以通過as!將其轉(zhuǎn)成需要的類型
    
    
    

  class person: NSObject {
  
      var name : String
  
      //  自定義構(gòu)造函數(shù)甲抖，覆蓋init:函數(shù)
      init(dict : [String : NSObject]) {
      
          self.name = dict["name"] as! String
      }
  
  }
  
  //  創(chuàng)建person對(duì)象
  let ps : person = person(dict:["name" : "laoWang"])
  
  print(ps.name)  //  結(jié)果：laoWang
  
  

• 字典轉(zhuǎn)模型方式二

  • 開發(fā)中我們經(jīng)常會(huì)用KVC的方式將字典轉(zhuǎn)成模型，這邊就使用KVC對(duì)字典進(jìn)行轉(zhuǎn)換

  • 需要注意的是：KVC不能保證給所有屬性賦值心铃，所以屬性需要有默認(rèn)的值

    • 對(duì)象准谚、結(jié)構(gòu)體類型定義一般為可選類型就可以了，因?yàn)榭蛇x類型沒有賦值前為nil
    • 基本數(shù)據(jù)類型一般設(shè)置為0
      
      
      

    class person: NSObject {
        //  KVC方式下去扣，對(duì)象柱衔、結(jié)構(gòu)體類型必須是可選類型，否則無法轉(zhuǎn)換
        var name : String?
    
        //  自定義構(gòu)造函數(shù)愉棱，覆蓋init:函數(shù)
        init(dict : [String : NSObject]) {
    
            //  必須先初始化對(duì)象
            super.init()
    
            //  調(diào)用對(duì)象的KVC方法
            setValuesForKeysWithDictionary(dict)
         }
    
    }
    
    //  創(chuàng)建person對(duì)象
    let ps : person = person(dict:["name" : "laoWang"])
    
    print(ps.name)  //  結(jié)果：laoWang