acuerdo rápido

Acuerdo para poner en práctica los métodos y las propiedades requeridas para una función en particular.

Capaz de satisfacer las necesidades de cualquier tipo de acuerdo se conoce como seguimiento (cumplir) el acuerdo.

Clase, estructura o de enumeración tipos pueden seguir los protocolos y proporciona implementación específica para completar los métodos y funciones definidos en el protocolo.

gramática

Sintaxis acuerdo son los siguientes:

protocol SomeProtocol {
    // 协议内容
}

Para seguir una clase de protocolo, es necesario escribir el nombre con el nombre del protocolo, colon media: separado, como parte de la definición de tipo. Cuando varios protocolos a seguir, con una coma entre cada protocolo separado.

struct SomeStructure: FirstProtocol, AnotherProtocol {
    // 结构体内容
}

Si la clase tiene que seguir el protocolo, mientras que los padres, el nombre de la clase padre debe ser colocado antes del nombre del protocolo, separados por comas.

class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
    // 类的内容
}

Provisión de la propiedad

Protocolo se utiliza para especificar un caso particular de la clase o atributo de la propiedad, sin especificar el tipo de memoria atributo o propiedad computacional. También debe indicarse como de sólo lectura o de lectura y escritura.

Acuerdo es por lo general para declarar variables var declaración de tipo de atributo después de añadir {} get conjunto para representar la propiedad es de lectura y escritura, el atributo de sólo lectura está representado por {} llegar.

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 salida por encima de la ejecución del programa es:

98
true
false
Swift 协议
Swift

Métodos de disposiciones mutando

A veces es necesario cambiarla en un método de instancia.

Por ejemplo, el método de instancia de tipo de valor (struct, enum), la palabra clave mutando en función de prefijo, escrito antes de func, muestra un ejemplo modificado del valor de sus instancias pueden atribuir pertenece en el proceso.

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 salida por encima de la ejecución del programa es:

Wednesday

Las disposiciones del constructor

Acuerdo podrá requerir a seguir a los que aplicar el constructor especificado.

Se puede escribir como un constructor de ordinario, como constructores escribió una declaración en la definición contenida en el acuerdo, pero no escribir los apoyos y la sintaxis constructores entidad es el siguiente:

protocol SomeProtocol {
   init(someParameter: Int)
}

Ejemplos

protocol tcpprotocol {
   init(aprot: Int)
}

Protocolo especificado en la aplicación constructor de la clase

Puede seguir el constructor de acuerdo en clase, y especificar si es conveniente especificar el constructor o constructor de la clase. En ambos casos, usted tiene que ser lograr el superíndice constructor "necesaria" modificador:

class SomeClass: SomeProtocol {
   required init(someParameter: Int) {
      // 构造器实现
   }
}

protocol tcpprotocol {
   init(aprot: Int)
}

class tcpClass: tcpprotocol {
   required init(aprot: Int) {
   }
}

Utilice garantías modificador requerido: siga todas las subclases del acuerdo, sino que también puede proporcionar una implementación explícita o heredar el constructor para el cumplimiento.

Si una subclase anula el constructor de la clase padre específico, y el constructor se ajusta a las disposiciones de un acuerdo, entonces la aplicación constructor tiene que estar marcado de forma simultánea modificadores requeridos y de anulación:

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 salida por encima de la ejecución del programa es:

res is: 20
res is: 30
res is: 50

tipo de protocolo

Aunque el propio acuerdo no implementa ninguna función, pero se puede utilizar como el tipo de protocolo de usar.

Al igual que otros protocolos pueden utilizar el mismo tipo general, los escenarios de uso:

Como una función, método o tipos de parámetro constructor o tipo de valor de retorno
Como un tipo de constantes, variables o propiedades
Como una matriz, un diccionario u otro tipo de elemento contenedor

Ejemplos

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 salida por encima de la ejecución del programa es:

10
20
30
5
10
15
[100, 200, 300]
[10, 20, 30]

Adición de miembros en el acuerdo de ampliación

Podemos ampliar ampliar los tipos (clases, estructuras, enumeraciones, etc.) ya existe.

Las extensiones pueden añadir propiedades de miembro, métodos, y el índice de la secuencia de comandos, como el tipo de protocolo que ya existe.

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

acuerdo de la herencia

Protocolo puede heredar uno o más protocolos, puede agregar nuevos contenidos requiere un acuerdo sobre la base de la herencia.

La sintaxis es similar a la herencia y protocolo de herencia de clases, separados por una coma entre Acuerdo hereditaria múltiple:

protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
    // 协议定义
}

Ejemplos

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 salida por encima de la ejecución del programa es:

学生尝试 1 次通过
学生尝试 1 次通过
学生尝试 1 次通过
学生尝试 5 次通过
学生尝试 5 次通过
学生缺席考试
学生尝试 5 次通过
学生缺席考试

Acuerdo Exclusivo

Se puede heredar una lista de protocolo, mediante la adición de los acuerdos de limitación de palabras clave de clase sólo puede caber en la categoría (clase) escribe.

La clase debe ser la primera palabra clave aparece en la lista de protocolos de forma sucesiva, a continuación, es el otro acuerdo sucesor. El formato es el siguiente:

protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
    // 协议定义
}

Ejemplos

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 salida por encima de la ejecución del programa es:

res is: 20
res is: 30
res is: 50

Protocolo de Síntesis

de apoyo a la síntesis rápida de múltiples protocolos, lo cual es muy útil cuando tenemos que seguir más de un protocolo.

Sintaxis es la siguiente:

protocol<SomeProtocol, AnotherProtocol>

Ejemplos

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 salida por encima de la ejecución del programa es:

Person(name: "Priya", age: 21)
Person(name: "Rehan", age: 29)
Person(name: "Roshan", age: 19)

Acuerdo de Inspección consistencia

Se pueden utilizar los operadores is y as para comprobar el cumplimiento de un protocolo o de la fuerza en un determinado tipo.

is el operador para comprobar si hay una instancia 遵循 un cierto 协议 .
as? devuelve un valor opcional, cuando la instancia se 遵循 cuando el acuerdo para devolver el tipo de protocolo, de lo contrario se vuelve nil .
as para abatido obligatorio, si falla la fuerte su vez, provocará un error de ejecución.

Ejemplos

El siguiente ejemplo define un protocolo HasArea requiere un área legible tipo doble:

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 salida por encima de la ejecución del programa es:

面积为 12.5663708
面积为 243610.0
没有面积

Anterior: expansión Swift

Siguiente: Swift Genérico

Swift curso

acuerdo rápido

gramática

Provisión de la propiedad

Métodos de disposiciones mutando

Las disposiciones del constructor

Ejemplos

Protocolo especificado en la aplicación constructor de la clase

tipo de protocolo

Ejemplos

Adición de miembros en el acuerdo de ampliación

acuerdo de la herencia

Ejemplos

Acuerdo Exclusivo

Ejemplos

Protocolo de Síntesis

Ejemplos

Acuerdo de Inspección consistencia

Ejemplos