一 可選類型知識點補充

1 例一 : 強轉並且制定類型

let str = "23"  //打印結果: "23"
let age : Int? = Int(str) //打印結果 :23

—-> 1.1 問題 : 該例子轉化的結果為什麼需要用可選類型來接收?

—-> 1.2 解答 : 因為很有可能是轉化不成功的,如果此時不用可選類型來接收的話,萬一轉化失敗,那麼該值就為空(nil),如果不選擇可選類型來接收,程序會崩潰.

2 例二 : 獲取某個plist文件的路徑

let path : String? = NSBundle.mainBundle().pathForResource("xiaofeng.plist", ofType: nil) //打印的結果為nil,因為寫程序的時候並沒有新建一個名字為"xiaofeng"的plist文件

if let path = path {
    NSArray(contentsOfFile: path)
}

—-> 2.1 這裡同樣需要用可選類型來接收,原因是很有可能找不到名字為”xiaofeng”的plist文件,如果此時不用可選類型來接收,值為nil,程序會崩潰.

—-> 2.2 在此句後面寫一個判斷語句更加安全的判斷是否可以取成功.判斷的好處如下:

—> 2.2.1 判斷path是否有值,如果沒有值的話,就不執行{}中的內容

—> 2.2.2 如果path有值,那麼系統就會對path進行解包,並且將解包的結果賦值

3 例三 : 獲取一個NSURL

let url : NSURL? = NSURL(string: "www.baidu.com") //打印結果:www.baidu.com
if let url = url {
    NSURLRequest(URL : url) // { URL: www.baidu.com }
}

—-> 3.1 如果不加判斷或者將獲取到的值不用可選類型來接收的話,那麼當url是下面這種類型,就獲取不到.不用選類型來接收是會報錯的.

//url中出現了中文,並且沒有用可選類型來接收值,系統會報錯
//系統包的錯誤: cannot convert value of type 'NSURL?' to specified type 'String'
let url : String = NSURL(string: "www.baidu.com/百度")

—-> 3.2 如果用if做出了判斷,此時能更加安全的對url進行操作,判斷url是否獲取成功,成功的話就將url解包.

4 例三 : 在保證一個可選類型一定有值的前提下,可以直接強制解包

—-> 4.1 如果此時的123.plist文件存在的話,就可以強制解包(通過按住option點擊path1可以看出,path1的類型是可選類型)

let path1 = NSBundle.mainBundle().pathForResource("123.plist", ofType: nil)

二 is; as?; as!的用法

1 is : 用來判斷某種類型是不是另外一種類型(用法比較簡單)

let array = [12,"xiaofeng",1.89]
let arrayM = [NSObject]()//定義數組,內部的元素是NSObject類型
//判斷取出的第一個元素是不是整型
if let firstObject = array.first {
    if firstObject is Int {
        print("是Int類型")    //打印結果:"是Int類型\n"
    }else{
        print("不是Int類型")
    }
}

2 as? : 轉成的最終類型是一個可選類型(需要作出判斷)

let dict = ["name" : "xiaofeng", "age" : 20, "height" : 1.88]
let value = dict["name"] //通過按住option點擊value,可以看出類型為可選類型
//將NSObject轉成String類型
if let value = value {
    //此處value as? String也有可能轉失敗
    let valueStr : String? = value as? String
    //判斷是否能轉成功
    if let valueStr = valueStr {
        let info = "my name is " + valueStr //最終結果:"my name is xiaofeng"
    }
}

—-> 2.1 簡便寫法判斷NSObject? 轉 String

if let valueStr = value as? String {
    let info = "my name is " + valueStr //打印結果 :"my name is xiaofeng"
}

3 as! : 轉成的最終類型就是具體的類型(NSObject? 轉成 String)

—-> 3.1 此方法的後果: 如果用這種方法轉化不成功,那麼程序會直接崩潰

let info = "my name is " + (value as! String) //打印結果 :"my name is xiaofeng"

三 swift中的函數

1 oc中的方法

有參數有返回值
- (CGFloat)sum:(CGFloat)num1 num2:(CGFloat)num2;
有參數沒有返回值
- (void)sum1:(CGFloat)num1 num2:(CGFloat)num2;
沒有參數有返回值
- (CGFloat)sum2;
沒有參數沒有返回值
- (void)sum3;

2 swift中的函數相當於oc中的方法(格式如下)

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

—-> 2.1 func是關鍵字,多個參數列表之間可以用逗號（,）分隔，也可以沒有參數

—-> 2.2 使用箭頭“->”指向返回值類型

—-> 2.3 如果函數沒有返回值，返回值為Void.並且“-> 返回值類型”部分可以省略

3 常見的函數類型

—-> 3.1 有參數有返回值

func sum (num1 : Int , num2 : Int) ->Int {
    return num1 + num2
}
let result = sum(10, num2: 10)
print("計算的結果是:\(result)")  //打印結果 : "計算的結果是:20\n"

—-> 3.2 有參數沒有返回值

func minus (num1 : Double , num2 : Double) {
    print(num1 - num2)   //打印出來的結果 : "2.0\n"
}
minus(22.1, num2: 20.1)

—-> 3.3 沒有參數有返回值

func multiply() ->Int {
    return 10   //返回結果 : 10
}
multiply()

—-> 3.4 沒有參數沒有返回值

func divide() {
}
divide()

—-> 3.5 有參數有多個返回值(元組)

—-3.5.1 計算一個數組中奇數和偶數的個數?

* 普通寫法:

let array = [11,22,44,33,66,88]
var oddCount = 0 //奇數
var evenCount = 0 //偶數
for num in array {
    if num % 2 == 0 {
        evenCount++  //打印結果 : 4
    } else {
        oddCount++  //打印結果 : 2
    }
}

* 利用元組特性作為多個返回值

let nums = [11,22,33,44,55,7,77,88]

func getCount (nums : [Int]) ->(Int,Int) {
    var evenCount = 0 //偶數
    var oddCount = 0 //奇數
    for num in nums {
        if num % 2 == 0 {
            evenCount++    //打印結果 : 3
        }else {
            oddCount++    //打印結果 : 5
        }
    }
    return (evenCount,oddCount)
}
let count = getCount(nums)
print("偶數的個數是:\(count.0),奇數的個數是:\(count.1)")

4 內部參數和外部參數

—-> 4.1 含義: 內部參數: 在函數內部可以看到的參數,就是內部參數;外部參數: 在函數外面可以看到的參數,就是外部參數

func sum (num1 : Int , num2 : Int , num3 : Int) ->Int {
    print(num1)
    print(num2)
    print(num3)
    return num1 + num2 + num3   //返回結果 : 30
}
//調用
sum(10, num2: 10, num3: 10)

—-> 4.2 為什麼上面代碼在調用的時候,num1並沒有顯示出來,而是從num2開始顯示的?

—-> 4.3 解答 : 默認情況下,從第二個參數開始,參數名稱既是內部參數也是外部參數

—-> 4.4 如何讓第一個參數也是外部參數?

—-> 4.5 解答 : 可以在第一個標識符前加上和該標識符同名的標識符

func multiply (num1 num1 : Int , num2 : Int , num3 : Int) ->Int {
    return num1 * num2 * num3  //返回結果 : 1000
}
multiply(num1: 10, num2: 10, num3: 10)

—-> 4.6 如何讓外部參數不顯示?

—-> 4.7 可以在參數名稱前加下劃線(_)

func subtraction (num1 : Int , _ num2 : Int , _ num3 : Int) ->Int {
    return num1 - num2 - num3   //返回結果 : 50
}
subtraction(100, 20, 30)

5 默認參數

—-> 5.1 含義 : 某些情況,如果沒有傳入具體的參數,可以使用默認參數(“藍山”)

—-> 5.2 需求 : 剛進入公司作為新員工,老員工需要你幫他們泡咖啡,他們說了各自的咖啡需求,但是有一些人沒有說,只說了隨便,此時要你設計一個函數求出咖啡的種類?

func makeCoffee(coffeeName : String = "藍山") ->String {
    return "制作了一杯:\(coffeeName)咖啡"
}
makeCoffee("拿鐵")  //通過傳入咖啡的名稱,返回制作好的咖啡
makeCoffee()       //此時的調用函數,返回的結果是默認設置的"藍山"咖啡

6 可變參數

—-> 6.1 含義與條件

—–> 6.1.1 swift中函數的參數個數可以變化，它可以接受不確定數量的輸入類型參數

—–> 6.1.2 它們必須具有相同的類型

—–> 6.1.3 我們可以通過在參數類型名後面加入（…）的方式來指示這是可變參數

—-> 6.2 需求 : 第一天 老板要你通過函數計算兩個數的相加;第二天 老板要你通過函數計算三個數的相加; 第三天 老板要你通過函數計算四個數的相加

//此時需要些三個方法來計算
func sum(num1 : Int , num2 : Int) ->Int {
    return num1 + num2
}
func sum(num1 : Int , num2 : Int , num3 : Int) ->Int {
    return num1 + num2 + num3
}
func sum(num1 : Int , num2 : Int , num3 : Int , num4 : Int) ->Int {
    return num1 + num2 + num3 + num4
}
sum(10, num2: 20, num3: 30, num4: 40)

—-> 6.3 使用可變參數進行改進

//計算參數為數組中的各個元素的和(方法一)
func arrayCount(nums : [Int]) ->Int {
    var result = 0
    for num in nums {
        result += num
    }
    return result
}
arrayCount([10,20,30,40])  //傳入一個數組   打印結果是 : 100

//計算參數為數組中的各個元素的和(方法二)
func sunNums(nums : Int...) ->Int {
    var result = 0
    for num in nums {
        result += num
    }
    return result
}
sunNums(10,20,30,40)

7 引用類型(指針的傳遞)

—-> 7.1 默認情況下,函數的參數是值傳遞.如果想改變外面的變量,則需要傳遞變量的地址

—-> 7.2 必須是變量,因為需要在內部改變其值

—-> 7.3 Swift提供的inout關鍵字就可以實現

—-> 7.4 需求 : 用函數交換兩個數的值

—–> 7.4.1 錯誤寫法 :

var m = 20
var n = 30
func exchangeNum(var num1 : Int , var num2 : Int) {
    let tempNum = num1
    num1 = num2
    num2 = tempNum
}
exchangeNum(m, num2: n)
print("m :\(m), n: \(n)")    //打印出結果 : "m :20, n: 30\n"

—–> 7.4.2 正確寫法 一: 運用指針進行交換(swift提供的關鍵字: inout)

var a = 20
var b = 30
func exchangeNum(inout num1 : Int , inout num2 : Int) {
    let tempNum = num1
    num1 = num2
    num2 = tempNum
}
exchangeNum(&a, num2: &b)
print("a : \(a) , b : \(b)")     //打印結果 : "a : 30 , b : 20\n"

—–> 7.4.3 特別寫法 :

var c = 20
var d = 30
func exchangeNum( num1 : Int , num2 : Int) -> (Int , Int) {
    return (num2 ,num1)
}
let num = exchangeNum(c, num2: d)
c = num.0     //打印結果 : 30
d = num.1     //打印結果 : 20

8 函數的嵌套使用

—-> 8.1 在swift中函數是可以嵌套使用的(不推薦)

func test() {
    func demo() {
        print("demo")
    }
    demo()    //先打印:demo
    print("test")  //再打印:test
//    demo()    //如果在此處調用   先打印:test  再打印:demo
}
test()

9 函數的類型

—-> 9.1 定義兩個函數

func add(a : Int , b : Int) ->Int {
    return a + b
}
func mul(a : Int , b : Int) ->Int {
    return a * b
}

—-> 9.2 寫出函數的類型 (函數相當於一個值)

var a = add    //打印出函數的類型 : (Int, Int) -> Int

var a : (Int, Int) -> Int = add
a(20,30)    //打印結果 : 50
a = mul     //打印結果 : (Int, Int) -> Int
a(30,60)    //打印結果 : 1800

—-> 9.3 函數作為方法的參數

—–> 9.3.1 定義一個函數

var m : Int = 20
func test(num : Int) ->Int {
    return num
}
test(m)   //打印結果 : 20
test(30)  //打印結果 : 30

—–> 9.3.2 用第一個函數作為第二個函數的參數

func demo(funcName : (Int) ->Int) {
    funcName(20)
}
demo(test)

—–> 9.3.3 函數作為方法的返回值

func add(a : Int , b : Int) ->Int {
    return a + b
}

func demo1() ->((Int, Int) ->Int) {//返回值的類型必須是和返回函數同種類型
    return add
}
let tempFunc = demo1()
tempFunc(20,30)

四 枚舉

1 OC中的枚舉 : 指定相關名稱為一組整型值

typedef enum {
    SexMan,  //默認為0
    SexWoMan //1
}Sex

2 swift中的枚舉 : Swift 中的枚舉更加靈活，不必給每一個枚舉成員提供一個值.也可以提供一個值是字符串，一個字符，或是一個整型值或浮點值.

3 swift枚舉的語法

enum SomeEnumeration {
// 屬性(enumeration definition goes here)
}

4 定義swift中的枚舉(並沒有規定Man,WoMan的數值)

//單個值一行
enum Sex {
    case Man
    case WoMan
}

//多個值一行
enum Direction {
    case East,West,South,North
}

5 創建枚舉具體類型

var sex = Sex.Man
sex = .WoMan

6 給枚舉類型賦具體值

enum Planet : Int {
    case Mercury = 0, venus, Earth, Mars
}

enum Sex1 : Int {
    case Man = 0
    case WoMan = 1
}

enum Sex2 : String {
    case Man = "男"
    case WoMan = "女"
}

7 通過下面的方法來取出枚舉中的屬性(rawValue:)

let sex1 = Sex1(rawValue: 0)  //打印出結果 : Man
let sex2 = Sex1(rawValue: 1)  //打印出結果 : WoMan

let sex4 = Sex2(rawValue: "男")   //打印出結果 : Man
let sex5 = Sex2(rawValue: "女")   //打印出結果 : WoMan

五 結構體

1 結構體的具體使用

—-> 1.1 需求 : 判斷兩個點之間的距離是否大於某個數字?

—-> 1.2 傳統做法

//1.定義中心點
let centerX : Double = 100
let centerY : Double = 100
//獲取比較的點
let x : Double = 60
let y : Double = 50
let x1 : Double = 200
let y1 : Double = 150
//定義方法,用來比較兩個點
func inRange(x : Double, y : Double) ->Bool {
    //獲取兩個點之間的距離
    let disX = x - centerX
    let disY = y - centerY
    //計算第三邊的距離
    //pow(disX, 2)代表了disX的2次方;sqrt代表開方根
    let distance = sqrt(pow(disX, 2) + pow(disY, 2))
    //判斷是否小於200
    return distance < 200    //打印結果 : true
}
inRange(60, y: 50)

—-> 1.3 使用結構體進行該進(優點) : 看上去比較直觀,一眼就知道代表了點

//結構體定義
struct Location {
    var x : Double
    var y : Double
}
//通過結構體創建對應的點
let center = Location(x: 100, y: 100)
//需要判斷的點
let testLocation = Location(x: 50, y: 40)
//定義函數
func inRang(location : Location) ->Bool {
    let disX = location.x - center.x
    let disY = location.y - center.y

    let distance = sqrt(pow(disX, 2) + pow(disY, 2))
    return distance < 200
}
//方法的調用
inRang(testLocation)

2 結構體擴充構造函數

—-> 2.1 swift規范 : 在實例化任何一個類或者結構體時,必須保證類/結構體所有(存儲)屬性,都必須被初始化.

—-> 2.2 如果自定義了構造函數,那麼會覆蓋系統提供的構造函數.如果希望保留原來的構造函數,那麼必須明確的將系統提供的構造函數進行重寫

struct Location {
    var x : Double = 0
    var y : Double = 0
    var z : Double = 0
    //init()是系統的構造方法
    init() {
    }
    //自定義構造方法
    init(x : Double, y : Double, z : Double) {
        self.x = x
        self.y = y
        self.z = z
    }
}

—-> 2.3 注意一 :如果沒有自定義構造方法,是可以敲出下面的方法來

Location()

—-> 2.4 注意二 : 自定義了構造方法,同時重寫了系統的構造方法是可以同時敲出下面的方法

Location()  //如果init()構造方法沒有被重寫,是無法敲出來的
//創建Location實例
let location = Location(x: 100, y: 100, z: 100)

—-> 2.5 注意三 : 系統的結構體除了可以通過make方法創建外,也可以直接結構體名稱後面跟上()來創建

let point = CGPoint(x: 100, y: 100)
let size = CGSize(width: 100, height: 100)
let rect = CGRect(origin: point, size: size)
var rect1 = CGRect().origin.x
rect1 = 100
let rect2 = CGRect(x: 0, y: 0, width: 100, height: 100)
let range = NSRange(location: 3, length: 9)

3 結構體擴充函數

—-> 3.1 給結構體擴充方法,必須在func前加上Mutating

—-> 3.2 給自定義的結構體擴充函數

struct Location {
    var x : Double
    var y : Double
    //mutating少了是會報錯的
    mutating func moveH(dis : Double) {
        x += dis
    }
    mutating func moveV(dis : Double) {
        y += dis
    }
}
var location = Location(x: 50, y: 60)
location.moveH(-100)
location.moveV(100)
print(location)   //打印出結果 : "Location(x: -50.0, y: 160.0)\n"

—-> 3.3 給系統的結構體擴充方法

extension CGPoint {
    mutating func moveH(dis : CGFloat) {
        x += dis
    }
    mutating func moveV(dis : CGFloat) {
        y += dis
    }
}
var point = CGPoint(x: 100, y: 100)
point.moveH(100)
print(point)   //打印出結果 : "(200.0, 100.0)\n"

—-> 3.4 給系統的類擴充方法(必須使用系統給的關鍵字:extension)

extension UIButton {
    func getTitle() ->String? {
        return titleLabel?.text
    }
}
let btn = UIButton()
btn.setTitle("按鈕", forState: .Normal)
print(btn.getTitle())  //打印出結果 : "Optional("按鈕")\n"

六 類

1 定義類

—-> 1.1 類的定義

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

—-> 1.2 注意 : (1)定義的類,可以沒有父類.那麼該類是rootClass (2)通常情況下,定義類時.繼承自NSObject(非OC的NSObject)

2 類的屬性

—-> 2.1 類的屬性種類

—–> 2.1.1 存儲屬性:存儲實例的常量和變量

—–> 2.1.2 計算屬性:通過某種方式計算出來的屬性

—–> 2.1.3 類屬性:與整個類自身相關的屬性

3 存儲屬性

class Person: NSObject {
    var name = ""
    var age = 0
    var mathScore = 0.0
    var chineseScroe = 0.0
}
//創建Person對象
let p = Person()
//給存儲屬性賦值
p.name = "xiaofeng"
p.age = 19
p.mathScore = 90
p.chineseScroe = 100

4 計算屬性(本質是一個方法)

1> 計算屬性並不存儲實際的值，而是提供一個getter和一個可選的setter來間接獲取和設置其它屬性

2> 計算屬性一般只提供getter方法

3> 如果只提供getter，而不提供setter，則該計算屬性為只讀屬性,並且可以省略get{}

—-> 4.1 需求:計算一個學生的兩門課程的平均成績

class Person: NSObject {
    var name = ""
    var age = 0
    var mathScore = 0.0
    var chineseScroe = 0.0
    //計算屬性(本質是一個方法)
    func getAverageScore() ->Double {
        return (mathScore + chineseScroe) * 0.5
    }
}
//創建Person對象
let p = Person()
//給存儲屬性賦值
p.name = "xiaofeng"
p.age = 19
p.mathScore = 90
p.chineseScroe = 100;
//調用方法
print(p.getAverageScore())  //打印結果 : "95.0\n"

—-> 4.2 計算屬性的完整寫法

 var averageScore : Double {
        get {
            return (mathScore + chineseScroe) * 0.5
        }
        set (newScore){
            chineseScroe = 2 * newScore - mathScore
        }
    }

—-> 4.3 計算屬性常見寫法

 var averageScore : Double {
        return (mathScore + chineseScroe) * 0.5
    }

5 類屬性

—-> 5.1 類屬性是與類相關聯的，而不是與類的實例相關聯

—-> 5.2 所有的類和實例都共有一份類屬性.因此在某一處修改之後,該類屬性就會被修改

—-> 5.3 類屬性的設置和修改,需要通過類來完成

static var courseCount = 0
//設置課程個數
Person.courseCount = 3
//取出類屬性的是
print(Person.courseCount)

6 類的構造函數

—-> 6.1 默認情況下,系統會給類提供一個最簡單的構造函數 init()

—-> 6.2 創建出來一個對象,必須保證該對象內部所有的屬性都有初始化值

—-> 6.3 如果自定義構造函數init(),會覆蓋系統默認提供的init()構造函數,如果不希望覆蓋,那麼必須明確的實現init()構造函數

class Person {
    var name : String = ""
    var age : Int = 0
    //系統的構造函數
    init() {
    }
    //添加構造函數
    init(name : String, age : Int) {
        self.name = name
        self.age = age
    }
    //用字典添加
    init(dict : [String : NSObject]) {
        if let name = dict["name"] as? String {
            self.name = name
        }

        if let age = dict["age"] as? Int {
            self.age = age
        }
    }
}

—-> 6.4 創建對象

//2.創建類對象
let p = Person()//通過普通方法創建
//通過擴充的方法創建
let p1 = Person(dict: ["name" : "xiaofeng", "age" : 19])

7 類的字典轉模型(KVC)

—-> 7.1 利用KVC字典轉模型會更加方便

—-> 7.2 注意:

—–> 7.2.1 KVC並不能保證會給所有的屬性賦值

—–> 7.2.2 因此屬性需要有默認值

class Person : NSObject{
    var name : String = ""
    var age : Int = 0
    init(dict :[String : NSObject]) {
        //必須先初始化對象
        super.init()
        setValuesForKeysWithDictionary(dict)
    }
    //如果使用KVC的時候,發現模型屬性值並不能一一對應,此時使用kvc是會報錯的,但是重寫下面這個方法可以避免系統報錯
    override func setValue(value: AnyObject?, forUndefinedKey key: String) {
    }
}
let p = Person(dict: ["name" : "xiaofeng", "age" : 18])
print(p.name)    //打印結果 : "xiaofeng\n"
print(p.age)     //打印結果 : "18\n"

8 析構函數

—-> 8.1 Swift 會自動釋放不再需要的實例以釋放資源,類似於delloc

—-> 8.2 Swift 通過自動引用計數（ARC）處理實例的內存管理

—-> 8.3 當引用計數為0時,系統會自動調用析構函數(不可以手動調用)

—-> 8.4 通常在析構函數中釋放一些資源(如移除通知等操作)

–> 1 析構函數寫法

deinit {
    // 執行析構過程
}

–> 2 具體代碼

class Person : NSObject {
    var name = ""
    var age = 0
    //用來釋放一些沒用的資源,類似於delloc
    deinit {
        print("Person -----deinit")    //打印結果 : "Person -----deinit\n"
        NSNotificationCenter.defaultCenter().removeObserver(self)
    }
}

var p : Person? = Person()
p = nil      //此時將p賦值為nil,析構函數中的print會打印Person -----deinit

9 屬性監聽

—-> 9.1 在OC中我們可以重寫set方法來監聽屬性的改變

—-> 9.2 Swift中可以通過屬性觀察者來監聽和響應屬性值的變化

—-> 9.3 通常是監聽存儲屬性和類屬性的改變.(對於計算屬性，我們不需要定義屬性觀察者，因為我們可以在計算屬性的setter中直接觀察並響應這種值的變化)

—-> 9.4我們通過設置以下觀察方法來定義觀察者

—–> 9.4.1 willSet：在屬性值被存儲之前設置。此時新屬性值作為一個常量參數被傳入。該參數名默認為newValue，我們可以自己定義該參數名

—–> 9.4.2 didSet：在新屬性值被存儲後立即調用。與willSet相同，此時傳入的是屬性的舊值，默認參數名為oldValue

—–> 9.4.3 willSet與didSet只有在屬性第一次被設置時才會調用，在初始化時，不會去調用這些監聽方法

class Person: NSObject {
    //屬性監聽器name
    var name : String = "" {
        //監聽屬性即將發生改變
        willSet (new) {
        //在該方法中有一個默認的系統屬性newValue,用於存儲新值
            print(name)    //打印結果 : "\n"
            print(new)     //打印結果 : "xiaofeng\n"
        }
        //監聽屬性已經發生改變
        didSet (old){
        //在該方法中有一個默認的系統屬性oldValue,用於存儲舊值
            print(name)     //打印結果 : "xiaofeng\n"
            print(old)      //打印結果 : "\n"
        }
    }
    //屬性監聽器age
    var age : Int = 0 {
        //在willSet中有newValue,用於保存新值
        willSet (newAge) {
            print(age)
            print(newAge)
        }
        //在didSet中有oldSet,用於保存舊值
        didSet (oldAge) {
            print(age)
            print(oldAge)
        }
    }
}

//創建對象
let p = Person()
p.name = "xiaofeng"
p.age = 20

七 總結

1 該部分接上一篇swift基本語法部分,詳細的講解了函數,自定義構造方法,類部分的相關知識,裡面寫的並不是很全面,我已經盡可能的完善了,希望能幫到大家.

2 最後,我還會陸續的更新swift的相關知識,希望看到我博客的開發者,如果覺得我寫的還行的話,麻煩大家支持我的博客,關注我的官方博客,謝謝!!!!