9.43. Swift protocol

9.43.1. Grammar #

The syntax format of the protocol is as follows:

protocol SomeProtocol { // Agreement Content } 

For a class to follow a protocol, you need to add the protocol name after the type name, separated by a colon: as part of the type definition. When following multiple protocols, each protocol is separated by a comma.

struct SomeStructure: FirstProtocol, AnotherProtocol { // Structure Content } 

If the class has a parent class while following the protocol, the parent class name should be placed before the protocol name, separated by a comma.

class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol { // Content of Class } 

9.43.2. Provisions on attributes #

The protocol is used to specify specific instance or class properties, rather than specifying storage or computational properties. You must also specify whether it is read-only or read-and-write.

In protocols, variable properties are usually declared using var , followed by {set get} after type declaration to indicate that the property is readable and writable, while read-only properties are represented using {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 agreement" 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) 

The output of the above program execution is as follows:

98 true false Swift agreement Swift 

9.43.3. Yes Mutating provisions of the method #

Sometimes you need to change its instance in the method.

For example, in an instance method of a value type (structure, enumeration),set the mutating keyword as a prefix to the function, written in the func previously, indicates that the value of the instance to which it belongs and its instance properties can be modified in this method.

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 .thurs: self = .thurs print("Wednesday") case .fri: self = .fri print("Firday") case .sat: self = .sat print("Saturday") default: print("NO Such Day") } } } var res = days.wed res.show() 

The output of the above program execution is as follows:

Wednesday 

9.43.4. Requirements for constructors #

A protocol can require its followers to implement a specified constructor.

You can write the constructor declaration in the definition of the protocol,just as you would write a normal constructor, but you don’t need to write curly braces and constructor entities. The syntax is as follows:

protocol SomeProtocol { init(someParameter: Int) } 

9.43.5. Example #

protocol tcpprotocol { init(aprot: Int) } 

9.43.6. Implementation of protocol constructor specification in class #

You can implement a constructor in a class that follows the protocol and specify it as the specified constructor or convenience constructor for the class. In both cases, you must mark the constructor implementation with the “required” modifier:

class SomeClass: SomeProtocol { required init(someParameter: Int) { // Constructor implementation } } protocol tcpprotocol { init(aprot: Int) } class tcpClass: tcpprotocol { required init(aprot: Int) { } } 

Use required the modifier ensures that all subclasses that follow the protocol can also provide an explicit implementation or inheritance implementation for the constructor specification.

If a subclass overrides the specified constructor of the parent class, and the constructor follows the provisions of a protocol, then the implementation of the constructor needs to be marked at the same time required and override modifier:

protocol tcpprotocol { init(no1: Int) } class mainClass { var no1: Int // local variable init(no1: Int) { self.no1 = no1 // initialization } } class subClass: mainClass, tcpprotocol { var no2: Int init(no1: Int, no2 : Int) { self.no2 = no2 super.init(no1:no1) } // Because following the protocol requires the addition of "required"; Because it inherits from the parent class, "override" needs to be added 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)") 

The output of the above program execution is as follows:

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

9.43.7. Protocol Type #

Although the protocol itself does not implement any function, the protocol can be used as a type.

The protocol can be used like other common types, using scenarios:

• As a parameter type or return value type in a function, method, or constructor

• As a type of constant, variable, or attribute

• As an element type in an array, dictionary, or other container

9.43.8. Example #

protocol Generator { associatedtype members func next() -> members? } var items = [10,20,30].makeIterator() 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})) 

The output of the above program execution is as follows:

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

9.43.9. Add protocol members to the extension #

We can extend existing types (classes, structures, enumerations, etc.) through extensions.

Extensions can add properties, methods, subscript scripts, protocols, and other members to existing types.