Swift列舉,結構體,類,擴充套件,協議

weixin_34249678發表於2017-10-31

1.列舉

有的變數只要幾種取值的選擇,在swift中對這種比較特殊的變數,可以定義為列舉型別

列舉的定義

//enum 列舉名稱{
//    此處放置列舉的成員
//}

列舉的程式碼

enum UserLever{
    
    case 總經理
    case 業務員
}

enum UserLever1
{
    case 總經理,業務員,哈哈
}

print(UserLever1.哈哈)

//注意:列舉和Swift不同的是他們的值並不會隱式等於0，1，2,3

列舉值的遍歷

let caseValue=UserLever1.哈哈

switch  caseValue{
case UserLever1.哈哈:
      print("哈哈")
case UserLever1.總經理:
      print("總經理")
default:
    print("呵呵")
}

列舉的原始值

enum sex:Int
{
    case man=1
    case female=2
    case unknow=3
}
//另一種寫法
enum sex1:Int
{
    case man=1,female,unknow
}
print(sex1.man.rawValue)

//給列舉新增方法
enum sex2:Int
{
    case man,female,unknow
    func fun()
    {
        print("哈哈")
    }
}

//呼叫列舉中的方法
let gender=sex2.man
gender.fun()

2.結構體

結構體的定義

//struct 結構體名稱{
//    此處放置結構體的內容
//}

struct People{
    
    var name="大保健"
    var sex="男"
    //給結構體新增方法
    func getName() {
        
        print("name:\(name)    sex:\(sex)")
    }
    
}

let people1=People()

people1.getName()

people1.name

3.類

Swift 類是構建程式碼的一種通用而靈活的構造體,類是屬於使用者自定義的資料型別,並且該型別的資料具有一定的行為能力，也就是類中所描述的方法

類的建立

//class 類名
//{
//    屬性列表
//    方法別表
//}

class people
{
    var name = "小明"
    var sex = "男"
    
    func fun(){
        
        print("name:\(name)")
    }
}

let p=people()

p.fun()
print(p.name)

其中可以在定義類的時候,給它指定自定義的init初始化方法

class people2
{
    var name = "小明"
    var sex = "男"
    //自定義的init初始化方法
    init() {
        
        self.name="哈哈"
        self.sex="女"
    }
    //帶引數的例項化
    init(name:String,sex:String) {
        
        self.name=name
        self.sex=sex
        
    }
}

let pp1=people2(name:"呵呵",sex:"女")

print(pp1.name)

類屬性的set和get方法，使用get和set來間接獲取/改變其他屬性的值

class people3
{
    var name = "小明"
    var getpeopleName: String {
        get {
            return name
        }
        set {
            name = newValue
        }
    }
}

let pp3 = people3()
pp3.getpeopleName="呵呵呵呵呵呵"//set
pp3.name//get

類屬性的willSet和didSet方法,可以給類新增屬性觀察者

屬性觀察者可以觀察屬性值得變化,並對此作出相應的鵝反應，當設定屬性值時,屬性觀察者就被呼叫,即使當新值和原值相同時也就會被呼叫
可以單獨或者同時使用下面的方法,以進行屬性觀察者的定義:willset方法在設定屬性值之前被呼叫。而didset方法則在設定屬性值之後被呼叫
當實現willset觀察者時,新的屬性值作為常量引數被傳遞。可以為這個引數起一個名字，如果不命名,則這個引數就被預設命名為newValue
注意:set get 方法和willSet,didSet不能一起用好像

class people4
{
    var name = "小明"
    {
        
        willSet{
            
            print("即將設定為新值\(newValue)")
        }
        didSet{
            
           print("新值設定成功\(name)")
        }
    }
}

let pp4 = people4()
pp4.name="======哈哈"

類的靜態方法

靜態方法為類所有,需要通過類來使用,因此靜態方法不必建立類的例項就可以使用,在Swift環境中可以為類,結構體和列舉等型別定義靜態的方法,也稱為型別方法

class people5
{
    //定義靜態方法
    class func GetName(name:NSString)->NSString {
        
        return  name;
    }

}

print(people5.GetName(name:"哈哈哈"))

類的析構

與構造工程相反,例項最後釋放的時候,需要清除一些資源,這個過程就是析構的過程。在析構過程中也會呼叫一個特殊的方法deinit，稱之解構函式。解構函式deinit沒有返回值,也沒有引數,也不需要引數的小括號,所以不能過載

class people6
{
    var name:String
    
    init(name:String) {
        self.name=name
    }
    
    deinit { //定義了解構函式
        
      print("呼叫解構函式...")
      
        
    }
    
}


var pp6:people6? = people6(name:"小明")
print(pp6!.name)
pp6 = nil

類的繼承

在Swift環境中，類的繼承不同於結構體和列舉型別，繼承是類所特有的。當一個類繼承其他類時,繼承類就被稱為子類，被繼承類稱為父類或者超類
類的繼承具有以下特點
1.繼承是在一些通用類的基礎上構造,建立和擴充新類的最有效的手段
2.繼承能清晰體現相關類之間的程詞機構關係
3.繼承提供了軟體複用功能
4.繼承通過增強一致性,來減少模組間的介面和介面,大大增加了程式的易維護性

class people7{
    
    func say(){
        
        print("我要大保健")
    }
}


class peopleSon:people7{
    
    
    var name:String
    
    init(name:String) {
        
        self.name=name
    }
    
    
    
     func say1(){
        
        print("我們一起大保健")
    }
    
    override func say() {//重寫
        
         print("我是：\(name)要去保健")
    }
    
}

let pp7=peopleSon(name:"麻痺戒指")
pp7.say()
pp7.say1()

類的延遲載入屬性lazy

延遲載入屬性是指當第一次被呼叫的時候,才會對其進行初始化的屬性(就是懶載入)

class people8{

    lazy var name="小明"

}
let pp8=people8()
pp8.name

類的引用特徵

class people9
{
    
    var name:String
    init(name:String) {
        
        self.name=name
    }
  
}

var pp9 = people9(name:"呵呵")
pp9.name="麻痺戒指"

var pp91=pp9
pp91.name="古天樂麻痺戒指"
print(pp91.name)

型別的檢測

型別檢測在swift中是一種檢測例項型別的方式，同時也是讓例項作為它的父類或者子類的一種方式

class people10
{
    
    var name:String
    init(name:String) {
        
        self.name=name
    }
    
}

class peopleson1:people10
{
    func say() {
        
        print("古天樂麻痺戒指")
    }
}


let pps10 = peopleson1(name:"呵呵")


// is操作符是一個型別檢査操作符,在Swift中,對它的定義是:檢測一個例項是不是特定類的子型別,如果是,則該操作符返回true,如果不是,則返回false.
if (pps10 is people10){
    
    print("是這種型別")
}

// as操作符是一個型別轉換操作符,主要用於例項在子類和父類間的轉換
if let item=pps10 as? people10{
    
    item.name="====古天樂麻痺戒指"
    item.name
}

anyObject和any

Swift為不確定型別提供了兩種特殊型別別名：
AnyObject可以代表任何class型別(即類型別)的例項。
Any可以表示任何型別，包括方法型別（function types）。用來修飾任意型別的例項,包括AnyObject修飾的例項.
注意：
只有當你明確的需要它的行為和功能時才使用Any和AnyObject。在你的程式碼裡使用你期望的明確的型別總是更好的.
AnyObject型別
AnyObject任意例項型別
Any 其實Any是AnyObject的總類,完全覆蓋AnyObject.

class Evil{
    
    var name = ""
}

var hiter = Evil()
hiter.name = "保健"

var hiter1 = Evil()
hiter1.name = "大保健"

var array = [AnyObject]()
array=[hiter,hiter1]

if let item=array[1]as?Evil {
    
    item.name
}

4.擴充套件

Swift中的擴充套件功能（Extension）,可以動態地給類增加功能,類似JavaScript中prototype，這包括在沒有許可權獲取原始原始碼的情況下,擴充套件某個型別的功能。而在object-C中,則是通過runtime中來實現動態呼叫或者新增功能的
現有的類,結構或列舉型別的方法,可以在擴充套件的幫助下進行新增。型別的功能可以使用擴充套件加入，但重寫的功能不能使用擴充套件
在Swift中使用擴充套件可以完成以下任務
新增計算型屬性和計算型靜態屬性
定義例項方法和型別方法
提供新的構造器
定義下標
定義和使用新的巢狀型別
使一個已有型別符合某個協議
注意：
擴充套件可以對一個型別新增新的功能，但是不能重寫已有的功能。

示例程式碼

extension String{
    
    //新增屬性
    var name:  String{
        
        return  "呵呵"
    }
    
    func getname(name:String) -> String {
        
        return name;
    }
}

print("名字".name)
print("名字".getname(name:"麻痺戒指"))

//新增構造器
/*
 
 其實構造器就是一個特殊的方法,所以擴充套件構造器方法就是新增方法,不過要注意兩點:
 1:如果擴充套件類型別,我們只能夠增加便捷構造器,而不能夠增加指定構造器和析構器.
 2:對於值型別,比如結構體,列舉,在擴充套件其構造器時,務必保證所有的屬性都被初始化.
 
 */

struct people{
    
    var name = "小明"
    
}

extension people
{
    func say() {
        
        print("麻痺戒指")
    }
}

let p = people()

p.name
p.say()

5.協議定義

協議是為方法,屬性等定義一套規範,沒有具體的實現,類似Java中的抽象介面，它只是描述了方法或者屬性的骨架,而不是實現。
協議可以通過一個類,結構或列舉，來提供協議中要去的具體實現