Swift 中的协议 (Protocol)

最新推荐文章于 2025-01-04 15:12:33 发布

原创最新推荐文章于 2025-01-04 15:12:33 发布 · 679 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#swift #协议解析

iOS 基础专栏收录该内容

20 篇文章

订阅专栏

本文介绍了Swift中的协议概念，包括协议定义、mutating方法的规定、遵守协议的方式、可选协议的使用、协议的继承以及如何检查协议的一致性。协议在Swift中允许结构体和枚举遵循，提供了灵活性和多态性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Swift 协议

Swift 中的协议用来定义方法和属性但协议本身不进行实现，而是由遵守该协议的类具体实现与OC不同的是，协议可以被结构体和枚举遵守
定义协议

 protocol 协议名称 {
   协议内容
 }

如果希望定义的协议只能被类遵守定义格式

 protocol 协议名称 : Class {
   协议内容
 }

对 Mutating 方法的规定

有时需要在方法中改变它的实例。
例如，值类型(结构体，枚举)的实例方法中，将mutating关键字作为函数的前缀，写在func之前，表示可以在该方法中修改它所属的实例及其实例属性的值。

 protocol daysofaweek {
    mutating func show()
 }

enum days: daysofaweek {
    case sun, mon, tue, wed, thurs, fri, sat
    mutating func show() {
        switch self {
        case .sun:
            self = .sun
            print("Sunday")
        case .mon:
            self = .mon
            print("Monday")
        case .tue:
            self = .tue
            print("Tuesday")
        case .wed:
            self = .wed
            print("Wednesday")
        case .thurs:
            self = .thurs
            print("Wednesday")
        case .fri:
            self = .fri
            print("Wednesday")
        case .sat:
            self = .sat
            print("Saturday")
        default:
            print("NO Such Day")
        }
    }
}

var res = days.wed
res.show()

遵守协议

类、结构体、枚举遵守协议时，在他们的名称后面加上协议名称中间用冒号分隔多个协议之间用逗号分隔

protocol Run {
    func run()
}
protocol Eat {
    func eat()
}

class Animal : Run , Eat {

    func eat() {
        print("吃啊")
    }
    func run() {
        print("跑啊")
    }
}
class Dog: NSObject,Run {

    func run(){
        print("狗在爬坡")
    }
}

class Cat: Animal{

    override func run(){
        print("�� 在爬坡")
    }
}

可选协议

如果协议中声明的内容是可选的，也就是说在遵守协议时可以实现也可以不用实现
注意：在声明可选协议时，要在可选内容的前面加 @objc optional 关键字并且在声明协议时在protocol关键字前加
@objc

@objc protocol Show {

    @objc optional func sing()

    func dancing()
}
class Person : Show {
    func dancing() {
        print("正在跳舞��")

    }
}

协议的继承

协议之间可以继承，他的语法格式与类的继承相似，不同的是协议可以都继承，继承多个协议时，被继承的协议之间用逗号分隔

protocol Jump {
    func jump()
}
protocol Climb{
    func climb()
}

protocol Stu : Jump,Climb {

    var name : String{get}
}

class student : Stu {

    func jump() {
        print("跳")
    }
    func climb() {
        print("爬")
    }
    var name: String
    init(name : String) {
        self.name = name
    }
}

let stu1 = student(name: "小明")

stu1.climb()
stu1.jump()
stu1.name

检查协议的一致性

使用 is 操作符检查实例是否遵守了某个协议
使用 as 操作符把实例类型转换到指定的协议类型

stu1 is Run
stu1 is Stu

if let tempStu  =  stu1 as? Stu {
    print("----------\(tempStu.name)")
} else {
    print("************")
}