Protocol inheritance in Swift - Mini Project: Build & Apply

Protocol inheritance

📖 Scenario: Imagine you are designing a simple app to manage different types of vehicles. Some vehicles can be driven, some can fly, and some can do both. You want to organize these capabilities using Swift protocols.

🎯 Goal: You will create protocols to represent different vehicle capabilities and use protocol inheritance to combine them. Then, you will create a struct that conforms to the combined protocol and print its capabilities.

📋 What You'll Learn

Create a protocol called Drivable with a method drive() that prints "Driving on the road".

Create a protocol called Flyable with a method fly() that prints "Flying in the sky".

Create a protocol called Vehicle that inherits from both Drivable and Flyable.

Create a struct called FlyingCar that conforms to Vehicle and implements both drive() and fly() methods.

Create an instance of FlyingCar and call both drive() and fly() methods.

💡 Why This Matters

🌍 Real World

Using protocol inheritance helps organize related capabilities in apps that manage different types of objects, like vehicles with multiple functions.

💼 Career

Understanding protocol inheritance is important for Swift developers to write clean, reusable, and scalable code in iOS app development.

1

Create the base protocols

Create a protocol called Drivable with a method drive() that prints "Driving on the road". Also create a protocol called Flyable with a method fly() that prints "Flying in the sky".

Swift

# Create protocol Drivable with method drive() that prints "Driving on the road"
# Create protocol Flyable with method fly() that prints "Flying in the sky"

Hint

Protocols define methods without implementation. You will add the print statements when you implement these methods in a struct.

2

Create a protocol that inherits from both

Create a protocol called Vehicle that inherits from both Drivable and Flyable.

Swift

protocol Drivable {
    func drive()
}

protocol Flyable {
    func fly()
}

# Create protocol Vehicle that inherits from Drivable and Flyable

Hint

Use a colon and list the protocols separated by commas to inherit multiple protocols.

3

Create a struct that conforms to Vehicle

Create a struct called FlyingCar that conforms to Vehicle. Implement the drive() method to print "Driving on the road" and the fly() method to print "Flying in the sky".

Swift

protocol Drivable {
    func drive()
}

protocol Flyable {
    func fly()
}

protocol Vehicle: Drivable, Flyable {
}

# Create struct FlyingCar that conforms to Vehicle
# Implement drive() and fly() methods with print statements

Hint

Implement both methods inside the struct with the exact print statements.

4

Create an instance and call the methods

Create an instance of FlyingCar called myFlyingCar. Call the drive() method and then the fly() method on myFlyingCar.

Swift

protocol Drivable {
    func drive()
}

protocol Flyable {
    func fly()
}

protocol Vehicle: Drivable, Flyable {
}

struct FlyingCar: Vehicle {
    func drive() {
        print("Driving on the road")
    }
    func fly() {
        print("Flying in the sky")
    }
}

# Create instance myFlyingCar of FlyingCar
# Call drive() and fly() methods on myFlyingCar

Hint

Remember to create the instance with let and call the methods with dot notation.

Practice

1. What does protocol inheritance in Swift allow you to do?

easy

A. Create instances of protocols directly

B. Inherit properties and methods from a class

C. Override methods in a protocol

D. Create a new protocol that includes requirements from one or more existing protocols

Solution

1. Step 1: Understand protocol inheritance concept

   Protocol inheritance lets you build new protocols by combining existing ones, so the new protocol requires all combined features.

2. Step 2: Compare options with concept

   Only Create a new protocol that includes requirements from one or more existing protocols correctly describes creating a new protocol that inherits requirements from existing protocols.

3. Final Answer:

   Create a new protocol that includes requirements from one or more existing protocols -> Option D

4. Quick Check:

   Protocol inheritance = create combined protocols [OK]

Hint: Protocol inheritance combines requirements from multiple protocols [OK]

Common Mistakes:

• Confusing protocol inheritance with class inheritance
• Thinking protocols can be instantiated
• Believing protocols can override methods

2. Which of the following is the correct syntax to declare a protocol AdvancedProtocol that inherits from BasicProtocol in Swift?

easy

A. protocol AdvancedProtocol: BasicProtocol {}

B. protocol AdvancedProtocol inherits BasicProtocol {}

C. protocol AdvancedProtocol extends BasicProtocol {}

D. protocol AdvancedProtocol implements BasicProtocol {}

Solution

1. Step 1: Recall Swift protocol inheritance syntax

   In Swift, a protocol inherits from another by listing the parent protocol after a colon (:).

2. Step 2: Match syntax with options

   Only protocol AdvancedProtocol: BasicProtocol {} uses the correct syntax: protocol NewProtocol: ExistingProtocol {}.

3. Final Answer:

   protocol AdvancedProtocol: BasicProtocol {} -> Option A

4. Quick Check:

   Protocol inheritance syntax uses colon (:) [OK]

Hint: Use colon (:) to inherit protocols in Swift [OK]

Common Mistakes:

• Using 'inherits' or 'extends' keywords which are invalid in Swift
• Using 'implements' keyword which is for classes, not protocols
• Missing the colon between protocol names

3. Given the following code, what will be the output when example.printInfo() is called?

protocol A {
    func printInfo()
}
protocol B: A {
    func printExtra()
}
class Example: B {
    func printInfo() {
        print("Info from A")
    }
    func printExtra() {
        print("Extra from B")
    }
}
let example = Example()
example.printInfo()

medium

A. Info from A

B. Extra from B

C. No output, compile error

D. Info from A\nExtra from B

Solution

1. Step 1: Understand protocol inheritance and class conformance

   Protocol B inherits from A, so class Example must implement both printInfo() and printExtra(). It does.

2. Step 2: Identify which method is called

   The code calls example.printInfo(), which prints "Info from A".

3. Final Answer:

   Info from A -> Option A

4. Quick Check:

   Calling printInfo() prints "Info from A" [OK]

Hint: Match called method to implemented function output [OK]

Common Mistakes:

• Confusing which method is called
• Expecting both methods to print automatically
• Thinking protocol inheritance affects method output

4. What is wrong with the following Swift code?

protocol P1 {
    func method1()
}
protocol P2: P1 {
    func method2()
}
class MyClass: P2 {
    func method2() {
        print("Method 2")
    }
}

medium

A. P2 cannot inherit from P1

B. method2() should not be implemented in MyClass

C. MyClass must implement method1() because P2 inherits from P1

D. MyClass should be a protocol, not a class

Solution

1. Step 1: Analyze protocol inheritance and class conformance

   Protocol P2 inherits from P1, so any class conforming to P2 must implement all methods from P1 and P2.

2. Step 2: Check implemented methods in MyClass

   MyClass implements only method2() but misses method1(), causing a compile error.

3. Final Answer:

   MyClass must implement method1() because P2 inherits from P1 -> Option C

4. Quick Check:

   Inherited protocol methods must be implemented [OK]

Hint: Implement all inherited protocol methods in conforming class [OK]

Common Mistakes:

• Ignoring inherited protocol requirements
• Thinking only new protocol methods must be implemented
• Confusing class and protocol roles

5. You have two protocols:

protocol Vehicle {
    func start()
}
protocol ElectricVehicle: Vehicle {
    func charge()
}

You want to create a class ElectricCar that conforms to ElectricVehicle. Which implementation correctly satisfies all protocol requirements?

hard

A. class ElectricCar: ElectricVehicle {
func start() { print("Starting") }
}

B. class ElectricCar: ElectricVehicle {
func start() { print("Starting") }
func charge() { print("Charging") }
}

C. class ElectricCar: Vehicle {
func charge() { print("Charging") }
}

D. class ElectricCar: ElectricVehicle {
func charge() { print("Charging") }
}

Solution

1. Step 1: Understand protocol inheritance requirements

   ElectricVehicle inherits from Vehicle, so conforming types must implement both start() and charge().

2. Step 2: Check each class implementation

   class ElectricCar: ElectricVehicle { func start() { print("Starting") } func charge() { print("Charging") } } implements both methods, fulfilling all requirements. Options B and D miss charge() or start(). class ElectricCar: Vehicle { func charge() { print("Charging") } } does not conform to ElectricVehicle.

3. Final Answer:

   class ElectricCar: ElectricVehicle { func start() { print("Starting") } func charge() { print("Charging") } } -> Option B

4. Quick Check:

   Implement all inherited protocol methods in class [OK]

Hint: Implement all methods from inherited protocols in your class [OK]

Common Mistakes:

• Implementing only one protocol method
• Conforming to wrong protocol
• Missing methods from inherited protocols