DahuangPhoneiOSSwift → swift 协议


  共有7788人关注过本帖树形打印复制链接

主题:swift 协议

帅哥哟,离线,有人找我吗?
dahuangphone
  1楼 | 信息 | 搜索 | 邮箱 | 主页 | UC


加好友 发短信
等级:管理员 帖子:407 积分:4533 威望:0 精华:0 注册:2012/9/29 7:54:10
swift 协议  发帖心情 Post By:2014/10/10 18:20:32 [只看该作者]

//协议:所有的方法都是抽象的,类似于java的接口,c++中的纯虚类。

//协议可以规定方法的方法名,参数列表和返回值,没有具体实现,由遵守这个协议的类来完成具体实现

//协议可以规定属性的类型和读写属性

//类,结构体,枚举都可以声明遵守协议


protocol Pro1{

    func protocolFunc(str:String)->String

}


protocol Pro2{

    class func staticProtocolFunc(str:String)->String //静态方法,此处必须用class声明

}


protocol Pro3{

    mutating func mutatingProtocolFunc(str:String)->String //mutating 针对结构体和枚举,对类相当于没有

}


protocol Pro4{

    var n1:String{get set}

    var n2:String{get set}

    var n3:String{get}  // 这几个协议属性在具体类型中可以是储存属性,也可以是计算属性,总是变量类型对,读写要求相同就行

    class var n4:String{get// 静态属性,次数必须用class,遵守者看实际情况使用class或者static

}


protocol Pro5:Pro1//协议也可以继承

    

}



class A:Pro4{

    var n1:String{

    get{

        return self.n1

    }

    set{

        self.n1=newValue

    }

    }

    

    var n2:String=""   //存储属性本身已经实现了getset协议。

    

    var n3:String{

    get{

        return self.n1+self.n2

    }

    set{   //尽管协议只要求get,但是我们有set也可以。协议只要求我们要有什么,没有要求不能有什么

        self.n1=newValue

    }

    }

    

    class var n4:String//静态协议属性

        return "A"

    }

}


class B:A,Pro1{   //既要继承,又要遵守协议的时候,需要把父类写在第一个上,后面是协议

    func protocolFunc(str: String) -> String {

        return str;

    }

}


class C:Pro1,Pro2{

    func protocolFunc(str: String) -> String {

        return str;

    }

    class func staticProtocolFunc(str:String)->String{

        return str;

    }

}


struct D:Pro1,Pro2,Pro3{

    

    var name:String=""

    

    func protocolFunc(str: String) -> String {

        return str;

    }

    static func staticProtocolFunc(str: String) -> String//此处要使用static

        return str;

    }

    

    mutating func mutatingProtocolFunc(str:String)->String{   //变异方法,可以修改结构体内部属性

        self.name=str

        return str

    }

}


enum E:Pro3{

    case a,b,c,d

    mutating func mutatingProtocolFunc(str:String)->String//变异方法,可以修改枚举值

        self=E.c

        return str

    }

   

}


extension C:Pro3//扩展遵守协议,注意mutating关键字,在类实现的时候直接省去

    func mutatingProtocolFunc(str:String)->String{

        return ""

    }

}


var e:E=E.a

e.mutatingProtocolFunc("")

if e==E.c{

    var a=1

}


//协议是以一种类型存在的,我们可以声明这种类型的实例


var p1:Pro1=D()

var p2:Pro1=C()

var p3:protocol<Pro1,Pro2> = C()  //合成协议,同时支持Pro1,Pro2的数据类型


var p:[Pro1]=[p1,p2]


for item in p{

    if let temp=item as? D{

        temp

    }else{

        1

    }

}


if let temp=p3 as? D{

    temp

}else{

    1

}


//另一个例子


//定义一个协议

protocol addPro{

    func addFunc(a:Int,b:Int)->Int

}



//addClass遵守这个协议

class addClass:addPro{


    func addFunc(a: Int, b: Int) -> Int {

        return a+b

    }

}


//将协议作为参数传入

func add(a:Int,b:Int,pro:addPro)->Int{

   return pro.addFunc(a, b: b)

}


//addClass()是addClass的一个实例,同时它遵守addPro这个协议,所以addClass也是addPro的一个实例

add(1,2,addClass())



//如果一个类型在内部已经遵守了一个协议,却没有生命,可以通过扩展补充说明


protocol addPro{

    func addFunc(a:Int,b:Int)->Int

}




class addClass{   //没有声明遵守协议


    func addFunc(a: Int, b: Int) -> Int {   //遵守了协议

        return a+b

    }

}


extension addClass:addPro{}   //扩展补充说明



//@objc protocol 表示协议是可选的,也可以用来暴露给objective-c使用,说以它只能用在类上,不能用在结构体和枚举



@objc protocol AddPro{

    optional var index:Int{get}   //optional必须和@objc配合使用,表示这个在协议中是可选的

    optional func addPro(a:Int,b:Int)->Int    //optional必须和@objc配合使用,表示这个在协议中是可选的

}


class AddClass:AddPro{

    func addPro(a: Int, b: Int) -> Int {

        return a+b

    }

}



class Sum{

    var sum=0

    var method:AddPro?

    func addFunc(a:Int,b:Int){

    if let result = method?.addPro?(a,b: b){    // 注意问号的使用

        sum=result

    }else{

    sum=1000

    }

    }

}



var sum:Sum=Sum()

sum.addFunc(1, b: 2)  //结果为1000,因为method=nil

sum.method=AddClass()   // 实例花了method

sum.addFunc(1, b: 2)   //结果为3



//关联类型在协议中的使用


protocol pro{

    typealias ItemType:Equatable   //关联类型,要求必须遵守Equatable协议

    class func add(a:ItemType,b:ItemType)->ItemType

}



class addInt:pro{

    typealias ItemType=Int   //确定关联类型

    class func add(a: ItemType, b: ItemType) -> ItemType {

        return a+b

    }

}


class addString:pro{

    typealias ItemType=String  //确定关联类型

    class func add(a: ItemType, b: ItemType) -> ItemType {

        return a+b

    }

}



addInt.add(1, b: 2)


addString.add("111", b: "aaa")




[此贴子已经被作者于2014/10/13 17:30:41编辑过]

 回到顶部