swift基礎語法

swift.jpg

還未更新完畢，后面會持續增加內容

常量&變量

什么是常量和變量
  • 在Swift中規定:在定義一個標識符時必須明確說明該標識符是一個常量還是變量
  • 使用let來定義常量,定義之后不可以修改
  • 使用var來定義變量,定義之后可以修改
import UIKit
let a : Int = 10
// a = 20 是錯誤寫法,當一個字段定義為常量時是不可以修改的


var b : Int = 20
b = 30  //是正確的寫法-- 因為b定義為變量,因此是可以修改的
常量和變量的使用注意:
  • 注意:
    1-> 在真實使用過程中,建議先定義常量,如果需要修改再修改為變量(更加安全)
    2-> 是指向的對象不可以再進行修改.但是可以通過指針獲得對象后,修改對象內部的屬性
    var 
var view : UIView = UIView()
//對應oc的寫法為:UIView *view = [[UIView alloc] init];
//var創建的對象,可以再進行修改
view = UIView()

let

// 注意:聲明為常量不可以修改的意思是指針不可以再指向其他對象.但是可以通過指針拿到對象,修改其中的屬性
let view : UIView = UIView()
//錯誤寫法 view = UIView()
//但是可以對其屬性進行修改
view.backgroundColor = UIColor.redColor()

數據類型

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浮點型(默認)
//var
var num1 : Int = 10
var num2 : Double = 10.11

//let 
let num3 : Int = 10
let num4 : Float = 10.11
Swift是強類型的語言
  • Swift中任何一個標識符都有明確的類型
  • 注意:
    1> 如果定義一個標識符時有直接進行賦值,那么標識符后面的類型可以省略.因為Swift有類型推導,會自動根據后面的賦值來決定前面的標識符的數據類型。
    2> 可以通過 option + 鼠標左鍵 來查看變量的數據類型
//若在定義變量時沒有指定明確的類型,但是因為給i賦值一個20.20為整型.因此i為整型
var i = 20
// i = 30.5 錯誤寫法:因為i已經自動推導為Int類型，賦值浮點型會報錯

//自動推導為Double類型
var j = 3.33
j = 6.66 //正確寫法
Swift中基本運算
  • Swift中在進行基本運算時必須保證類型一致,否則會出錯
  • 相同類型之間才可以進行運算
  • 因為Swift中沒有隱式轉換
  • 數據類型的轉化
  • Int類型轉成Double類型:Double(標識符)
  • Double類型轉成Int類型:Int(標識符)
let a = 10
let b = 3.14
//let c = a + b 錯誤寫法:因為 a是Int類型 b是Double類型，不同類型不能進行運算

//不同類型不能進行運算，但是可以進行類型轉換之后再進行運算
let c = Double(a) + b
let d = a + Int(b)

邏輯分支

一. 分支的介紹

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

二. if分支語句

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

// 下面注釋掉的在Swift中是錯誤寫法，但在oc中是正確的
//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("完美")
}

三. 三目運算符

var a = 10
var b = 50
var result = a > b ? a : b

四.guard的使用

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

guard語句的語法

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

guard的使用

func scoreGrade(score : Double) {
    guard score >= 60 else {
        //只要score小于 60就會進到else代碼塊中
        print("不及格")
        return
    }
    
    //只要score大于或者等于60,不會進入else代碼塊中，并且執行下面的代碼
    print("成績及格")
}

scoreGrade(88)

四.switch分支

基本用法和OC用法一致
不同之處:

  • switch后可以不跟()
  • case后可以不跟break(默認會有break)
  • 一個case判斷中,可以判斷多個值.多個值以,隔開
  • 如果希望case穿透,則可以使用關鍵字fallthrough
  • Switch支持多種數據類型
  • 浮點型的switch判斷
  • 支持字符串類型
  • witch支持區間判斷
    • 什么是區間?
      通常我們指的是數字區間:010,100200
    • swift中的區間常見有兩種
      開區間:0..<10 表示:0~9,不包括10
      閉區間:0...10 表示:0~10

switch的使用1：基本的使用

let sex = 0

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

switch的使用2：一個case判斷中,判斷多個值

//一個case判斷中,可以判斷多個值.多個值以,隔開
let sex = 0
switch sex {
case 0, 1:
    print("正常人")
default:
    print("其他")
}

switch的使用3：case穿透,fallthrough

let sex = 0
switch sex {
case 0:
    print("穿透測試") //這句會被打印
    fallthrough
case 1:
    print("正常人")   //這句會被打印
default:
    print("其他")     //這句不會被打印
}

switch的使用4：浮點型的switch判斷

let f = 3.14
switch f {
case 3.14:
    print("π")
default:
    print("not π")
}

switch的使用5：字符串的switch判斷

let m = 15
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的使用5：switch支持區間判斷

let score = 88

switch score {
case 0..<60:
    print("不及格")
case 60..<80:
    print("幾個")
case 80..<90:
    print("良好")  //這句將被打印
case 90..<100:
    print("優秀")
default:
    print("滿分")
}

循環的使用

for循環

1、最常規寫法

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

2、區間for循環

//0到9 不含10
for i in 0..<10 {
    print(i)
}

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

3、特殊寫法：for循環中不需要用到下標i、用_代替

for _ in 0..<10 {
    print("chenfanfang")
}
while和repeat while循環 <repeat while 其實就是do while的效果>
  • while循環
    • while的判斷句必須有正確的真假,沒有非0即真
    • while后面的()可以省略
var a = 0
while a < 10 {
    //總共循環10次  0 -- 9
    print("chenfanfang")
    a++
}

repeat while循環


var b = 0
repeat {
    //循環10次  0--9
    print("chenfanfang")
    b++
} while b < 10

字符串

字符串的介紹

  • swift字符串和oc字符串的比較

    • OC和Swift中字符串的區別在OC中字符串類型時NSString,在Swift中字符串類型是String
    • OC中字符串@"",Swift中字符串""

  • swift使用 String的原因

    • String是一個結構體，性能更高,NSString是一個 OC對象，性能略差。String支持直接遍歷字符串的每一個字符
    • Swift提供了 String和 NSString之間的無縫轉換
字符串的使用

遍歷字符串

//遍歷字符串的每一個字符
var str = "chenfanfang"

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

兩個字符串的拼接

let str1 = "chen"
let str2 = "fanfang"
let str3 = str1 + str2

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

let name = "chenfanfang"
let age = 25

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

字符串的格式化:比如時間:2016-09-01

let year = 2016
let month = 9
let day = 1

let dateStr = String(format: "%d-%02d-%02d", arguments: [year, month, day])

字符串的截取

/*
 *   Swift中提供了特殊的截取方式,該方式比較麻煩
 *   簡單的方式是將String轉成NSString來使用
 *   在標識符后加:as NSString即可將String轉成NSString
 */

let myStr = "my name is chenfanfang"

//截取到的字符串是:chenfanfang
let subStr1 = (myStr as NSString).substringFromIndex(11)
//截取到的字符串是:my
let subStr2 = (myStr as NSString).substringToIndex(2)
//截取到的字符串是:chenfanfang
let subStr3 = (myStr as NSString).substringWithRange(NSRange(location: 11, length: 11))

數組

數組的介紹
  • 數組中的集合元素是有序的，可以重復出現
  • swift數組類型是Array，是一個泛型集合
數組的初始化
  • 使用let修飾的數組是不可變數組
  • 使用var修飾的數組是可變數組
// 定義一個可變數組,必須初始化才能使用
var array1 : [String] = [String]()
// 定義一個不可變數組
let array2 : [NSObject] = ["chenfanfang", 25]
  • 在聲明一個Array類型的時候可以使用下列的語句之一
var array1 : [String]

var array2 : Array<String>
  • 聲明的數組需要進行初始化才能使用，數組類型往往是在聲明的同時進行初始化的
// 定義時直接初始化
var array1 = ["chen", "fan", "fang"]

// 先定義,后初始化
var array2 : Array<String>

array2 = ["chen", "fan", "fang"]
對數組的基本操作
  • 增刪改
var array = ["chen", "fan", "fang", "so", "cool"]

//刪
array.removeAtIndex(0)              //根據下標刪除元素
var firstEle = array.removeFirst()  //刪除第一個元素:并且返回要刪除的那個元素
var lastEle = array.removeLast()    //刪除最后一個元素:并且返回要刪除的那個元素
array.removeAll()                   //刪除所有元素

//增
array.append("cool")

//改
array[0] = "chen"
數組的遍歷
var array = ["chen", "fan", "fang"]

//普通for循環遍歷方式
for var i = 0; i < array.count; i++ {
    print(array[i])
}

//for in 下標遍歷方式
for str in array {
    print(str)
}

//遍歷的時候設置遍歷區間
for str in array[0..<2] { //遍歷 0、1兩個下標對應的元素
    print(str)
}
數組的合并
// 注意:只有相同類型的數組才能合并
var array1 = ["chen", "fan"]
var array2 = ["fang"]

var array = array1 + array2

字典

字典的介紹
  • 字典允許按照某個鍵來訪問元素
  • 字典是由兩部分集合構成的，一個是鍵（key）集合，一個是值（value）集合
  • 鍵集合是不能有重復元素的，而值集合是可以重復的，鍵和值是成對出現的
  • Swift中的字典
    • Swift字典類型是Dictionary，是一個泛型集合
字典的初始化
  • Swift中的可變和不可變字典
  • 使用let修飾的數組是不可變字典
  • 使用var修飾的數組是可變字典
  • 定義可變字典、不可變字典
// 定義一個可變字典
var dic : [String : NSObject] = [String : NSObject]()

// 定義一個不可變字典
let dicM = ["name" : "chenfanfang", "age" : 25]
  • 在聲明一個Dictionary類型的時候可以使用下面的語句之一
//key可以不是String類型
var dict1: Dictionary<Int, String>

var dict2: [Int: String]
  • 聲明的字典需要進行初始化才能使用
// 定時字典的同時,進行初始化
var dict = ["name" : "chenfanfang", "age" : 25]

// swift中任意對象,通常不使用NSObject,使用AnyObject
var dict2 : Dictionary<String, AnyObject>
dict2 = ["name" : "chenfanfang", "age" : 25]
字典的增、刪、改、查

var dict : [String : AnyObject] = [String : AnyObject]()

// 添加數據
dict["name"] = "chenfanfang"
dict["age"] = 25
dict["weight"] = 110

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

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

// 查詢字典
dict["name"]
字典的遍歷

var dict = ["name" : "chenfanfang" , "age" : 25]

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

// 遍歷所有的鍵值對
for (key, value) in dict {
    print(key)
    print(value)
}
字典的合并
//字典的合并不能像數組那樣 相加合并

var dic1 = ["name" : "chenfanfang", "age" : 25]
var dic2 = ["love" : "iOS"]

for (key, value) in dict1 {
    dict2[key] = value
}

元祖的介紹

  • 元組是Swift中特有的,OC中并沒有相關類型
  • 它是一種數據結構，在數學中應用廣泛
  • 類似于數組或者字典
  • 可以用于定義一組數據
  • 組成元組類型的數據可以稱為“元素”
元祖的基本使用

元祖用法1

var userInfo = ("chenfanfang", 25)
print("name is \(userInfo.0) age is \(userInfo.1)")

//輸出結果:name is chenfanfang age is 25

元祖用法2

var userInfo2 = (name : "chenfanfang", age : 25)
print("name is \(userInfo2.name) age is \(userInfo2.age)")
//輸出結果:name is chenfanfang age is 25

元祖用法3

let (name, age) = ("chenfanfang", 25)
print("name is \(name) age is \(age)")
//輸出結果:name is chenfanfang age is 25
對元祖的總結
  • 個人覺得元祖就是集合了 “數組”、“字典”、“對象”等特性于一身。

可選類型

  • 在swift開發中,nil也是一個特殊的類型.因為和真實的類型不匹配是不能賦值的(swift是強類型語言)。但是開發中賦值nil,在所難免.因此推出了可選類型
  • 可選類型的取值: 1、空值 2、有值
定義可選類型
  • 最基本的寫法
  • 語法糖(常用)
// 錯誤寫法
// let string : String = nil

// 正確寫法:

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

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

1、給可選類型賦值

var string : Optional<String> = nil

// 給可選類型賦值
//string = 123 // 錯誤寫法:因此該可選類型中只能存放字符串
// 正確寫法:
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 let str = string {
    print(str)
}
可選類型的真實應用場景
  • 目的:讓代碼更加嚴謹

創建NSURL的錯誤寫法

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

創建NSURL的正確方式1-----通過可選類型

let url : NSURL? = NSURL(string: "www.baidu.com")

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

創建NSURL的正確方式2-----用類型推導

let url = NSURL(string: "www.baidu.com")

函數

函數的寫法
func 函數名(參數列表) -> 返回值類型 {
    代碼塊
    return 返回值
}
  • func是關鍵字,多個參數列表之間可以用逗號（,）分隔，也可以沒有參數
  • 使用箭頭“->”指向返回值類型
  • 如果函數沒有返回值，返回值為Void.并且“-> 返回值類型”部分可以省略
常見的函數類型
  • 1、沒有參數,沒用返回值
func func1() -> Void {
    print("沒有參數,沒用返回值")
}
// 調用函數
func1()

// 如果沒用返回值,Void可以寫成()
func func2() -> () {
    print("沒有參數,沒用返回值")
}
// 如果沒有返回值,后面的內容可以都不寫
func func3() {
    print("沒有參數,沒用返回值")
}
  • 2、有參數，沒有返回值
func func1(name : String) {
    print("my name is \(name)")
}

func1(name:"chenfanfang")
  • 3、沒有參數，有返回值
func func1() -> String {
    return "chenfanfang"
}

var name = func1()
  • 4、有參數，有返回值
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}

var result = sum(num1:10, num2: 20)

print("10 + 20 = \(result)")
函數的使用注意
  • 注意一: 外部參數和內部參數在函數內部可以看到的參數,就是內部參數
  • 在函數外面可以看到的參數,就是外部參數
  • 默認情況下,從第二個參數開始,參數名稱既是內部參數也是外部參數。 已過期
  • 如果第一個參數也想要有外部參數,可以設置標簽:在變量名前加標簽即可。已過期
  • 如果不想要外部參數,可以在參數名稱前加_

// 如果不想要外部參數,可以在參數名稱前加_
func ride(_ num1: Int, _ num2 :Int) -> Int {
    return num1 * num2
}

var result2 = ride(20, 20)
  • 注意二:
  • 默認參數某些情況,如果沒有傳入具體的參數,可以使用默認參數

func makeCoffee(coffeeName : String = "拿鐵") {
    //如果
    print("制作一杯\(coffeeName)咖啡")
}

makeCoffee()       //打印結果:制作一杯拿鐵咖啡
makeCoffee(coffeeName: "貓屎") //打印結果:制作一杯貓屎咖啡
  • 注意三: 可變參數swift中函數的參數個數可以變化，它可以接受不確定數量的輸入類型參數
  • 它們必須具有相同的類型
  • 我們可以通過在參數類型名后面加入（...）的方式來指示這是可變參數

func func1(name : NSString, moneys : Double..., age : Int) {
    
    var totalMoney : Double = 0.0
    
    for money in moneys {
        totalMoney += money
    }
    
    print("name is \(name) age is \(age) have money \(totalMoney)元")
}

func1(name: "chenfanfang", moneys: 10.0, 20.0, 50.0, age: 25)

//打印輸出結果:name is chenfanfang age is 25 have money 80.0元
  • 注意四:
  • 引用類型(指針的傳遞)默認情況下,函數的參數是值傳遞.如果想改變外面的變量,則需要傳遞變量的地址
  • 必須是變量,因為需要在內部改變其值
  • Swift提供的inout關鍵字就可以實現

參數：值傳遞


func swap(a : Int, 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)")

//打印結果:
a:20, b:10
a:10, b:20

參數：指針傳遞


func swap1(a :inout Int, inout b :inout Int) {
    let temp = 1
    a = b
    b = temp
    
    print("a=\(a), b=\(b)")
}

var a = 10
var b = 20

swap1(a: &a, b: &b)

print("a=\(a), b=\(b)")

//打印輸出結果:
a=20, b=1
a=20, b=1
  • 函數的嵌套使用
  • swift中函數可以嵌套使用
  • 即函數中包含函數,但是不推薦該寫法

func func1() {
    func func2 () {
        print("func2")
    }
    
    func2()
    
    print("func1")
}

func1()

//打印輸出結果:
func2
func1

類

  • 類的定義
class 類名 : SuperClass {
    // 定義屬性和方法
}
//定義的類,可以沒有父類.那么該類是rootClass
//通常情況下,定義類時.繼承自NSObject(非OC的NSObject)
  • 類的屬性

類的屬性種類：
1、存儲屬性:存儲實例的常量和變量
2、計算屬性:通過某種方式計算出來的屬性
3、類屬性:與整個類自身相關的屬性

存儲屬性

  • 存儲屬性是最簡單的屬性，它作為類實例的一部分，用于存儲常量和變量
  • 可以給存儲屬性提供一個默認值，也可以在初始化方法中對其進行初始化
  • 下面是存儲屬性的寫法
  • 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 = 25
stu.name = "chenfanfang"

stu.chineseScore = 98.0
stu.mathScore = 99.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) * 0.5
        }
        
        // 沒有意義,因為之后獲取值時依然是計算得到的
        // newValue是系統分配的變量名,內部存儲著新值
        set {
            self.averageScore = newValue
        }
    }
    
}

var stu : Student = Student()
stu.chineseScore = 90.0
stu.mathScore = 80.0

print(stu.averageScore) //打印輸出85.0

類屬性

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

Student.courseCount = 8

//打印出結果:課程數目=8
print("課程數目=\(Student.courseCount)")

監聽屬性的改變

  • 在OC中我們可以重寫set方法來監聽屬性的改變
  • Swift中可以通過屬性觀察者來監聽和響應屬性值的變化
  • 通常是監聽存儲屬性和類屬性的改變.(對于計算屬性，我們不需要定義屬性觀察者，因為我們可以在計算屬性的setter中直接觀察并響應這種值的變化)
  • 我們通過設置以下觀察方法來定義觀察者
  • willSet：在屬性值被存儲之前設置。此時新屬性值作為一個常量參 數被傳入。該參數名默認為newValue，我們可以自己定義該參數名
  • didSet：在新屬性值被存儲后立即調用。與willSet相同，此時傳入的是屬性的舊值，默認參數名為oldValue
  • willSet與didSet只有在屬性第一次被設置時才會調用，在初始化時，不會去調用這些監聽方法
  • 監聽的方式如下:
  • 監聽age和name的變化
class Student : NSObject {
    
    //監聽屬性的改變
    
    //用系統自帶的新舊值名稱newValue、oldValue
    var name : String? {
        
        willSet { // 屬性即將改變,還未改變時會調用的方法
            
            // 在該方法中有一個默認的系統屬性newValue,用于存儲新值
            
            print("name -- willSet: oldValue=\(name) newValue=\(newValue)")
            
        }
        
        didSet { // 屬性值已經改變了,會調用的方法
            // 在該方法中有一個默認的系統屬性oldValue,用于存儲舊值
            print("name -- didSet: oldValue=\(oldValue) newValue=\(name)")
        }
    }
    
    
    
    //自定義新舊值名稱
    var age : Int? {
        
        willSet(newAge) {
            // 在該方法中有一個默認的系統屬性newValue,用于存儲新值
            
            print("age -- willSet: oldValue=\(age) newValue=\(newAge)")

        }
        
        didSet(oldAge) {
            // 在該方法中有一個默認的系統屬性newValue,用于存儲新值
            
            print("age -- willSet: oldValue=\(oldAge) newValue=\(age)")

        }
    }
    
  
}

var stu : Student = Student()

//========================
//          name
//========================

stu.name = "cff"
//輸出結果
//name -- willSet: oldValue=nil newValue=Optional("cff")
//name -- didSet: oldValue=nil newValue=Optional("cff")

stu.name = "chenfanfang"
//輸出結果
//name -- willSet: oldValue=Optional("cff") newValue=Optional("chenfanfang")
//name -- didSet: oldValue=Optional("cff") newValue=Optional("chenfanfang")

//========================
//          age
//========================

stu.age = 10
//輸出結果
//age -- willSet: oldValue=nil newValue=Optional(10)
//age -- willSet: oldValue=nil newValue=Optional(10)

stu.age = 25
//輸出結果
//age -- willSet: oldValue=Optional(10) newValue=Optional(25)
//age -- willSet: oldValue=Optional(10) newValue=Optional(25)

類的構造函數

構造函數的介紹

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

構造函數的基本使用(重寫構造函數)

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

class Student : NSObject {
    
    var name : String
    var age : Int
    
    override init() {
        //在構造函數中，若沒有調用super.init(),那么系統會默認會自動調用super.init()
        name = "chenfanfang"
        age = 25
    }
}


var stu = Student()

print(stu.age)  //輸出:25
print(stu.name) //輸出:chenfanfang

初始化時給屬性賦值(自定義構造函數)

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

class Student : NSObject {
    
    var name : String
    var age : Int
    
    init(name : String, age : Int) {
        //在構造函數中，若沒有調用super.init(),那么系統會默認會自動調用super.init()
        self.name = name
        self.age = age
        
    }
}


var stu = Student(name: "chenfanfang", age: 25)

print(stu.age)  //輸出:25
print(stu.name) //輸出:chenfanfang

初始化時給屬性賦值(自定義構造函數，傳入字典)

注意:
去字典中取出的是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" : "why", "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" : "why", "age" : 18]
let p = Person(dict: dict)
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • Swift 簡介 查看Swift當前版本 簡介 Swift 語言由蘋果公司在 2014 年推出，用來撰寫 OS X...
    mian小爬閱讀 365評論 0贊 1
  • Swift 介紹 簡介 Swift 語言由蘋果公司在 2014 年推出，用來撰寫 OS X 和 iOS 應用程序 ...
    大L君閱讀 3,304評論 3贊 25
  • 簡介 特點（1）優于OC，快速，安全（2）取消了預編譯指令包括宏定義（OC用的太多了）（3）取消了OC指針和不安全...
    洛洛愛吃肉閱讀 980評論 0贊 3
  • 寂靜 你在看岸上的美圖還是水中的世界 是否真實有時讓人很累虛幻有時卻感覺很美昨夜有人把生活拉黑我對他說即使所有的風...
    方正的石頭閱讀 358評論 4贊 6
  • 下大雨，從昨天白天下到現在，一直沒有停過。半夜里睡地板上也是別有一番滋味，伴著雨聲，呼吸窗外新鮮的空氣，什么都...
    Miss文小姐閱讀 303評論 1贊 0