常量&變量

什么是常量和變量

• 在Swift中規(guī)定:在定義一個(gè)標(biāo)識(shí)符時(shí)必須明確說明該標(biāo)識(shí)符是一個(gè)常量還是變量
• 使用let來定義常量,定義之后不可以修改
• 使用var來定義變量,定義之后可以修改

基本使用

let a : Int = 10
// 錯(cuò)誤寫法,當(dāng)一個(gè)字段定義為常量時(shí)是不可以修改的
// a = 20

var b : Int = 20
// 因?yàn)閎定義為變量,因此是可以修改的
b = 30

使用注意

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

// 注意:聲明為常量不可以修改的意思是指針不可以再指向其他對象.但是可以通過指針拿到對象,修改其中的屬性
// 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)

數(shù)據(jù)類型

類型的介紹

• Swift中的數(shù)據(jù)類型也有:整型/浮點(diǎn)型/對象類型/結(jié)構(gòu)體類型等等
• 先了解整型和浮點(diǎn)型
• 整型

  • 有符號

    • Int8 : 有符號8位整型
    • Int16 : 有符號16位整型
    • Int32 : 有符號32位整型
    • Int64 : 有符號64位整型
    • Int : 和平臺(tái)相關(guān)(默認(rèn),相當(dāng)于OC的NSInteger)

  • 無符號

    • UInt8 : 無符號8位整型
    • UInt16 : 無符號16位整型
    • UInt32 : 無符號32位整型
    • UInt64 : 無符號64位整型
    • UInt : 和平臺(tái)相關(guān)(常用,相當(dāng)于OC的NSUInteger)(默認(rèn))

  • 浮點(diǎn)型

    • Float : 32位浮點(diǎn)型
    • Double : 64浮點(diǎn)型(默認(rèn))

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

類型推導(dǎo)

• Swift是強(qiáng)類型的語言

• Swift中任何一個(gè)標(biāo)識(shí)符都有明確的類型

• 注意:

  • 如果定義一個(gè)標(biāo)識(shí)符時(shí)有直接進(jìn)行賦值,那么標(biāo)識(shí)符后面的類型可以省略.
  • 因?yàn)镾wift有類型推導(dǎo),會(huì)自動(dòng)根據(jù)后面的賦值來決定前面的標(biāo)識(shí)符的數(shù)據(jù)類型

  // 定義變量時(shí)沒有指定明確的類型,但是因?yàn)橘x值給i一個(gè)20.20為整型.因此i為整型
  var i = 20
  // 錯(cuò)誤寫法:如果之后賦值給i一個(gè)浮點(diǎn)型數(shù)值,則會(huì)報(bào)錯(cuò)
  // i = 30.5
  // 正確寫法
  var j = 3.33
  j = 6.66
  

基本運(yùn)算

• Swift中在進(jìn)行基本運(yùn)算時(shí)必須保證類型一致,否則會(huì)出錯(cuò)

  • 相同類型之間才可以進(jìn)行運(yùn)算
  • 因?yàn)镾wift中沒有隱式轉(zhuǎn)換

• 數(shù)據(jù)類型的轉(zhuǎn)化

  • Int類型轉(zhuǎn)成Double類型:Double(標(biāo)識(shí)符)
  • Double類型轉(zhuǎn)成Int類型:Int(標(biāo)識(shí)符)

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

邏輯分支

if分支語句

• 和OC中if語句有一定的區(qū)別

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

  // 演練一:
  let a = 10
  // 錯(cuò)誤寫法:
  //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("優(yōu)秀")
  } else {
      print("完美")
  }
  // 演練三:
  // 這個(gè)是可選類型,因?yàn)橹挥新暶鞒煽蛇x類型后,才可以判斷是否為空
  // 可選類型會(huì)在后續(xù)講解,可先了解即可
  let view : UIView? = UIView()
  // 判斷如果view有值,則設(shè)置背景
  // 錯(cuò)誤寫法
  //if view {
  //    view.backgroundColor = UIColor.redColor()
  //}
  if view != nil {
      view!.backgroundColor = UIColor.redColor()
  }
  

三目運(yùn)算符

• Swift中的三目運(yùn)算保持了和OC一致的風(fēng)格

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

switch分支

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

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

• 使用補(bǔ)充:

  • 一個(gè)case判斷中,可以判斷多個(gè)值
  • 多個(gè)值以,隔開

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

• 簡單使用補(bǔ)充:

  • 如果希望出現(xiàn)之前的case穿透,則可以使用關(guān)鍵字fallthrough

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

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

  • 浮點(diǎn)型的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支持區(qū)間判斷

  • swift中的區(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("幾個(gè)")
  case 80..<90:
      print("良好")
  case 90..<100:
      print("優(yōu)秀")
  default:
      print("滿分")
  }
  

循環(huán)的介紹

for循環(huán)的寫法

• 最常規(guī)寫法

// 傳統(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)中不需要用到下標(biāo)i

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

while和do while循環(huán)

• while循環(huán)

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

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

• do while循環(huán)

  • 使用repeat關(guān)鍵字來代替了do

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

字符串

字符串的介紹

• 字符串在任何的開發(fā)中使用都是非常頻繁的
• OC和Swift中字符串的區(qū)別
  • 在OC中字符串類型時(shí)NSString,在Swift中字符串類型是String
  • OC中字符串@"",Swift中字符串""
• 使用 String 的原因
  • String 是一個(gè)結(jié)構(gòu)體，性能更高
  • NSString 是一個(gè) OC 對象音念，性能略差
  • String 支持直接遍歷
  • Swift 提供了 String 和 NSString 之間的無縫轉(zhuǎn)換

字符串的使用

• 遍歷字符串

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

• 字符串拼接

  • 兩個(gè)字符串的拼接

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

  • 字符串和其他數(shù)據(jù)類型的拼接

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

• 字符串的格式化

  • 比如時(shí)間:03:04

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

• 字符串的截取

  • Swift中提供了特殊的截取方式
    • 該方式非常麻煩
    • Index創(chuàng)建較為麻煩
  • 簡單的方式是將String轉(zhuǎn)成NSString來使用
    • 在標(biāo)識(shí)符后加: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))
  

數(shù)組

數(shù)組介紹

• 數(shù)組（Array）是一串有序的由相同類型元素構(gòu)成的集合
• 數(shù)組中的集合元素是有序的掂碱，可以重復(fù)出現(xiàn)
• Swift中的數(shù)組
  • swift字典類型是Array，是一個(gè)泛型集合

數(shù)組的初始化

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

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

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

• 在聲明一個(gè)Array類型的時(shí)候可以使用下列的語句之一

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

• 聲明的數(shù)組需要進(jìn)行初始化才能使用春感，數(shù)組類型往往是在聲明的同時(shí)進(jìn)行初始化的

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

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

對數(shù)組的基本操作

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

// 刪除元素
array.removeFirst()

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

// 取值
array[1]
數(shù)組的遍歷

遍歷數(shù)組

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

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

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

數(shù)組的合并

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

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

字典

字典的介紹

• 字典允許按照某個(gè)鍵來訪問元素
• 字典是由兩部分集合構(gòu)成的砌创，一個(gè)是鍵（key）集合虏缸，一個(gè)是值（value）集合
• 鍵集合是不能有重復(fù)元素的，而值集合是可以重復(fù)的嫩实，鍵和值是成對出現(xiàn)的
• Swift中的字典
  • Swift字典類型是Dictionary刽辙，也是一個(gè)泛型集合

字典的初始化

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

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

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

• 在聲明一個(gè)Dictionary類型的時(shí)候可以使用下面的語句之一

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

• 聲明的字典需要進(jìn)行初始化才能使用，字典類型往往是在聲明的同時(shí)進(jìn)行初始化的

// 定時(shí)字典的同時(shí),進(jìn)行初始化
var dict = ["name" : "James", "age" : 18]

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

字典的基本操作

// 添加數(shù)據(jù)
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中特有的
• 它是什么呢?
  • 它是一種數(shù)據(jù)結(jié)構(gòu)甲献，在數(shù)學(xué)中應(yīng)用廣泛宰缤。
  • 類似于數(shù)組或者字典
  • 可以用于定義一組數(shù)據(jù)

元祖的定義

• 元祖的常見寫法有兩種

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

元祖的簡單使用

• 用元組來描述一個(gè)HTTP的錯(cuò)誤信息

// 元祖:HTTP錯(cuò)誤
// 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)

可選類型

可選類型的介紹

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

定義可選類型

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

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

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

可選類型的使用

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

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

// 打印結(jié)果
print(string)
// 結(jié)果:Optional("Hello world")\n
// 因?yàn)榇蛴〕鰜淼氖强蛇x類型,所有會(huì)帶Optional


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

// 注意:如果可選類型為nil,強(qiáng)制取出其中的值(解包),會(huì)出錯(cuò)
string = nil
print(string!) // 報(bào)錯(cuò)

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

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

真實(shí)應(yīng)用場景

• 目的:讓代碼更加嚴(yán)謹(jǐn)

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

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

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

函數(shù)

函數(shù)的介紹

• 函數(shù)相當(dāng)于OC中的方法
• 函數(shù)的格式如下

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

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

常見的函數(shù)類型

// 1.沒有參數(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()

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

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

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

函數(shù)的使用注意

• 注意一: 外部參數(shù)和內(nèi)部參數(shù)
  • 在函數(shù)內(nèi)部可以看到的參數(shù),就是內(nèi)部參數(shù)
  • 在函數(shù)外面可以看到的參數(shù),就是外部參數(shù)
  • 默認(rèn)情況下,從第二個(gè)參數(shù)開始,參數(shù)名稱既是內(nèi)部參數(shù)也是外部參數(shù)
  • 如果第一個(gè)參數(shù)也想要有外部參數(shù),可以設(shè)置標(biāo)簽:在變量名前加標(biāo)簽即可
  • 如果不想要外部參數(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)

• 注意二: 默認(rèn)參數(shù)
  • 某些情況,如果沒有傳入具體的參數(shù),可以使用默認(rèn)參數(shù)

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

• 注意三: 可變參數(shù)
  • swift中函數(shù)的參數(shù)個(gè)數(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)

• 注意四: 引用類型(指針的傳遞)
  • 默認(rèn)情況下,函數(shù)的參數(shù)是值傳遞.如果想改變外面的變量,則需要傳遞變量的地址
  • 必須是變量,因?yàn)樾枰趦?nèi)部改變其值
  • Swift提供的inout關(guān)鍵字就可以實(shí)現(xiàn)
  • 對比下列兩個(gè)函數(shù)

// 函數(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ù)的嵌套使用(暫時(shí)了解即可)
  • swift中函數(shù)可以嵌套使用
  • 即函數(shù)中包含函數(shù),但是不推薦該寫法

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

Swift中類的定義

類的介紹

• Swift也是一門面向?qū)ο箝_發(fā)的語言
• 面向?qū)ο蟮幕A(chǔ)是類,類產(chǎn)生了對象
• 在Swift中如何定義類呢?
  • class是Swift中的關(guān)鍵字,用于定義類

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

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

如何定義類的屬性

類的屬性介紹

• Swift中類的屬性有多種
  • 存儲(chǔ)屬性:存儲(chǔ)實(shí)例的常量和變量
  • 計(jì)算屬性:通過某種方式計(jì)算出來的屬性
  • 類屬性:與整個(gè)類自身相關(guān)的屬性

存儲(chǔ)屬性

• 存儲(chǔ)屬性是最簡單的屬性球及，它作為類實(shí)例的一部分氧骤，用于存儲(chǔ)常量和變量
• 可以給存儲(chǔ)屬性提供一個(gè)默認(rèn)值，也可以在初始化方法中對其進(jìn)行初始化
• 下面是存儲(chǔ)屬性的寫法
  • age和name都是存儲(chǔ)屬性,用來記錄該學(xué)生的年齡和姓名
  • chineseScore和mathScore也是存儲(chǔ)屬性,用來記錄該學(xué)生的語文分?jǐn)?shù)和數(shù)學(xué)分?jǐn)?shù)

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

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

// 創(chuàng)建學(xué)生對象
let stu = Student()

// 給存儲(chǔ)屬性賦值
stu.age = 10
stu.name = "why"

stu.chineseScore = 89.0
stu.mathScore = 98.0

計(jì)算屬性

• 計(jì)算屬性并不存儲(chǔ)實(shí)際的值吃引，而是提供一個(gè)getter和一個(gè)可選的setter來間接獲取和設(shè)置其它屬性
• 存儲(chǔ)屬性一般只提供getter方法
• 如果只提供getter筹陵，而不提供setter，則該計(jì)算屬性為只讀屬性,并且可以省略get{}
• 下面是計(jì)算屬性的寫法
  • averageScore是計(jì)算屬性,通過chineseScore和mathScore計(jì)算而來的屬性
  • 在setter方法中有一個(gè)newValue變量,是系統(tǒng)指定分配的

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

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

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

        // 沒有意義,因?yàn)橹螳@取值時(shí)依然是計(jì)算得到的
        // newValue是系統(tǒng)分配的變量名,內(nèi)部存儲(chǔ)著新值
        set {
            self.averageScore = newValue
        }
    }
}

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

類屬性

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

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

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

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

        // 沒有意義.newValue是系統(tǒng)分配的變量名,內(nèi)部存儲(chǔ)著新值
        set {
            self.averageScore = newValue
        }
    }

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

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

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

• 在OC中我們可以重寫set方法來監(jiān)聽屬性的改變
• Swift中可以通過屬性觀察者來監(jiān)聽和響應(yīng)屬性值的變化
• 通常是監(jiān)聽存儲(chǔ)屬性和類屬性的改變.(對于計(jì)算屬性惶翻，我們不需要定義屬性觀察者，因?yàn)槲覀兛梢栽谟?jì)算屬性的setter中直接觀察并響應(yīng)這種值的變化)
• 我們通過設(shè)置以下觀察方法來定義觀察者
  • willSet：在屬性值被存儲(chǔ)之前設(shè)置鹅心。此時(shí)新屬性值作為一個(gè)常量參數(shù)被傳入吕粗。該參數(shù)名默認(rèn)為newValue，我們可以自己定義該參數(shù)名
  • didSet：在新屬性值被存儲(chǔ)后立即調(diào)用旭愧。與willSet相同颅筋，此時(shí)傳入的是屬性的舊值，默認(rèn)參數(shù)名為oldValue
  • willSet與didSet只有在屬性第一次被設(shè)置時(shí)才會(huì)調(diào)用输枯，在初始化時(shí)议泵，不會(huì)去調(diào)用這些監(jiān)聽方法
• 監(jiān)聽的方式如下:
  • 監(jiān)聽age和name的變化

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

let p : Person = Person()

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

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

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

• 構(gòu)造函數(shù)類似于OC中的初始化方法:init方法
• 默認(rèn)情況下載創(chuàng)建一個(gè)類時(shí),必然會(huì)調(diào)用一個(gè)構(gòu)造函數(shù)
• 即便是沒有編寫任何構(gòu)造函數(shù)，編譯器也會(huì)提供一個(gè)默認(rèn)的構(gòu)造函數(shù)桃熄。
• 如果是繼承自NSObject,可以對父類的構(gòu)造函數(shù)進(jìn)行重寫

構(gòu)造函數(shù)的基本使用

構(gòu)造函數(shù)的基本使用

• 類的屬性必須有值
• 如果不是在定義時(shí)初始化值,可以在構(gòu)造函數(shù)中賦值

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

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

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

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

• 很多時(shí)候,我們在創(chuàng)建一個(gè)對象時(shí)就會(huì)給屬性賦值
• 可以自定義構(gòu)造函數(shù)
• 注意:如果自定義了構(gòu)造函數(shù),會(huì)覆蓋init()方法.即不在有默認(rèn)的構(gòu)造函數(shù)

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

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

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

字典轉(zhuǎn)模型(初始化時(shí)傳入字典)

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

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

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

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

字典轉(zhuǎn)模型(利用KVC轉(zhuǎn)化)

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

class Person: NSObject {
    // 結(jié)構(gòu)體或者類的類型,必須是可選類型.因?yàn)椴荒鼙ＷC一定會(huì)賦值
    var name : String?

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

    // 自定義構(gòu)造函數(shù),會(huì)覆蓋init()函數(shù)
    init(dict : [String : NSObject]) {
        // 必須先初始化對象
        super.init()
        // 調(diào)用對象的KVC方法字典轉(zhuǎn)模型
        setValuesForKeysWithDictionary(dict)
    }
}
// 創(chuàng)建一個(gè)Person對象
let dict = ["name" : "James", "age" : 18]
let p = Person(dict: dict)

閉包

閉包的介紹

• 閉包和OC中的block非常相似
  • OC中的block是匿名的函數(shù)
  • Swift中的閉包是一個(gè)特殊的函數(shù)
  • block和閉包都經(jīng)常用于回調(diào)

閉包的使用

block的用法回顧

• 定義網(wǎng)絡(luò)請求的類

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

@implementation HttpTool
- (void)loadRequest:(void (^)())callBackBlock
{
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"加載網(wǎng)絡(luò)數(shù)據(jù):%@", [NSThread currentThread]);

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

• 進(jìn)行網(wǎng)絡(luò)請求,請求到數(shù)據(jù)后利用block進(jìn)行回調(diào)

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

• block寫法總結(jié):

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

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

使用閉包代替block

• 定義網(wǎng)絡(luò)請求的類

class HttpTool: NSObject {

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

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

• 進(jìn)行網(wǎng)絡(luò)請求,請求到數(shù)據(jù)后利用閉包進(jìn)行回調(diào)

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

• 閉包寫法總結(jié):

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

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

• 閉包的簡寫

  • 如果閉包沒有參數(shù),沒有返回值.in和in之前的內(nèi)容可以省略

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

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

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

閉包的循環(huán)引用

• 如果在HttpTool中有對閉包進(jìn)行強(qiáng)引用,則會(huì)形成循環(huán)引用

class HttpTool: NSObject {

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

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

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

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

懶加載

懶加載的介紹

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

懶加載的使用

• 格式

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

• 懶加載的使用

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