accord Swift
Accord pour mettre en œuvre les méthodes et les propriétés requises pour une fonction particulière.
Capable de répondre aux exigences de tout type d'accord est connu comme suit (conforme) de l'accord.
types de classe, la structure ou l'énumération peuvent suivre les protocoles et fournit la mise en œuvre spécifique pour compléter les méthodes et fonctions définis par le protocole.
grammaire
accord de syntaxe sont les suivantes:
protocol SomeProtocol {
// 协议内容
}
Pour suivre une classe de protocole, vous devez taper le nom avec le nom du protocole, du côlon milieu: séparés, dans le cadre de la définition de type. Lorsque plusieurs protocoles à suivre, avec une virgule entre chaque protocole séparé.
struct SomeStructure: FirstProtocol, AnotherProtocol {
// 结构体内容
}
Si la classe doit suivre le protocole tout parent, le nom de la classe parent doit être placé avant le nom de protocole, séparés par des virgules.
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 类的内容
}
Fourniture de biens
Protocole est utilisé pour spécifier une instance particulière de l'attribut de classe ou de la propriété, sans spécifier la mémoire type d'attribut ou de la propriété de calcul. Il doit également être indiquée comme étant en lecture seule ou en lecture-écriture.
Accord est généralement de déclarer des variables var déclaration de type d'attribut après avoir ajouté {set get} pour représenter la propriété est lisible et inscriptible, attribut lecture seule est représentée par {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)
La sortie de l'exécution du programme ci-dessus est la suivante:
98 true false Swift 协议 Swift
Méthodes de dispositions Mutating
Parfois, vous avez besoin de changer dans une méthode d'instance.
Par exemple, le type de valeur (struct, enum) méthode d'instance, le mot-clé muter en fonction de préfixe, écrit avant func, montrant un exemple modifié de la valeur de ses instances peut attribuer il appartient dans le processus.
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()
La sortie de l'exécution du programme ci-dessus est la suivante:
Wednesday
Les dispositions du constructeur
Accord peut l'obliger à suivre ceux qui mettent en œuvre le constructeur spécifié.
Vous pouvez écrire comme un constructeur ordinaire, comme les constructeurs ont écrit une déclaration dans la définition de l'accord, mais ne pas écrire les accolades et la syntaxe des constructeurs d'entité se présente comme suit:
protocol SomeProtocol {
init(someParameter: Int)
}
Exemples
protocol tcpprotocol {
init(aprot: Int)
}
Protocole spécifié dans la mise en œuvre de constructeur de classe
Vous pouvez suivre le constructeur de l'accord dans la classe, et de préciser s'il est commode de spécifier le constructeur de constructeur ou de classe. Dans les deux cas, vous devez être pour atteindre le superscript constructeur "nécessaire" modificateur:
class SomeClass: SomeProtocol {
required init(someParameter: Int) {
// 构造器实现
}
}
protocol tcpprotocol {
init(aprot: Int)
}
class tcpClass: tcpprotocol {
required init(aprot: Int) {
}
}
Utilisez des garanties de modification requis: suivre toutes les sous-classes de l'accord, il peut aussi fournir une implémentation explicite ou hériter du constructeur pour l'accomplissement.
Si une sous-classe remplace le constructeur de la classe parent spécifié, et le constructeur respecte les dispositions d'un accord, puis la mise en œuvre du constructeur doit être marqué modificateurs simultanément requis et override:
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)")
La sortie de l'exécution du programme ci-dessus est la suivante:
res is: 20 res is: 30 res is: 50
Type de protocole
Bien que l'accord lui-même ne met pas en œuvre une fonction, mais peut être utilisé comme le type de protocole à utiliser.
Comme les autres protocoles peuvent utiliser le même type général, les scénarios d'utilisation:
- En fonction, la méthode ou les types de paramètres constructeur ou le retour type de valeur
- En tant que type de constantes, variables ou propriétés
- En tant que matrice, d'un dictionnaire ou d'un autre type d'élément de récipient
Exemples
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}))
La sortie de l'exécution du programme ci-dessus est la suivante:
10 20 30 5 10 15 [100, 200, 300] [10, 20, 30]
Ajout de membres dans l'accord d'extension
Nous pouvons étendre à élargir les types (classes, structures, énumérations, etc.) existe déjà.
Les extensions peuvent ajouter des propriétés des membres, des méthodes, et l'indice du script, comme le type de protocole qui existe déjà.
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"
}
}
}accord sur les successions
Protocole peut hériter d'un ou plusieurs autres protocoles, vous pouvez ajouter du nouveau contenu exige un accord sur la base de l'héritage.
La syntaxe est similaire à l'héritage et le protocole d'héritage de classe, séparés par une virgule entre accord hérité multiples:
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 协议定义
}
Exemples
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)
La sortie de l'exécution du programme ci-dessus est la suivante:
学生尝试 1 次通过 学生尝试 1 次通过 学生尝试 1 次通过 学生尝试 5 次通过 学生尝试 5 次通过 学生缺席考试 学生尝试 5 次通过 学生缺席考试
Accord exclusif
Vous pouvez hériter d'une liste de protocole, en ajoutant les accords de restriction de mot-clé de classe ne peut tenir dans la catégorie (classe) tapez.
La classe doit être le premier mot-clé apparaît dans la liste des protocoles successifs, alors, est l'autre accord successeur. Le format est le suivant:
protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
// 协议定义
}
Exemples
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)")
La sortie de l'exécution du programme ci-dessus est la suivante:
res is: 20 res is: 30 res is: 50
Protocole de synthèse
support de synthèse Swift plusieurs protocoles, ce qui est très utile quand nous avons besoin de suivre plus d'un protocole.
La syntaxe est la suivante:
protocol<SomeProtocol, AnotherProtocol>
Exemples
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)
La sortie de l'exécution du programme ci-dessus est la suivante:
Person(name: "Priya", age: 21) Person(name: "Rehan", age: 29) Person(name: "Roshan", age: 19)
Accord d'inspection Cohérence
Vous pouvez utiliser les opérateurs is et as de vérifier le respect d'un protocole ou contraints à un certain type.
-
isopérateur de vérifier si une instance遵循un certain协议. -
as?renvoie une valeur facultative, lorsque l'instance est遵循lorsque l'accord pour retourner le type de protocole, sinon elle retournenil. -
aspour baissés obligatoire, échoue si la forte tour, provoquera une erreur d'exécution.
Exemples
L'exemple suivant définit un protocole de HasArea nécessite une zone de lecture de type Double:
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("没有面积")
}
}
La sortie de l'exécution du programme ci-dessus est la suivante:
面积为 12.5663708 面积为 243610.0 没有面积