porozumienia SWIFT

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.

gramatyka

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 {
    // 类的内容
}

Zapewnienie własności

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

Metody przepisów mutowania

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

Przepisy konstruktora

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)
}

Przykłady

protocol tcpprotocol {
   init(aprot: Int)
}

Protokół określony w realizacji konstruktora klasy

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

Typ protokołu

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:

Jako funkcji, metody lub typów parametrów konstruktora lub Return typu wartości
Jako typ stałych, zmiennych lub właściwości
Jako tablica, słownika lub innego typu elementu kontenera

Przykłady

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]

Dodawanie członków w umowie przedłużacza

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 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"
      }
   }
}

Umowa Dziedziczenie

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 {
    // 协议定义
}

Przykłady

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 次通过
学生缺席考试

Umowa Exclusive

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 {
    // 协议定义
}

Przykłady

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

Synteza protokół

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>

Przykłady

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)

Umowa Spójność Inspection

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.

Przykłady

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
没有面积

Poprzedni: Swift ekspansji

Dalej: Swift Generic

Swift kurs

porozumienia SWIFT

gramatyka

Zapewnienie własności

Metody przepisów mutowania

Przepisy konstruktora

Przykłady

Protokół określony w realizacji konstruktora klasy

Typ protokołu

Przykłady

Dodawanie członków w umowie przedłużacza

Umowa Dziedziczenie

Przykłady

Umowa Exclusive

Przykłady

Synteza protokół

Przykłady

Umowa Spójność Inspection

Przykłady