Swift-Abkommen
Abkommen die Methoden und Eigenschaften für eine bestimmte Funktion, die zur Durchführung.
Lage, die Anforderungen jeder Art von Vereinbarung zu treffen ist wie folgt (konform) der Vereinbarung bekannt.
Klasse, Struktur oder Aufzählungstypen können Protokolle folgen und spezifische Implementierung liefert die protokolldefinierten Methoden und Funktionen zu vervollständigen.
Grammatik
Syntax Vereinbarung sind wie folgt:
protocol SomeProtocol {
// 协议内容
}
Um eine Protokollklasse folgen, müssen Sie mit dem Protokollnamen, die mittlere Doppelpunkt im Namen eingeben: getrennt, als Teil der Typdefinition. Wenn mehrere Protokolle zu folgen, mit einem Komma zwischen den getrennten Protokoll.
struct SomeStructure: FirstProtocol, AnotherProtocol {
// 结构体内容
}
Wenn die Klasse das Protokoll während Eltern zu folgen hat, sollte die übergeordnete Klasse Name vor dem Protokollnamen platziert werden durch Komma getrennt.
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 类的内容
}
Bereitstellung von Immobilien
Protokoll wird verwendet, um eine bestimmte Instanz der Klasse Attribut oder Eigenschaft angeben, ohne das type-Attribut Speicher oder Rechen Eigenschaft angeben. Es muss auch als schreibgeschützt oder Lese-Schreib angegeben werden.
Abkommen ist in der Regel Variablen var Attributtyp Deklaration zu deklarieren nach dem Hinzufügen {set get} die Eigenschaft darzustellen lesbar und beschreibbar, read-only-Attribut dargestellt wird durch {get}.
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)
Die obige Programmausführung Ausgabe ist:
98 true false Swift 协议 Swift
Methoden der Mutating Bestimmungen
Manchmal müssen Sie es in einer Instanzmethode zu ändern.
Zum Beispiel kann der Wert Typ (struct, enum) Instanzmethode, die mutiert Schlüsselwort als Präfix-Funktion, vor func geschrieben, die ein modifiziertes Beispiel des Wertes seiner Instanzen zeigt Attribut kann es in dem Prozess gehört.
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()
Die obige Programmausführung Ausgabe ist:
Wednesday
Die Bestimmungen des Konstruktor
Abkommen kann es erfordern diejenigen, die Umsetzung der angegebenen Konstruktor zu folgen.
Sie können wie ein gewöhnlicher Konstruktor schreiben, als Konstrukteure eine Erklärung, in der Definition im Vertrag geschrieben, aber nicht schreiben, Klammern und Konstrukteuren Einheit Syntax lautet wie folgt:
protocol SomeProtocol {
init(someParameter: Int)
}
Beispiele
protocol tcpprotocol {
init(aprot: Int)
}
Protokoll im Konstruktor der Klasse Implementierung angegeben
Sie können die Vereinbarung Konstruktor in der Klasse folgen, und angeben, ob es zweckmäßig ist, den Konstruktor oder Klasse Konstruktor angeben. In beiden Fällen müssen Sie den Konstruktor hochgestelltes zu erreichen sein "erforderlich" Modifikator:
class SomeClass: SomeProtocol {
required init(someParameter: Int) {
// 构造器实现
}
}
protocol tcpprotocol {
init(aprot: Int)
}
class tcpClass: tcpprotocol {
required init(aprot: Int) {
}
}
Verwenden Sie Modifikator Garantien erforderlich: folgen alle Subklassen der Vereinbarung, kann es auch eine explizite Implementierung zur Verfügung stellen oder den Konstruktor erben zu erfüllen.
Wenn eine Unterklasse der angegebenen übergeordneten Klasse Konstruktor überschreibt, und der Konstruktor folgt den Bestimmungen einer Vereinbarung, muss der Konstruktor Implementierung markiert werden gleichzeitig erforderlich und Überschreibung Modifikatoren:
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)")
Die obige Programmausführung Ausgabe ist:
res is: 20 res is: 30 res is: 50
Protokolltyp
Obwohl die Vereinbarung selbst implementieren keine Funktion, sondern kann als Protokolltyp verwendet werden, zu verwenden.
Wie andere Protokolle können die gleiche allgemeine Art verwenden, Nutzungsszenarien:
- Als eine Funktion, Methode oder Konstruktor Parametertypen oder Rückgabewert Typ
- Als eine Art von Konstanten, Variablen oder Eigenschaften
- Als Array, einem Wörterbuch oder einem anderen Behälter Elementart
Beispiele
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}))
Die obige Programmausführung Ausgabe ist:
10 20 30 5 10 15 [100, 200, 300] [10, 20, 30]
Hinzufügen von Mitgliedern in der Verlängerungsvertrag
Wir können erweitern die Typen (Klassen, Strukturen, Aufzählungen, etc.) zu erweitern ist bereits vorhanden.
Erweiterungen können Mitglied Eigenschaften, Methoden und Index das Skript als Protokolltyp, der bereits vorhanden hinzuzufügen.
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"
}
}
}Erbvertrag
Protokoll kann ein oder mehrere andere Protokolle erben, können Sie neue Inhalte hinzufügen Vereinbarung auf der Grundlage der Vererbung erfordert.
Die Syntax ist ähnlich und Klassenvererbung Protokoll der Vererbung durch ein Komma zwischen mehreren ererbten Abkommen getrennt:
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 协议定义
}
Beispiele
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)
Die obige Programmausführung Ausgabe ist:
学生尝试 1 次通过 学生尝试 1 次通过 学生尝试 1 次通过 学生尝试 5 次通过 学生尝试 5 次通过 学生缺席考试 学生尝试 5 次通过 学生缺席考试
Exklusivvertrag
Sie können eine Liste der Protokoll erben, indem Sie die Klasse Schlüsselwort Beschränkungsabkommen hinzufügen, können nur in die Kategorie (Klasse) passen eingeben.
Die Klasse muss das erste Schlüsselwort in der Liste der Protokolle nacheinander angezeigt werden, dann ist der andere Nachfolgeabkommen. Format ist wie folgt:
protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
// 协议定义
}
Beispiele
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)")
Die obige Programmausführung Ausgabe ist:
res is: 20 res is: 30 res is: 50
Syntheseprotokoll
Swift Synthese Unterstützung mehrerer Protokolle, was sehr nützlich ist, wenn wir mehr als ein Protokoll folgen müssen.
Die Syntax ist wie folgt:
protocol<SomeProtocol, AnotherProtocol>
Beispiele
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)
Die obige Programmausführung Ausgabe ist:
Person(name: "Priya", age: 21) Person(name: "Rehan", age: 29) Person(name: "Roshan", age: 19)
Konsistenzprüfung Vereinbarung
Sie können die ist die Verwendung und als Betreiber die Einhaltung eines Protokolls zu überprüfen oder in einer bestimmten Art gezwungen.
-
isBetreiber zu prüfen , ob eine Instanz遵循einem bestimmten协议. -
as?einen optionalen Wert zurückgibt, wenn die Instanz遵循, wenn die Vereinbarung den Protokolltyp zurückzukehren, andernfalls gibt esnil. -
asfür die obligatorische gesenkten ausfällt, wenn die starke wiederum wird einen Laufzeitfehler verursachen.
Beispiele
Das folgende Beispiel definiert ein HasArea Protokoll eine Doppel Typ lesbar Bereich erfordert:
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("没有面积")
}
}
Die obige Programmausführung Ausgabe ist:
面积为 12.5663708 面积为 243610.0 没有面积