iOS中 Swift初級入門學習(三)

版權聲明：本文為部落客原創文章，未經部落客允許不得轉載。

//  

//  main.swift  

//  lessonswift-03  

//  copyright (c) 2015年 韓俊強. all rights reserved.  

import foundation  

// 聲明一個類, 我們用class關鍵字修飾  

// 類可以被繼承, 它是引用類型  

class student {  

    var name = "小米"  

    var gender = "男"  

    var age = 18  

}  

// 建立一個student執行個體  

let studnet = student()  

let student2 = studnet  

// 如何判斷兩個執行個體是否一樣  

if studnet === student2{  

    println("兩個執行個體一樣, 都操作的同一塊記憶體")  

}else{  

    println("兩個實力不一樣")  

// 在類中,判斷兩個實力是否相等, 用 === ,不相等用 !==  

let student3 = student()  

if student3 !== studnet {  

    println("不一樣")  

    println("一樣")  

// 聲明結構體我們用struct關鍵字  

struct person {  

    var name : string  

    var age : int  

var person = person(name: "小妹妹", age: 19)  

var person2 = person  

// 結構體中,不能判斷兩個執行個體是否相等  

//if person === person2 {  

//}  

// 屬性  

// 根據調用對象的不同, 屬性可以分為類屬性, 還有執行個體類型屬性  

// 根據功能的不同, 屬性可以分為存儲屬性 和 計算屬性  

struct animal {  

    // 這兩個屬性是對象來調用的, 是執行個體屬性  

    // 這兩個屬性是用來存儲值的, 是存儲屬性  

    var typename : string  

    var isfly : bool  

// 建立一個執行個體  

var dog = animal(typename: "泰迪", isfly: false)  

// 該屬性的作用是存儲值, 調用的對象是執行個體  

dog.typename = "藏獒"  

println(dog.isfly)  

class human {  

    var name : string!  

    var age : int!  

    // 延遲存儲屬性  

    // 延遲存儲屬性用lazy修飾, 而且必須是可變的, 也就是說要用var 來修飾變量, 還要給初值, 什麼時候建立, 就和我們oc中的懶加載一樣  

    lazy var cat : animal = animal(typename: "波斯貓", isfly: true)  

let ahumen = human()  

// 調用該屬性的時候, 才會被建立  

ahumen.cat.typename = "加菲貓"  

println(ahumen.cat.typename)  

// 計算屬性  

class coolperson {  

    // 有set get方法, 或者隻有get方法的屬性叫做計算屬性, 計算屬性不能給屬性指派, 隻能給其他屬性指派  

    var countproperty : string{  

        set {  

            // newvalue 就是系統在set方法中為我們提供的一個新值, 也就是我們給該屬性賦的值  

            println(newvalue)  

            name = newvalue  

        }  

        get {  

            // 把值給我們的計算屬性  

            return "\(name)" + "好帥"  

    }  

let 小妹妹 = coolperson()  

小妹妹.countproperty = "朱麗葉"  

println(小妹妹.name)  

println(小妹妹.countproperty)  

class teacher {  

    var name = "小花"  

    var age = 19  

    // 隻有get方法的屬性就叫隻讀屬性, 不能給該屬性指派  

    var gender : string {  

//        get {  

//            return "男"  

//        }  

        // 簡潔寫法  

        return "男"  

let 小花 = teacher()  

//小花.gender = "女"  

// 屬性觀察器  

class bird {  

    var isfly : bool!  

    var age : int! {  

    willset {  

    // 屬性将要被指派的時候會走的方法  

    // newvalue 是新值  

    println("newvalue = \(newvalue)")  

    didset {  

    // 屬性已經被指派的時候會走該方法  

    println("oldvalue = \(oldvalue)")  

       }  

   }  

let abird = bird()  

abird.age = 19  

// 類屬性  

struct desk {  

    // 結構體中的屬性我們用static修飾  

    // 結構體中的類屬性, 我們要給它賦初始值  

    static var price : float = 2  

    static var numbers : int = 1  

    static var totalprice : float {  

        // newvalue 的類型和 totalprice一緻  

            numbers = int(newvalue)  

            return float(numbers) * price  

// 類屬性通過類名調用  

desk.numbers = 10  

println("總價格 == \(desk.totalprice) 元")  

// 類的類屬性  

class fruit {  

    // 類的類屬性用class關鍵字來修飾, 并且隻能修飾計算屬性  

    class var name : string {  

    get {  

    return "hello"  

println(fruit.name)  

// 方法  

// 按照調用對象的不同, 方法可以分為類方法和執行個體方法  

class plane {  

    // 執行個體方法  

    func canfly() {  

        println("我會飛")  

let plan = plane()  

plan.canfly()  

struct ship {  

    func canship() {  

        println("我會在水裡跑")  

let ship = ship()  

ship.canship()  

// 類方法  

struct man {  

    // 結構體中的類方法, 我們用static來修飾  

    static func playlol() {  

        println("男人喜歡lol")  

// 通過 類名.方名 的方式調用類方法  

man.playlol()  

// 類中的類方法我們用class來修飾, 通過 類名.方法名 的方式來調用  

class women {  

    class func shopping() {  

        println("敗家")  

// 繼承  

// 沒有繼承類叫基類, 也叫做超類  

class yapei {  

    var name = "亞培"  

    var age = 23  

    var description : string {  

        println("\(name) 年齡 \(age) 喜歡逛淘寶")  

        return "\(name) 年齡 \(age) 喜歡逛淘寶"  

    // 如果一個類的屬性或者方法不想被繼承, 我們可以在方法或者屬性前面加關鍵字 final , 如果整個類都不想被繼承 就在 class前面加 關鍵字 final  

   final func infoofyapei(){  

        println("這是個基類的方法");  

class sonofyapei: yapei {  

    // 不能重寫存儲屬性  

//    override var name = "小花"  

    // 我們隻能重寫計算屬性, 用override來修飾  

    override var description : string {  

        return "\(name) 的子類"  

//    override func infoofyapei() {  

//        println("重寫了父類的方法,這是子類的方法")  

//    }  

let pei = yapei()  

println(pei.description)  

pei.infoofyapei()  

// 構造方法  

class monkey {  

    var gender : string  

    // 構造方法, 通過構造方法我們要保證每一個沒有值的屬性被指派  

    init(name : string,age : int,gender : string) {  

        // 如果屬性名和參數名一樣, 這個時候我們的屬性名前面一定要加self  

        // 我們要確定調用過構造方法以後, 該執行個體的每一個屬性都有值  

        self.name = name  

        self.gender = gender  

        self.age = age  

let 孫悟空 = monkey(name: "悟空", age: 8, gender: "未知")  

println((孫悟空.name,孫悟空.age,孫悟空.gender))  

class 金剛 : monkey {  

    var hobby : string  

    // 必須在調用父類的構造方法前, 先給子類的沒有指派的屬性指派  

    init(name: string, age: int, gender: string,hobby : string) {  

    self.hobby = hobby  

    super.init(name: name, age: age, gender: gender)  

let ac = 金剛 (name: "猴子`", age: 12, gender: "nan", hobby: "玩耍")  

// 析構  

class badegg {  

    var shape : string!  

    var color : string!  

    // 析構方法類似于oc裡面的dealloc 方法, 當執行個體的引用計數器為0的時候會走的方法  

    deinit {  

        println("egg --- dead")  

var anegg : badegg? = badegg()  

var anotheregg : badegg? = badegg()  

anegg = nil  

anotheregg = nil  

// 自動引用計數機制  

// 在swift當中也是使用自動引用計數機制來管理記憶體(arc)  

// 引用技術機制僅僅應用于類的執行個體, 而結構體是值類型, 有不同的方式來存儲和傳遞值, 結構體沒有引用計數機制  

// swift直接使用arc, 會在類的執行個體不再使用的時候走deinit(析構)方法  

// swift中的arc機制: 這塊空間如果隻是一個指針指向, 那麼我們把這個指針置為nil, 這塊空間就會釋放掉, 如果有多個指針指向, 那麼我們需要把所有的真想這塊空間的指針置為nil,這塊空間才會釋放  

原文位址：http://blog.csdn.net/qq_31810357/article/details/50081507