Najlepszy samouczek porozumienia SWIFT W 2024 r. W tym samouczku możesz dowiedzieć się Zapewnienie własności,Metody przepisów mutowania,Przepisy konstruktora,Protokół określony w realizacji konstruktora klasy,Typ protokołu,Dodawanie członków w umowie przedłużacza,Umowa Dziedziczenie,Umowa Exclusive,Synteza protokół,Umowa Spójność Inspection,
Umowa na wdrożenie metod i właściwości wymaganych dla danej funkcji.
W stanie spełnić wymagania każdego rodzaju umowy znana jest następująca (zgodne) umowy.
Klasa, struktura lub wyliczenie rodzajów może obserwować protokoły i zapewnia realizację konkretnego celu zakończenia metod i protokołów funkcje zdefiniowane.
Umowa Składnia przedstawiają się następująco:
protocol SomeProtocol { // 协议内容 }
Aby śledzić klasy protokołu, należy wpisać nazwę z nazwą protokołu, Bliski jelita grubego: w separacji, jako część definicji typu. Gdy wiele protokołów do naśladowania, przecinkiem pomiędzy każdym protokole rozdzielone.
struct SomeStructure: FirstProtocol, AnotherProtocol { // 结构体内容 }
Jeśli klasa ma podążać protokół while rodzica, nazwa klasy rodzic powinien być umieszczony przed nazwą protokołu, rozdzielając je przecinkami.
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol { // 类的内容 }
Protokół jest używany do określenia konkretnej instancji atrybutu klasy lub mienia, bez określania atrybutu pamięci typu lub mienia obliczeniowej. To musi być również wskazany jako tylko do odczytu lub odczytu i zapisu.
Umowa jest zazwyczaj zadeklarować zmienne var deklarację typu atrybutu po dodaniu {Ustaw get} reprezentuje właściwość jest do odczytu i zapisu, atrybut tylko do odczytu jest reprezentowany przez {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)
Wyjście powyżej wykonywanie programu jest:
98 true false Swift 协议 Swift
Czasami trzeba zmienić go w metodzie instancji.
Na przykład, wartość typu (Struct wyliczeniowym) Metoda przykład, mutacji kluczowe w funkcji prefiksu napisany przed func, pokazano zmodyfikowany przykład wartości jego przypadkach może przypisać należy w tym procesie.
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()
Wyjście powyżej wykonywanie programu jest:
Wednesday
Umowa może wymagać go do naśladowania tych, którzy realizować określony konstruktor.
Można pisać jak zwykły konstruktora, ponieważ konstruktorzy napisał oświadczenie w definicji w umowie, ale nie pisz szelki i składnia podmiot konstruktorzy przedstawia się następująco:
protocol SomeProtocol { init(someParameter: Int) }
protocol tcpprotocol { init(aprot: Int) }
Możesz śledzić konstruktora umowy w klasie, i określić, czy jest to wygodne, aby określić konstruktor konstruktora lub klasy. W obu przypadkach trzeba być osiągnięcie odnośnikiem konstruktora "niezbędne" modyfikator:
class SomeClass: SomeProtocol { required init(someParameter: Int) { // 构造器实现 } } protocol tcpprotocol { init(aprot: Int) } class tcpClass: tcpprotocol { required init(aprot: Int) { } }
Użyj gwarancji wymaganych modyfikatorów: przestrzegać wszystkich podklas umowy, może też stanowić wyraźny wdrożenia lub odziedziczyć konstruktora do spełnienia.
Jeśli podklasą zastępuje określony konstruktora klasy nadrzędnej, a konstruktor przestrzega postanowień umowy, a następnie wdrożenie konstruktor musi być oznaczony jednocześnie niezbędne i zastąpić modyfikatory:
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)")
Wyjście powyżej wykonywanie programu jest:
res is: 20 res is: 30 res is: 50
Chociaż sama umowa nie implementuje żadnej funkcji, ale może być używany jako typ protokół.
Podobnie jak inne protokoły mogą wykorzystywać ten sam typ ogólny, scenariusze użycia:
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}))
Wyjście powyżej wykonywanie programu jest:
10 20 30 5 10 15 [100, 200, 300] [10, 20, 30]
Możemy rozszerzyć rozszerzyć typów (klas, struktur, wyliczeń, etc.) już istnieje.
Rozszerzenia mogą dodawać właściwości członków, metod i indeks scenariusz, jako typ protokołu, który już istnieje.
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 0pl.2: return "Baby" case 2pl.12: return "Child" case 13pl.19: return "Teenager" case let x where x > 65: return "Elderly" default: return "Normal" } } }
Protokół może dziedziczyć jeden lub więcej innych protokołów, można dodać nowe treści wymaga umowy na podstawie dziedziczenia.
Składnia jest podobna do dziedziczenia oraz protokół klasy dziedziczenie, oddzielonych przecinkami między wieloma odziedziczonej Umowy:protocol InheritingProtocol: SomeProtocol, AnotherProtocol { // 协议定义 }
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)
Wyjście powyżej wykonywanie programu jest:
学生尝试 1 次通过 学生尝试 1 次通过 学生尝试 1 次通过 学生尝试 5 次通过 学生尝试 5 次通过 学生缺席考试 学生尝试 5 次通过 学生缺席考试
Można dziedziczyć listę protokołu, dodając słowo kluczowe class układów przytrzymujących może pasować tylko do kategorii (klasy) typ.
Klasa musi być pierwsze słowo kluczowe pojawi się na liście protokołów z rzędu, to jest druga umowa następcą. Format jest następujący:
protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol { // 协议定义 }
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)")
Wyjście powyżej wykonywanie programu jest:
res is: 20 res is: 30 res is: 50
Swift wspomagająca syntezę wielu protokołów, co jest bardzo przydatne, gdy musimy śledzić więcej niż jeden protokół.
Składnia jest następująca:
protocol<SomeProtocol, AnotherProtocol>
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)
Wyjście powyżej wykonywanie programu jest:
Person(name: "Priya", age: 21) Person(name: "Rehan", age: 29) Person(name: "Roshan", age: 19)
Można korzystać z IS i operatorzy w celu sprawdzenia zgodności z protokołem lub zmuszeni do określonego typu.
is
operatorem w celu sprawdzenia, czy instancja 遵循
pewien 协议
. as?
zwraca opcjonalną wartość, gdy instancja jest 遵循
, gdy umowa wrócić typ protokołu; w przeciwnym wypadku zwraca nil
. as
obowiązkowego spuszczonymi, nie powiedzie się, jeśli silny kolej, spowoduje błąd wykonania. Poniższy przykład definiuje protokół HasArea wymaga obszar czytelnego typu 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("没有面积") } }
Wyjście powyżej wykonywanie programu jest:
面积为 12.5663708 面积为 243610.0 没有面积