Protocol Inheritance in Swift 🎯

Welcome to our deep dive into Protocol Inheritance in Swift! In this tutorial, we'll explore how to create and use protocols, and learn about protocol inheritance which allows us to build complex and modular Swift code. Let's get started!

What is a Protocol? 📝

A protocol in Swift is a blueprint that defines a set of methods, properties, and other requirements that suit a particular task or piece of functionality. Protocols allow us to define a common interface for any number of classes, structures, and enumerations, promoting code reusability and modularity.

Creating a Protocol 💡

To create a protocol, simply use the protocol keyword, followed by the protocol name and curly braces {}. Within the braces, define the required methods, properties, and other protocol requirements.

swift

protocol MyProtocol {
    var myProperty: String { get set }
    func myMethod() -> String
}

In the above example, we've created a simple protocol named MyProtocol with a get and set property called myProperty and a method called myMethod().

Adopting a Protocol 💡

To adopt a protocol, a class, structure, or enumeration uses the : symbol followed by the protocol name. The adopting type must then implement all required methods and properties defined in the protocol.

swift

struct MyStruct: MyProtocol {
    var myProperty: String

    func myMethod() -> String {
        return "Hello from MyStruct"
    }
}

In this example, we've created a structure called MyStruct that adopts MyProtocol. We've implemented the myProperty and myMethod() requirements from the protocol.

Protocol Inheritance 💡

Protocol inheritance allows us to create a hierarchy of protocols, much like class inheritance. A child protocol can extend a parent protocol by adopting it and adding additional requirements.

swift

protocol ParentProtocol {
    var parentProperty: String { get set }
    func parentMethod() -> String
}

protocol ChildProtocol: ParentProtocol {
    var childProperty: String { get set }
    func childMethod() -> String
}

In the above example, we've created a ParentProtocol and a ChildProtocol that extends it. ChildProtocol inherits all the requirements from ParentProtocol and adds an additional property and method.

Using Protocol Inheritance 💡

To use protocol inheritance, a type can adopt both the parent and child protocols and implement all required methods and properties from both.

swift

struct MyStruct: ParentProtocol, ChildProtocol {
    var parentProperty: String = "Parent Property"
    var childProperty: String = "Child Property"

    func parentMethod() -> String {
        return "Parent Method"
    }

    func childMethod() -> String {
        return "Child Method"
    }
}

In this example, we've created a MyStruct that adopts both ParentProtocol and ChildProtocol. We've implemented all the required methods and properties from both protocols.

Practical Example 💡

Let's consider a simple example where we have a Vehicle protocol with common requirements like speed, accelerate(), and brake() methods. We then create a Car and Bicycle types that adopt the Vehicle protocol and provide their own implementations for the methods.

swift

protocol Vehicle {
    var speed: Double { get set }
    func accelerate()
    func brake()
}

struct Car: Vehicle {
    var speed: Double = 0.0

    func accelerate() {
        speed += 10.0
        print("Car is accelerating. Speed is now \(speed) mph.")
    }

    func brake() {
        speed -= 5.0
        print("Car is braking. Speed is now \(speed) mph.")
    }
}

struct Bicycle: Vehicle {
    var speed: Double = 0.0

    func accelerate() {
        speed += 2.0
        print("Bicycle is accelerating. Speed is now \(speed) mph.")
    }

    func brake() {
        speed -= 1.0
        print("Bicycle is braking. Speed is now \(speed) mph.")
    }
}

In this example, we've created a Vehicle protocol with common requirements for cars and bicycles. We then created a Car and Bicycle types that adopt the Vehicle protocol and provide their own implementations for the accelerate() and brake() methods, taking advantage of protocol inheritance.