Swift Protocols vs Inheritance: A Comparison for New Developers

In Swift programming, understanding the distinction between protocol and inheritance is crucial for building robust and maintainable applications.

This blog delves deep into the nuances of Swift protocol vs inheritance, providing you with the knowledge to make informed architectural decisions in your projects.

Understanding Swift Protocols

Protocols in Swift are powerful tools that define a blueprint of methods, properties, and other requirements for tasks or functionalities. They enable you to create protocols that multiple types can conform to, ensuring consistency and flexibility in your codebase.

Defining Protocols

A protocol defines a set of methods and properties that a conforming type must implement. Unlike classes, protocols do not provide implementations but instead specify what needs to be implemented.

Copy
1protocol Drawable {
2    var color: String { get set }
3    func draw()
4}

Protocol Inheritance

Protocol inheritance allows a protocol to inherit from one or more parent protocols. This enables you to build more complex protocols by combining existing ones, enhancing code reuse and modularity.

Copy
1protocol Shape: Drawable {
2    var area: Double { get }
3}

In this example, Shape inherits from Drawable, meaning any type conforming to Shape must also conform to Drawable.

Protocol Extension and Default Implementation

Swift's protocol extension feature allows you to provide default implementations for protocol methods. This means that conforming types can use these defaults or provide their implementations.

Copy
1extension Drawable {
2    func draw() {
3        print("Drawing with color \(color)")
4    }
5}

By providing a default implementation, you reduce the burden on conforming types to implement every method, promoting cleaner and more maintainable code.

Understanding Inheritance in Swift

In object-oriented programming, inheritance refers to the ability of a class to inherit attributes and methods from its parent class. Swift supports class inheritance, enabling you to create a hierarchical relationship between classes.

Class Inheritance

With class inheritance, a subclass inherits all the characteristics of its superclass, allowing for code reuse and the extension of existing functionality.

Copy
1class Vehicle {
2    var speed: Int = 0
3
4    func accelerate() {
5        speed += 10
6    }
7}
8
9class Car: Vehicle {
10    var brand: String
11
12    init(brand: String) {
13        self.brand = brand
14    }
15
16    override func accelerate() {
17        super.accelerate()
18        print("\(brand) car accelerated to \(speed) km/h")
19    }
20}

In this example, Car inherits from Vehicle, gaining access to its properties and methods while also creating its own.

Single vs Multiple Inheritance

Swift supports single inheritance, meaning a class can inherit from only one superclass. Unlike some other languages, Swift does not support multiple inheritance for classes to prevent complexity and ambiguity.

However, you can achieve similar functionality by conforming to multiple protocols, allowing a type to adopt behaviors from various sources without the complications of multiple inheritance.

Protocols vs Inheritance: Key Differences

While both protocols and inheritance enable code reuse and the establishment of relationships between types, they serve different purposes and offer distinct advantages.

• Flexibility: Protocols allow for more flexible designs by enabling types to conform to multiple protocols simultaneously. In contrast, inheritance is limited to a single superclass.

• Decoupling: Protocols promote decoupled architectures, adhering to the interface segregation principle, whereas inheritance can lead to tightly coupled code.

• Default Implementations: Through protocol extensions, you can provide default implementations, which is not inherently possible with class inheritance.

When to Use Protocols Over Inheritance

Choosing between protocols and inheritance depends on the specific requirements of your project. Here are scenarios where protocols might be the better choice:

• Multiple Behaviors: When a type needs to adopt multiple behaviors or functionalities, multiple protocols offer a clean solution.

• Flexibility and Scalability: Protocols provide greater flexibility, making it easier to scale and maintain your codebase.

• Adhering to Design Principles: Utilizing protocols aligns with the interface segregation principle, promoting more modular and testable code.

Best Practices and Design Principles

Adhering to best practices ensures that your use of protocols and inheritance leads to maintainable and scalable code.

Interface Segregation Principle

The interface segregation principle advocates for creating small, focused protocols rather than large, monolithic ones. This encourages creating protocols that are specific to certain functionalities, enhancing code clarity and reusability.

Copy
1protocol Flyable {
2    func fly()
3}
4
5protocol Swimmable {
6    func swim()
7}
8
9class Duck: Flyable, Swimmable {
10    func fly() {
11        print("Duck is flying")
12    }
13
14    func swim() {
15        print("Duck is swimming")
16    }
17}

In this example, Duck conforms to both Flyable and Swimmable, each defining distinct behaviors.

Practical Examples

Understanding theoretical concepts is essential, but seeing them in action solidifies your comprehension. Below are practical examples illustrating the use of protocols and inheritance in Swift.

Using Multiple Protocols

By conforming to multiple protocols, you can compose complex behaviors in a type without the constraints of single inheritance.

Copy
1protocol Printable {
2    func printDetails()
3}
4
5protocol Serializable {
6    func serialize() -> Data
7}
8
9class Report: Printable, Serializable {
10    var title: String
11
12    init(title: String) {
13        self.title = title
14    }
15
16    func printDetails() {
17        print("Report Title: \(title)")
18    }
19
20    func serialize() -> Data {
21        return Data(title.utf8)
22    }
23}

Here, Report conforms to both Printable and Serializable, adopting functionalities from both protocols.

Combining Protocols with Class Inheritance

Sometimes, the best solution involves combining protocols with inheritance to leverage the strengths of both approaches.

Copy
1protocol Drivable {
2    func drive()
3}
4
5class Vehicle {
6    var speed: Int = 0
7
8    func accelerate() {
9        speed += 10
10    }
11}
12
13class Truck: Vehicle, Drivable {
14    func drive() {
15        print("Truck is driving at \(speed) km/h")
16    }
17}

In this example, Truck inherits from Vehicle and conforms to Drivable, combining class inheritance with protocol adherence.

Wrapping Up!

In this article, we explored the intricacies of Swift protocol vs. inheritance, highlighting how protocols offer flexibility through protocol inheritance, protocol extensions, and the ability to conform to multiple protocols. We contrasted this with class inheritance, which provides a straightforward mechanism for code reuse and hierarchical structuring but is limited by single inheritance constraints.

The main takeaway is that leveraging protocols can lead to more modular and maintainable code, especially when adhering to design principles like the interface segregation principle. Conversely, class inheritance remains valuable for scenarios requiring a clear superclass-subclass relationship. By understanding the strengths and appropriate use cases of both approaches, you can architect robust and scalable Swift applications effectively.