Swift系列12-协议

发表于 | 更新于 | 分类于 | 阅读次数
字数统计 982 字

协议

使用protocol关键字
形如: 

1
2
3
4
5
6
protocol 协议名 {
    func 方法1()//没有方法主体
    func 方法2()
    var age:Int{get set}//可读可写属性
    var gander:Int{get}//只读属性
}

一个类需要实现多个协议的用逗号,进行隔开

1
2
3
4
5
class DelegateView: BaseViewController,MsgDelegate,DataDelegate {
	override func viewDidLoad() {
		super.viewDidLoad()
	}
}

协议中的属性

协议中的属性:
1,必须使用var来修饰
2,不允许有默认值
3,只能使用{set get}可读可写,{get}只读来修饰.
4,属性必须要实现赋值
5,使用static进行修饰的属性,需要类实现 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
protocol CarDelegate {
    ///属性可读可写
    var name:String{get set}
    ///属性只读
    var from:String{get}
    static var time:String{get set} //使用static进行修饰的属性,需要类实现
}
class BaseCar: NSObject{
    ///BaseCar类的协议
    var delegate:CarDelegate?
}

class ShowMessage: NSObject,CarDelegate {
    var name: String = "特斯拉"
    var from: String = "USA"//由于是可读属性,可以使用let关键字修饰:let from: String = "USA"
    static var time: String = "time"
    override init() {
        super.init()
        print(name)
        name = "宝马"
        print(name)
        print(ShowMessage.time) //类实现
    }
}

协议中的方法

协议中的方法:
1,不能有方法体,只是声明方法
2,方法形参不可以有默认值
3,方法默认都是必须实现的
4,可选方法:需要@objc修饰protocol,对应的方法还要@objc optional修饰
5,异变方法:mutating

默认实现的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
protocol DataDelegate: AnyObject {
    func todayFor()
    func getMessage(_ height:CGFloat)
}
class CommonMessage: NSObject {
    //使用weak来修饰,防止出现实例之间的循环引用
    weak var dataDelegate:DataDelegate?
    func beginSomething() {        
        self.dataDelegate?.getMessage(100)
        self.dataDelegate?.todayFor()  
    }
}

class DelegateView: BaseViewController,DataDelegate {   
    override func viewDidLoad() {
        super.viewDidLoad()
        com = CommonMessage.init()
        com.dataDelegate = self //协议
        com.beginSomething()
    }
   func todayFor() {
        print("必须实现的协议")
    }
   func getMessage(_ height: CGFloat) {
        print("传递参数")
    }
}

可选实现方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 @objc protocol MsgDelegate:AnyObject {
    func from() //这个方法没有@objc optional修饰,也是必须实现的
    @objc optional func address()
}
class CommonMessage: NSObject {
    //使用weak来修饰,防止出现实例之间的循环引用
    weak var delegate:MsgDelegate?
    func beginSomething() {
        self.delegate?.from()
        if self.delegate?.address?() != nil {
            print("实现了address")
            self.delegate?.address?()
        }else{
            print("没有实现address对应协议")
        }
        /*
         OC中有判断协议是否已经实现了的方法;
         swift中则没有,如果要判断使用如上(self.delegate?.address?() != nil),
         必须是可选协议方法才能进行判断,必须实现的方法就必须实现;
         */
    }
}

异变方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//有时一个方法需要改变（或异变）其所属的实例.
protocol Togglable {
    mutating func toggle()
}
enum OnOffSwitch: Togglable {
    case off, on
    mutating func toggle() {
        switch self {
        case .off:
            self = .on
        case .on:
            self = .off
        }
    }
}
var lightSwitch = OnOffSwitch.off //先设置了off
lightSwitch.toggle() //调用异变方法 现在是on

协议是否继承AnyObject

协议可用于结构体,枚举,类
在类中使用,书写的协议时,协议需要继承AnyObject;这样协议可以用weak进行修饰,防止出现实例的循环引用;
不使用NSObjectProtocol,是因为NSObjectProtocol是OC语言的,swift不推荐使用;

用于类之间的协议:AnyObject,需要添加weak来修饰防止循环引用

1
2
3
4
5
6
7
8
9
protocol 协议名 : AnyObject{
    func 方法1()//没有方法主体
    func 方法2()
    var age:Int{get set}//可读可写属性
    var gander:Int{get}//只读属性
}
class PC: NSObject {
    weak var dele:协议名?
}

用于结构体或枚举,不需要使用weak来修饰协议

1
2
3
4
5
6
7
///用于结构体或枚举,不需要使用weak来修饰协议
protocol Another {
    func 方法()
}
class PC: NSObject {
    var le:Another?
}

The End