Protocols | Structs And Classes

What is a Protocol?

In Swift, a protocol is a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality. Protocols can be adopted by classes, structures, and enumerations to provide an actual implementation of these requirements.

Defining a Protocol

To define a protocol, you use the protocol keyword followed by the protocol name and a set of requirements.

Example of a Protocol Definition:


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

In this example, the Vehicle protocol requires any conforming type to have a property numberOfWheels and a method drive().

Adopting a Protocol

Classes, structs, or enums can adopt a protocol and provide actual implementations of the required properties and methods.

Example of a Class Adopting a Protocol:


                        class Car: Vehicle {
                            var numberOfWheels: Int {
                                return 4
                            }
                            func drive() {
                                print("The car is driving.")
                            }
                        }

In this example, the Car class conforms to the Vehicle protocol by providing the required property and method implementations.

Using Protocols

Once you have defined a protocol and have a class or struct that conforms to it, you can create instances of that class or struct and use them as you would any other type.

Example of Using a Protocol:


                        let myCar = Car()
                        print("My car has \(myCar.numberOfWheels) wheels.")
                        myCar.drive()

Output: My car has 4 wheels.
The car is driving.

Protocol Inheritance

Protocols can inherit from other protocols. This means that a protocol can require conforming types to implement additional methods or properties from other protocols.

Example of Protocol Inheritance:


                        protocol ElectricVehicle: Vehicle {
                            var batteryLevel: Int { get }
                            func charge()
                        }

Here, ElectricVehicle inherits from the Vehicle protocol and adds its own requirements.

Conclusion

Protocols in Swift are a powerful way to define a contract for your types. They allow for code reuse and make it easier to write flexible and maintainable code. By adhering to protocols, you can create a consistent interface for various types while maintaining the unique capabilities of each type.