The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Protocols

Next ►
►

Protocols are a fundamental part of Swift programming, providing a blueprint for methods, properties, and other requirements that suit a particular task or piece of functionality. Classes, structures, and enumerations can adopt protocols to provide actual implementations of those requirements. Any type that satisfies the requirements of a protocol is said to conform to that protocol.

Key Concepts

  1. Defining a Protocol
  2. Adopting and Conforming to a Protocol
  3. Protocol Inheritance
  4. Protocol Composition
  5. Optional Protocol Requirements
  6. Protocol Extensions

  1. Defining a Protocol

A protocol is defined using the protocol keyword followed by the protocol's name and a set of requirements.

protocol SomeProtocol {
    var mustBeSettable: Int { get set }
    var doesNotNeedToBeSettable: Int { get }
    func someMethod()
    init(someParameter: Int)
}

Explanation:

  • var mustBeSettable: Int { get set }: A property that must be both readable and writable.
  • var doesNotNeedToBeSettable: Int { get }: A property that is only readable.
  • func someMethod(): A method that must be implemented.
  • init(someParameter: Int): An initializer that must be implemented.

  1. Adopting and Conforming to a Protocol

A class, structure, or enumeration can adopt a protocol by listing the protocol's name after the type's name, separated by a colon. The type must then provide implementations for all of the protocol's requirements.

class SomeClass: SomeProtocol {
    var mustBeSettable: Int
    var doesNotNeedToBeSettable: Int
    
    required init(someParameter: Int) {
        self.mustBeSettable = someParameter
        self.doesNotNeedToBeSettable = someParameter
    }
    
    func someMethod() {
        print("Method implemented")
    }
}

Explanation:

  • required init(someParameter: Int): The required keyword ensures that this initializer is implemented by all subclasses.
  • The class SomeClass provides implementations for all properties and methods defined in SomeProtocol.

  1. Protocol Inheritance

A protocol can inherit one or more other protocols and can add further requirements on top of the requirements it inherits.

protocol AnotherProtocol: SomeProtocol {
    func anotherMethod()
}

Explanation:

  • AnotherProtocol inherits from SomeProtocol and adds an additional method requirement.

  1. Protocol Composition

You can combine multiple protocols into a single requirement using protocol composition.

protocol ProtocolA {
    func methodA()
}

protocol ProtocolB {
    func methodB()
}

struct ConformingType: ProtocolA, ProtocolB {
    func methodA() {
        print("Method A")
    }
    
    func methodB() {
        print("Method B")
    }
}

func someFunction(conformingInstance: ProtocolA & ProtocolB) {
    conformingInstance.methodA()
    conformingInstance.methodB()
}

Explanation:

  • ProtocolA & ProtocolB specifies that the parameter must conform to both ProtocolA and ProtocolB.

  1. Optional Protocol Requirements

Protocols can define optional requirements using the @objc attribute. This is typically used in conjunction with Objective-C interoperability.

@objc protocol OptionalProtocol {
    @objc optional func optionalMethod()
}

class SomeClass: OptionalProtocol {
    func optionalMethod() {
        print("Optional method implemented")
    }
}

Explanation:

  • @objc and @objc optional are used to define optional requirements.
  • The class SomeClass optionally implements optionalMethod.

  1. Protocol Extensions

Protocol extensions allow you to provide default implementations for any method or computed property requirement of that protocol.

protocol Greetable {
    func greet()
}

extension Greetable {
    func greet() {
        print("Hello!")
    }
}

struct Greeter: Greetable {}

let greeter = Greeter()
greeter.greet() // Prints "Hello!"

Explanation:

  • The Greetable protocol defines a greet method.
  • The extension provides a default implementation of greet.
  • The Greeter struct conforms to Greetable and uses the default implementation.

Practical Exercises

Exercise 1: Define and Conform to a Protocol

Task: Define a protocol Vehicle with properties numberOfWheels and color, and a method drive(). Create a class Car that conforms to this protocol.

Solution:

protocol Vehicle {
    var numberOfWheels: Int { get }
    var color: String { get set }
    func drive()
}

class Car: Vehicle {
    var numberOfWheels: Int
    var color: String
    
    init(numberOfWheels: Int, color: String) {
        self.numberOfWheels = numberOfWheels
        self.color = color
    }
    
    func drive() {
        print("Driving a \(color) car with \(numberOfWheels) wheels.")
    }
}

let myCar = Car(numberOfWheels: 4, color: "red")
myCar.drive() // Prints "Driving a red car with 4 wheels."

Exercise 2: Protocol Inheritance and Composition

Task: Define a protocol ElectricVehicle that inherits from Vehicle and adds a property batteryLevel. Create a class ElectricCar that conforms to ElectricVehicle.

Solution:

protocol ElectricVehicle: Vehicle {
    var batteryLevel: Int { get set }
}

class ElectricCar: ElectricVehicle {
    var numberOfWheels: Int
    var color: String
    var batteryLevel: Int
    
    init(numberOfWheels: Int, color: String, batteryLevel: Int) {
        self.numberOfWheels = numberOfWheels
        self.color = color
        self.batteryLevel = batteryLevel
    }
    
    func drive() {
        print("Driving a \(color) electric car with \(numberOfWheels) wheels and \(batteryLevel)% battery.")
    }
}

let myElectricCar = ElectricCar(numberOfWheels: 4, color: "blue", batteryLevel: 85)
myElectricCar.drive() // Prints "Driving a blue electric car with 4 wheels and 85% battery."

Conclusion

Protocols in Swift are a powerful way to define blueprints for methods, properties, and other requirements. They enable a flexible and reusable code structure by allowing different types to conform to the same set of requirements. Understanding and effectively using protocols is essential for mastering Swift programming, especially when working with complex and scalable applications. In the next module, we will delve into extensions, which further enhance the capabilities of protocols and other types in Swift.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved