• Playground是什么?
  從Xcode6開始出現(xiàn)(Swift開始出現(xiàn))
  翻譯為:操場/游樂場
  對于學(xué)習(xí)Swift基本語法非常方便
  所見即所得(快速查看結(jié)果)
  語法特性發(fā)生改變時,可以快速查看.

• Swift最基本的語法變化

1. 導(dǎo)入框架 import UIKit

// 1.導(dǎo)入框架
//#import <UIKit/UIKit.h>
import UIKit

2. 定義標識符時贪薪，必須聲明該標識符是變量還是常量
   聲明標識符的格式:變量/常量關(guān)鍵字 名稱 : 數(shù)據(jù)類型

2.定義一個標識符
// int a = 10;
// swift中定義標識符:必須制定該標識符是一個常量還是一個變量
// var(變量)/let(常量) 標識符的名稱 : 標識符的類型 = 初始化值
var a : Int = 10;
let b : Double = 3.14;
a = 29;
// b = 3.11 錯誤寫法
print ("nihao");

3. 語句結(jié)束時不需要加;
   如果同一行有多個語句,則依然需要加
   但是不建議一行多條語句

var m : Int = 20
let n : Double = 3.44

4. Swift中的打印語句:print(打印的內(nèi)容)

// NSLog(@"%d", a)
print(a)
print("hello world")

常量和變量

• 在Swift中規(guī)定:在定義一個標識符時必須明確說明該標識符是一個常量還是變量

• 使用let來定義常量,定義之后不可以修改

• 使用var來定義變量,定義之后可以修改

• 常量和變量的基本使用

import UIKit

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

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

常量和變量的使用注意:

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

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

Swift類型的介紹

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

• 整型

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

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

• 浮點型
  Float : 32位浮點型
  Double : 64浮點型(默認)

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

Swift中的類型推導(dǎo)

• Swift是強類型的語言
• Swift中任何一個標識符都有明確的類型
• 注意:
  • 如果定義一個標識符時有直接進行賦值,那么標識符后面的類型可以省略.
  • 因為Swift有類型推導(dǎo),會自動根據(jù)后面的賦值來決定前面的標識符的數(shù)據(jù)類型
  • 可以通過option+鼠標左鍵來查看變量的數(shù)據(jù)類型
    截屏.png

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

// 正確寫法
var j = 3.33
j = 6.66

Swift中基本運算

• Swift中在進行基本運算時必須保證類型一致,否則會出錯
  相同類型之間才可以進行運算
  因為Swift中沒有隱式轉(zhuǎn)換
• 數(shù)據(jù)類型的轉(zhuǎn)化
  Int類型轉(zhuǎn)成Double類型:Double(標識符)
  Double類型轉(zhuǎn)成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/switch/三目運算符等判斷語句
• 通過分支語句可以控制程序的執(zhí)行流程

二. if分支語句

• 和OC中if語句有一定的區(qū)別
  • 判斷句可以不加()
  • 在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("優(yōu)秀")
} else {
   print("完美")
}


// 演練三:
// 這個是可選類型,因為只有聲明成可選類型后,才可以判斷是否為空
// 可選類型會在后續(xù)講解,可先了解即可
let view : UIView? = UIView()

// 判斷如果view有值,則設(shè)置背景
// 錯誤寫法
//if view {
//    view.backgroundColor = UIColor.redColor()
//}

if view != nil {
   view!.backgroundColor = UIColor.redColor()
}

三. 三目運算符

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

var a = 10
var b = 50

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

四.guard的使用

• guard是Swift2.0新增的語法
• guard必須用在函數(shù)內(nèi)部
• 它與if語句非常類似，它設(shè)計的目的是提高程序的可讀性
• guard語句必須帶有else語句巍实，它的語法如下：
  • 當條件表達式為true時候跳過else語句中的內(nèi)容腾啥，執(zhí)行語句組內(nèi)容东涡，并且{}中必須跟上 return、break倘待、continue和throw
  • 條件表達式為false時候執(zhí)行else語句中的內(nèi)容疮跑，跳轉(zhuǎn)語句一般是return、break凸舵、continue和throw

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

// 1.guard必須用在函數(shù)

let myAge = 20

func online(age:Int)
{
    guard age >= 18 else {
        print("未成年不能上網(wǎng)")
        return
    }
    let forgetStr = "沒帶身分證"
    
    guard forgetStr == "沒帶身分證" else {
        print("回家拿身份證")
        return
    }
    print("可以上網(wǎng)")
}

四.switch分支

switch的介紹

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

switch的簡單使用

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

//基本用法
let sex = 0

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

• 簡單使用補充:
  • 一個case判斷中,可以判斷多個值
  • 多個值以,隔開

// 2.基本用法的補充:
// 1>如果希望一個case中出現(xiàn)case穿透,那么可以在case語句結(jié)束后跟上fallthrough
// 2>case后面可以跟多個條件,多個條件以,分割

switch sex {
    case 1,0:
    print("正常人")
    fallthrough
    case 0:
        print("男")
    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
}

print(result)

switch支持區(qū)間判斷

• 什么是區(qū)間?
  通常我們指的是數(shù)字區(qū)間:0_10,100200
• swift中的區(qū)間常見有兩種
  開區(qū)間:0..<10 表示:0~9,不包括10
  閉區(qū)間:0...10 表示:0~10

let score = 92;

switch score {
case 0..<60:
    print("不及格")
case 60..<80:
    print("及格")
case 80..<90:
    print("良好")
case 90...100:
    print("優(yōu)秀")

default:
    print("不合理的分數(shù)")
}

循環(huán)的介紹

• 在開發(fā)中經(jīng)常會需要循環(huán)
• 常見的循環(huán)有:for/while/do while.
• 這里我們只介紹for/while,因為for/while最常見

for循環(huán)的寫法

• 最常規(guī)寫法 (C-style for statement has been removed in Swift 3)swift3 之后不可以使用

// 傳統(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")
}

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中字符串類型時NSString,在Swift中字符串類型是String
  OC中字符串@"",Swift中字符串""
• 使用 String 的原因
  String 是一個結(jié)構(gòu)體，性能更高
  NSString 是一個 OC 對象啊奄，性能略差
  String 支持直接遍歷
  Swift 提供了 String 和 NSString 之間的無縫轉(zhuǎn)換

字符串的使用

遍歷字符串

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

for c in str {
    print(c)
}

字符串拼接

• 兩個字符串的拼接

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)"

• 字符串的格式化
  比如時間: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來使用
  在標識符后加: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數(shù)組類型是Array掀潮，是一個泛型集合

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

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

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

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

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

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

// 定義時直接初始化
var array = ["why", "lnj", "lmj"]

// 先定義,后初始化
var array : Array<String>
array = ["why", "lnj", "lmj"]

對數(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 = ["why", "lmj","lnj"]
var array1 = ["yz", "wsz"]
var array2 = array + array1;

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

字典

字典的介紹

• 字典允許按照某個鍵來訪問元素
• 字典是由兩部分集合構(gòu)成的整以，一個是鍵（key）集合胧辽，一個是值（value）集合
• 鍵集合是不能有重復(fù)元素的，而值集合是可以重復(fù)的公黑，鍵和值是成對出現(xiàn)的
• Swift中的字典
  Swift字典類型是Dictionary邑商，也是一個泛型集合

字典的初始化

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

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

// 定義一個不可變字典
let dict2 = ["name" : "why", "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 = ["name2":"xiaozhang" as AnyObject, "Tel":1900 as AnyObject]

字典的基本操作

// 添加數(shù)據(jù)
dictM["name"] = "why" as AnyObject
dictM["age"] = 18 as AnyObject
dictM["height"] = 190 as AnyObject
dict

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

// 修改字典
dict["name"] = "lmj"
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" : "yz", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
    dict2[key] = value
}

var myDict = ["name":"zhao", "age":89, "Tel":dictM] as [String : Any]

元祖

元祖的介紹

• 元組是Swift中特有的,OC中并沒有相關(guān)類型
• 它是什么呢?
  它是一種數(shù)據(jù)結(jié)構(gòu)凡蚜，在數(shù)學(xué)中應(yīng)用廣泛
  類似于數(shù)組或者字典
  可以用于定義一組數(shù)據(jù)
  組成元組類型的數(shù)據(jù)可以稱為“元素”

元祖的定義

• 元祖的常見寫法

// 使用元祖描述一個人的信息
("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的提示來使用
  隨著學(xué)習(xí)的深入,慢慢理解其中的原理和好處
• 概念:
  在OC開發(fā)中,如果一個變量暫停不使用,可以賦值為0(基本屬性類型)或者賦值為空(對象類型)
  在swift開發(fā)中,nil也是一個特殊的類型.因為和真實的類型不匹配是不能賦值的(swift是強類型語言)
  但是開發(fā)中賦值nil,在所難免.因此推出了可選類型
• 可選類型的取值:
  空值
  有值

定義可選類型

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

// 錯誤寫法
// let string : String = nil
// 正確寫法:
// 注意:name的類型是一個可選類型,但是該可選類型中可以存放字符串.
// 寫法一:定義可選類型
let name : Optional<String> = nil

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

可選類型的使用

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

// 給可選類型賦值
// 錯誤寫法:因此該可選類型中只能存放字符串
string = 123
// 正確寫法:
string = "Hello world"

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


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

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

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

// 簡單寫法:為了讓在if語句中可以方便使用string
// 可選綁定
// 1> 判斷name是否有值,如果沒有值,則不執(zhí)行{}.
// 2> 如果有值,則對可選類型進行解包,并且將解包后的值賦值給前面的常量
//if let tempName = name {
//    print(tempName)
//}
if let str = string {
    print(str)
}

真實應(yīng)用場景

• 目的:讓代碼更加嚴謹

// 通過該方法創(chuàng)建的URL,可能有值,也可能沒有值.
// 錯誤寫法:如果返回值是nil時,就不能接收了
// 如果字符串中有中文,則返回值為nil,因此該方法的返回值就是一個可選類型,而使用一個NSURL類型接收是錯誤的
let url : NSURL = NSURL(string: "www.520it.com")

// 正確寫法:使用可選類型來接收
let url : NSURL? = NSURL(string: "www.520it.com")
// 該方式利用類型推導(dǎo)
let url = NSURL(string: "www.520it.com")

// 通過url來創(chuàng)建request對象:在使用可選類型前要先進行判斷是否有值
// 該語法成為可選綁定(如果url有值就解包賦值給tempURL,并且執(zhí)行{})
if let tempUrl = url {
    let request = NSURLRequest(URL: tempUrl)
}

函數(shù)

函數(shù)的介紹

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

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

• func是關(guān)鍵字,多個參數(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ù)
• 默認情況下,從第二個參數(shù)開始,參數(shù)名稱既是內(nèi)部參數(shù)也是外部參數(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關(guān)鍵字就可以實現(xiàn)
• 對比下列兩個函數(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ù)的嵌套使用

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

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

    print("test")
    demo()
}

demo() // 錯誤
test() // 執(zhí)行函數(shù)會先打印'test',再打印'demo'

Swift中類的使用

一. 類的介紹和定義

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

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

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

二. 如何定義類的屬性

類的屬性介紹

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

存儲屬性

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

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

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

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

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

stu.chineseScore = 89.0
stu.mathScore = 98.0

計算屬性

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

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

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

類屬性

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

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

    // 類屬性
    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)聽存儲屬性和類屬性的改變.(對于計算屬性煮剧，我們不需要定義屬性觀察者斥滤，因為我們可以在計算屬性的setter中直接觀察并響應(yīng)這種值的變化)
• 我們通過設(shè)置以下觀察方法來定義觀察者
  willSet：在屬性值被存儲之前設(shè)置。此時新屬性值作為一個常量參數(shù)被傳入勉盅。該參數(shù)名默認為newValue佑颇，我們可以自己定義該參數(shù)名
  didSet：在新屬性值被存儲后立即調(diào)用。與willSet相同草娜，此時傳入的是屬性的舊值挑胸，默認參數(shù)名為oldValue
  willSet與didSet只有在屬性第一次被設(shè)置時才會調(diào)用，在初始化時宰闰，不會去調(diào)用這些監(jiān)聽方法
• 監(jiān)聽的方式如下:
  監(jiān)聽age和name的變化

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

//p.name = "yz"

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

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

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

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

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

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

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

初始化時給屬性賦值

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

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

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

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

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

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

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

    // 自定義構(gòu)造函數(shù),會覆蓋init()函數(shù)
    init(dict : [String : NSObject]) {

        let tempName = dict["name"]
         //tempName是一個AnyObject?,轉(zhuǎn)成String?
        // as? 最終轉(zhuǎn)成的類型是一個可選類型
        // as! 最終轉(zhuǎn)成的類型是一個確定的類型
        name = dict["name"] as? String
        age = dict["age"] as! Int
    }
}

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

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

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

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

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

    // 自定義構(gòu)造函數(shù),會覆蓋init()函數(shù)
    init(dict : [String : NSObject]) {
        // 必須先初始化對象
        super.init()
        // 調(diào)用對象的KVC方法字典轉(zhuǎn)模型
        setValuesForKeysWithDictionary(dict)
    }
}

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

閉包

閉包的介紹

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

• 注意:閉包和block一樣,第一次使用時可能不習(xí)慣它的語法,可以先按照使用簡單的閉包,隨著學(xué)習(xí)的深入,慢慢掌握其靈活的運用方法.

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

• 進行網(wǎng)絡(luò)請求,請求到數(shù)據(jù)后利用block進行回調(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 loadData(callBack:@escaping (_ name:String)->(Void))
    {
       DispatchQueue.global(qos: .default).async
        {
            //處理耗時操作的代碼塊...
            print(Thread.current)
            
            //操作完成议蟆，調(diào)用主線程來刷新界面
            DispatchQueue.main.async
            {
                callBack("jsonData");
            }
        }
        
    }}
}

• 進行網(wǎng)絡(luò)請求,請求到數(shù)據(jù)后利用閉包進行回調(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ù)的最后一個參數(shù),則可以將閉包寫在()后面
  如果函數(shù)只有一個參數(shù),并且這個參數(shù)是閉包,那么()可以不寫

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

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

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

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

懶加載的使用

• 格式

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

懶加載的使用

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