Tabla de contenido
versión
Xcode 11.3.1
Swift 5.1.3
protocolo
El protocolo especifica los métodos y atributos necesarios para lograr una función específica.
Las clases, estructuras o tipos enumerados pueden seguir el protocolo y proporcionar implementaciones específicas para completar los métodos y funciones definidos por el protocolo.
gramática
protocol SomeProtocol {
// 这里是协议的定义部分
}
Deje que los tipos personalizados sigan varios protocolos:
struct SomeStructure: FirstProtocol, AnotherProtocol {
// 这里是结构体的定义部分
}
Si una clase tiene una clase principal, el nombre de la clase principal debe colocarse antes del nombre del protocolo seguido, separado por comas:
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 这里是类的定义部分
}
Requisitos de propiedad
El protocolo no especifica si el atributo es un atributo almacenado o un atributo calculado, solo especifica el nombre y tipo del atributo.
Además, el protocolo especifica si el atributo es legible o legible y escribible.
Si el acuerdo estipula que es legible y escribible, entonces la implementación del acuerdo también es legible y escribible; si el acuerdo estipula que es legible, además de ser legible, la implementación también se puede escribir de acuerdo con las necesidades reales.
Agregue {set get} después de la declaración de tipo para indicar que la propiedad se puede leer y escribir, y {get} para indicar solo lectura.
protocol Subject {
var name: String {
get }
var score: Int {
get set }
}
struct Math: Subject {
var name: String {
return "Math" }
var score = 0
}
var math = Math()
//math.name = "Chinese" // 只读属性，报错
math.score = 100
print(math.name, math.score)
// 打印 Math 100
Requisitos del método
El protocolo puede requerir que los tipos que siguen el protocolo implementen ciertos métodos de instancia o métodos de clase especificados.
protocol SayHello {
func sayHello()
}
class Person: SayHello {
var name: String
init(name: String) {
self.name = name
}
func sayHello() {
print("\(self.name) say hello")
}
}
let xiaoming = Person(name: "小明")
xiaoming.sayHello()
// 小明 say hello
let xiaohong = Person(name: "小红")
xiaohong.sayHello()
// 小红 say hello
Requisitos del constructor
Puede implementar un constructor en una clase que se ajuste al protocolo, ya sea como un constructor designado o como un constructor de conveniencia, debe marcar la implementación del constructor con el modificador requerido:
protocol SayHello {
func sayHello()
}
class Person: SayHello {
var name: String
init(name: String) {
self.name = name
}
func sayHello() {
print("\(self.name) say hello")
}
}
let xiaoming = Person(name: "小明")
xiaoming.sayHello()
// 小明 say hello
let xiaohong = Person(name: "小红")
xiaohong.sayHello()
// 小红 say hello
protocol StudentName {
init(studentName: String)
}
class Student: Person, StudentName {
required init(studentName: String) {
super.init(name: studentName)
}
}
let xiaojun = Student(studentName: "学生小军")
xiaojun.sayHello()
// 学生小军 say hello
Comisión
La delegación es un patrón de diseño que permite a las clases o estructuras delegar algunas de las funciones de las que son responsables a instancias de otros tipos.
por ejemplo:
// 定义一个看门的协议
protocol WatchDoor {
func watchDoor()
}
// 人类会看门，所以遵循 WatchDoor 协议
class People: WatchDoor {
var name: String
init(name: String) {
self.name = name
}
func watchDoor() {
print("\(self.name)看门")
}
// 定义一个被委托对象，来代理看门任务 （现在这个被委托对象是谁还不知道）
var delegate: WatchDoor? = nil
}
// 打南面来了一条狗
class Dog {
var name: String
init(name: String) {
self.name = name
}
}
// 某天这狗的任督二脉被打通，从此具备看门的能力
extension Dog: WatchDoor {
func watchDoor() {
print("\(self.name)看门")
}
}
// 本来是人类小康看门
let people = People(name: "小康")
people.watchDoor()
// 看到狗儿旺财来了
let dog = Dog(name: "旺财")
// 然后委托旺财来看门
people.delegate = dog
// 现在是旺财在看门
people.delegate?.watchDoor()
/**
小康看门
旺财看门
*/