accordo Swift
Accordo per implementare i metodi e le proprietà necessarie per una particolare funzione.
In grado di soddisfare le esigenze di qualsiasi tipo di accordo è conosciuto come segue (conforme) il contratto.
tipi di classe, nella struttura o di enumerazione possono seguire i protocolli e fornisce specifica implementazione per completare i metodi e le funzioni di protocollo definito.
grammatica
Accordo di sintassi sono i seguenti:
protocol SomeProtocol {
// 协议内容
}
Per seguire una classe di protocollo, è necessario digitare il nome con il nome del protocollo, i due punti di mezzo: separati, come parte della definizione del tipo. Quando più protocolli da seguire, con una virgola tra ciascun protocollo separato.
struct SomeStructure: FirstProtocol, AnotherProtocol {
// 结构体内容
}
Se la classe deve seguire il protocollo, mentre genitore, il nome della classe genitore dovrebbe essere posto prima del nome del protocollo, separati da virgole.
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 类的内容
}
Fornitura di beni
Protocollo viene utilizzato per specificare una particolare istanza dell'attributo di classe o della proprietà, senza specificare la memoria attributo type o proprietà computazionale. Deve essere indicato anche come sola lettura o di lettura e scrittura.
Accordo di solito è di dichiarare le variabili var dichiarazione del tipo di attributo dopo l'aggiunta di {get set} per rappresentare la proprietà è di lettura e scrittura, l'attributo di sola lettura è rappresentato da {} ottenere.
protocol classa {
var marks: Int { get set }
var result: Bool { get }
func attendance() -> String
func markssecured() -> String
}
protocol classb: classa {
var present: Bool { get set }
var subject: String { get set }
var stname: String { get set }
}
class classc: classb {
var marks = 96
let result = true
var present = false
var subject = "Swift 协议"
var stname = "Protocols"
func attendance() -> String {
return "The \(stname) has secured 99% attendance"
}
func markssecured() -> String {
return "\(stname) has scored \(marks)"
}
}
let studdet = classc()
studdet.stname = "Swift"
studdet.marks = 98
studdet.markssecured()
print(studdet.marks)
print(studdet.result)
print(studdet.present)
print(studdet.subject)
print(studdet.stname)
L'output sopra l'esecuzione del programma è il seguente:
98 true false Swift 协议 Swift
Metodi di disposizioni mutazione
A volte è necessario cambiare in un metodo di istanza.
Ad esempio, il metodo istanza tipo di valore (struct, enum), la parola mutazione in funzione prefisso, scritto prima func, che mostra un esempio modificato del valore delle sue istanze possono attribuire essa appartiene nel processo.
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 mon:
self = thurs
print("Thursday")
case tue:
self = fri
print("Friday")
case sat:
self = sat
print("Saturday")
default:
print("NO Such Day")
}
}
}
var res = days.wed
res.show()
L'output sopra l'esecuzione del programma è il seguente:
Wednesday
Le disposizioni del costruttore
Accordo può richiedere a seguire coloro che implementare il costruttore specificato.
È possibile scrivere come un costruttore normale, come i costruttori hanno scritto una dichiarazione nella definizione nel contratto, ma non scrivere bretelle e sintassi costruttori entità è la seguente:
protocol SomeProtocol {
init(someParameter: Int)
}
Esempi
protocol tcpprotocol {
init(aprot: Int)
}
Protocollo specificato nella implementazione della classe costruttore
È possibile seguire l'accordo di costruzione della classe, e specificare se è conveniente per specificare il costruttore costruttore o classe. In entrambi i casi, devi essere per ottenere il costruttore apice "necessaria" modificatore:
class SomeClass: SomeProtocol {
required init(someParameter: Int) {
// 构造器实现
}
}
protocol tcpprotocol {
init(aprot: Int)
}
class tcpClass: tcpprotocol {
required init(aprot: Int) {
}
}
Utilizzare garanzie richieste modificatori: seguire tutte le sottoclassi del contratto, può anche fornire un'implementazione esplicita o ereditare il costruttore a realizzare.
Se una sottoclasse sovrascrive il costruttore della classe padre specificato, e il costruttore segue le disposizioni di un accordo, quindi l'attuazione del costruttore deve essere segnata simultaneamente richieste e di override modificatori:
protocol tcpprotocol {
init(no1: Int)
}
class mainClass {
var no1: Int // 局部变量
init(no1: Int) {
self.no1 = no1 // 初始化
}
}
class subClass: mainClass, tcpprotocol {
var no2: Int
init(no1: Int, no2 : Int) {
self.no2 = no2
super.init(no1:no1)
}
// 因为遵循协议，需要加上"required"; 因为继承自父类，需要加上"override"
required override convenience init(no1: Int) {
self.init(no1:no1, no2:0)
}
}
let res = mainClass(no1: 20)
let show = subClass(no1: 30, no2: 50)
print("res is: \(res.no1)")
print("res is: \(show.no1)")
print("res is: \(show.no2)")
L'output sopra l'esecuzione del programma è il seguente:
res is: 20 res is: 30 res is: 50
tipo di protocollo
Sebbene l'accordo stesso non implementa una funzione, ma può essere utilizzato come il tipo di protocollo da utilizzare.
Come altri protocolli possono utilizzare lo stesso tipo generale, scenari di utilizzo:
- Come una funzione, un metodo o tipi di parametri costruttore o il ritorno tipo di valore
- Come un tipo di costanti, variabili e alle proprietà
- Come un array, un dizionario o altro tipo di elemento contenitore
Esempi
protocol Generator {
typealias members
func next() -> members?
}
var items = [10,20,30].generate()
while let x = items.next() {
print(x)
}
for lists in [1,2,3].map( {i in i*5}) {
print(lists)
}
print([100,200,300])
print([1,2,3].map({i in i*10}))
L'output sopra l'esecuzione del programma è il seguente:
10 20 30 5 10 15 [100, 200, 300] [10, 20, 30]
Aggiunta di membri nel contratto di estensione
Siamo in grado di estendersi ad espandere i tipi (classi, strutture, enumerazioni, ecc) già esistente.
Le estensioni possono aggiungere proprietà dei membri, i metodi e l'indice di script, come il tipo di protocollo già esistente.
protocol AgeClasificationProtocol {
var age: Int { get }
func agetype() -> String
}
class Person {
let firstname: String
let lastname: String
var age: Int
init(firstname: String, lastname: String) {
self.firstname = firstname
self.lastname = lastname
self.age = 10
}
}
extension Person : AgeClasificationProtocol {
func fullname() -> String {
var c: String
c = firstname + " " + lastname
return c
}
func agetype() -> String {
switch age {
case 0...2:
return "Baby"
case 2...12:
return "Child"
case 13...19:
return "Teenager"
case let x where x > 65:
return "Elderly"
default:
return "Normal"
}
}
}accordo di successione
Protocollo può ereditare uno o più altri protocolli, è possibile aggiungere nuovi contenuti richiede un accordo sulla base di eredità.
La sintassi è simile a quella eredità e il protocollo di ereditarietà di classe, separati da una virgola tra multipla accordo ereditato:
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 协议定义
}
Esempi
protocol Classa {
var no1: Int { get set }
func calc(sum: Int)
}
protocol Result {
func print(target: Classa)
}
class Student2: Result {
func print(target: Classa) {
target.calc(1)
}
}
class Classb: Result {
func print(target: Classa) {
target.calc(5)
}
}
class Student: Classa {
var no1: Int = 10
func calc(sum: Int) {
no1 -= sum
print("学生尝试 \(sum) 次通过")
if no1 <= 0 {
print("学生缺席考试")
}
}
}
class Player {
var stmark: Result!
init(stmark: Result) {
self.stmark = stmark
}
func print(target: Classa) {
stmark.print(target)
}
}
var marks = Player(stmark: Student2())
var marksec = Student()
marks.print(marksec)
marks.print(marksec)
marks.print(marksec)
marks.stmark = Classb()
marks.print(marksec)
marks.print(marksec)
marks.print(marksec)
L'output sopra l'esecuzione del programma è il seguente:
学生尝试 1 次通过 学生尝试 1 次通过 学生尝试 1 次通过 学生尝试 5 次通过 学生尝试 5 次通过 学生缺席考试 学生尝试 5 次通过 学生缺席考试
accordo esclusivo
È possibile ereditare una lista di protocollo, con l'aggiunta di accordi di ritenuta classe di parole chiave può essere inserita solo nella categoria (classe) la digitazione.
La classe deve essere la prima parola chiave compare nella lista dei protocolli in successione, poi, è l'altro accordo successore. Il formato è come segue:
protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
// 协议定义
}
Esempi
protocol TcpProtocol {
init(no1: Int)
}
class MainClass {
var no1: Int // 局部变量
init(no1: Int) {
self.no1 = no1 // 初始化
}
}
class SubClass: MainClass, TcpProtocol {
var no2: Int
init(no1: Int, no2 : Int) {
self.no2 = no2
super.init(no1:no1)
}
// 因为遵循协议，需要加上"required"; 因为继承自父类，需要加上"override"
required override convenience init(no1: Int) {
self.init(no1:no1, no2:0)
}
}
let res = MainClass(no1: 20)
let show = SubClass(no1: 30, no2: 50)
print("res is: \(res.no1)")
print("res is: \(show.no1)")
print("res is: \(show.no2)")
L'output sopra l'esecuzione del programma è il seguente:
res is: 20 res is: 30 res is: 50
sintesi protocollo
supporto sintesi Swift protocolli multipli, il che è molto utile quando abbiamo bisogno di seguire più di un protocollo.
La sintassi è la seguente:
protocol<SomeProtocol, AnotherProtocol>
Esempi
protocol Stname {
var name: String { get }
}
protocol Stage {
var age: Int { get }
}
struct Person: Stname, Stage {
var name: String
var age: Int
}
func show(celebrator: protocol<Stname, Stage>) {
print("\(celebrator.name) is \(celebrator.age) years old")
}
let studname = Person(name: "Priya", age: 21)
print(studname)
let stud = Person(name: "Rehan", age: 29)
print(stud)
let student = Person(name: "Roshan", age: 19)
print(student)
L'output sopra l'esecuzione del programma è il seguente:
Person(name: "Priya", age: 21) Person(name: "Rehan", age: 29) Person(name: "Roshan", age: 19)
Accordo di ispezione Consistenza
È possibile utilizzare le IS e come operatori di controllare il rispetto di un protocollo o costretti in un certo tipo.
-
isall'operatore di controllare se un'istanza遵循un determinato协议. -
as?restituisce un valore opzionale, quando l'istanza viene遵循quando l'accordo per riportare il tipo di protocollo, altrimenti restituiscenil. -
asper downcast obbligatoria, non riesce se la forte sua volta, causare un errore di runtime.
Esempi
L'esempio seguente definisce un protocollo HasArea richiede un tipo Double zona leggibile:
protocol HasArea {
var area: Double { get }
}
// 定义了Circle类，都遵循了HasArea协议
class Circle: HasArea {
let pi = 3.1415927
var radius: Double
var area: Double { return pi * radius * radius }
init(radius: Double) { self.radius = radius }
}
// 定义了Country类，都遵循了HasArea协议
class Country: HasArea {
var area: Double
init(area: Double) { self.area = area }
}
// Animal是一个没有实现HasArea协议的类
class Animal {
var legs: Int
init(legs: Int) { self.legs = legs }
}
let objects: [AnyObject] = [
Circle(radius: 2.0),
Country(area: 243_610),
Animal(legs: 4)
]
for object in objects {
// 对迭代出的每一个元素进行检查，看它是否遵循了HasArea协议
if let objectWithArea = object as? HasArea {
print("面积为 \(objectWithArea.area)")
} else {
print("没有面积")
}
}
L'output sopra l'esecuzione del programma è il seguente:
面积为 12.5663708 面积为 243610.0 没有面积