Why protocol-oriented programming matters in Swift - See It in Action

Why protocol-oriented programming matters

📖 Scenario: Imagine you are building a simple app that manages different types of vehicles. Each vehicle can start and stop, but they do these actions differently. You want a clean way to organize this behavior so you can add more vehicle types easily in the future.

🎯 Goal: You will create a protocol to define common vehicle actions, then make different vehicle types conform to this protocol. This shows why protocol-oriented programming helps write flexible and reusable code.

📋 What You'll Learn

Create a protocol named Vehicle with two methods: start() and stop()

Create a struct called Car that conforms to Vehicle and implements start() and stop()

Create a struct called Bicycle that conforms to Vehicle and implements start() and stop()

Create an array called vehicles that holds both Car and Bicycle instances

Use a for loop to call start() on each vehicle in the vehicles array

Print output messages showing each vehicle starting and stopping

💡 Why This Matters

🌍 Real World

Protocol-oriented programming is used in Swift to write clean, reusable code that works well with many types. It helps apps stay organized and easy to extend.

💼 Career

Understanding protocols is essential for Swift developers. It is a core skill for building apps that are maintainable and scalable in professional iOS development.

1

Create the Vehicle protocol

Create a protocol named Vehicle with two methods: start() and stop().

Swift

# Define the Vehicle protocol with start() and stop() methods
// Your code here

Hint

Protocols define a blueprint of methods. Use protocol Vehicle {} and add func start() and func stop() inside.

2

Create Car and Bicycle structs conforming to Vehicle

Create a struct called Car that conforms to Vehicle and implements start() and stop(). Then create a struct called Bicycle that also conforms to Vehicle and implements start() and stop().

Swift

protocol Vehicle {
    func start()
    func stop()
}

// Create Car struct conforming to Vehicle
// Create Bicycle struct conforming to Vehicle
// Your code here

Hint

Use struct Car: Vehicle {} and implement the two methods with print statements. Do the same for Bicycle.

3

Create an array of vehicles

Create an array called vehicles that holds instances of Car and Bicycle.

Swift

protocol Vehicle {
    func start()
    func stop()
}

struct Car: Vehicle {
    func start() {
        print("Car is starting its engine.")
    }
    func stop() {
        print("Car has stopped.")
    }
}

struct Bicycle: Vehicle {
    func start() {
        print("Bicycle rider starts pedaling.")
    }
    func stop() {
        print("Bicycle has stopped.")
    }
}

// Create an array called vehicles with Car and Bicycle instances
// Your code here

Hint

Use let vehicles: [Vehicle] = [Car(), Bicycle()] to create the array.

4

Start all vehicles and print output

Use a for loop with variable vehicle to iterate over vehicles and call start() on each. Then print a message showing each vehicle started.

Swift

protocol Vehicle {
    func start()
    func stop()
}

struct Car: Vehicle {
    func start() {
        print("Car is starting its engine.")
    }
    func stop() {
        print("Car has stopped.")
    }
}

struct Bicycle: Vehicle {
    func start() {
        print("Bicycle rider starts pedaling.")
    }
    func stop() {
        print("Bicycle has stopped.")
    }
}

let vehicles: [Vehicle] = [Car(), Bicycle()]

// Use a for loop to call start() on each vehicle
// Your code here

Hint

Use for vehicle in vehicles { vehicle.start() } to call start on each vehicle.

Practice

1. What is the main purpose of protocols in Swift's protocol-oriented programming?

easy

A. To define a blueprint of methods and properties that a type must implement

B. To store data like variables and constants

C. To create user interfaces

D. To manage memory automatically

Solution

1. Step 1: Understand what protocols represent

   Protocols specify a set of methods and properties that a type must have, acting as a blueprint.

2. Step 2: Differentiate protocols from data storage

   Protocols do not store data themselves; they only define behavior and requirements.

3. Final Answer:

   To define a blueprint of methods and properties that a type must implement -> Option A

4. Quick Check:

   Protocols = Blueprint of behavior [OK]

Hint: Protocols define required behavior, not data storage [OK]

Common Mistakes:

• Thinking protocols store data
• Confusing protocols with classes or structs
• Assuming protocols manage memory

2. Which of the following is the correct syntax to declare a protocol named Drivable in Swift?

easy

A. struct Drivable { func drive() }

B. class Drivable { func drive() }

C. func protocol Drivable() { drive() }

D. protocol Drivable { func drive() }

Solution

1. Step 1: Recall protocol declaration syntax

   Protocols are declared using the keyword protocol followed by the name and curly braces.

2. Step 2: Identify correct method declaration inside protocol

   Inside protocols, methods are declared without implementation, just the signature.

3. Final Answer:

   protocol Drivable { func drive() } -> Option D

4. Quick Check:

   Use 'protocol' keyword and method signature [OK]

Hint: Protocols start with 'protocol' keyword, not class or struct [OK]

Common Mistakes:

• Using class or struct instead of protocol
• Trying to implement method inside protocol
• Incorrect keyword order

3. What will be the output of the following Swift code?

protocol Greetable {
    func greet() -> String
}

struct Person: Greetable {
    func greet() -> String {
        "Hello!"
    }
}

let p = Person()
print(p.greet())

medium

A. Error: Missing method implementation

B. greet()

C. Hello!

D. nil

Solution

1. Step 1: Check protocol and struct conformance

   The struct Person conforms to Greetable and implements greet() returning "Hello!".

2. Step 2: Understand the print statement output

   Calling p.greet() returns "Hello!", which is printed.

3. Final Answer:

   Hello! -> Option C

4. Quick Check:

   Protocol method implemented returns "Hello!" [OK]

Hint: Check if method returns a string and is called correctly [OK]

Common Mistakes:

• Assuming protocol methods print automatically
• Thinking missing implementation error occurs
• Confusing method name with output

4. Identify the error in this Swift code using protocol-oriented programming:

protocol Runnable {
    func run()
}

struct Athlete: Runnable {
    // Missing run() implementation
}

let athlete = Athlete()
athlete.run()

medium

A. Athlete struct must implement run() method

B. Protocol Runnable cannot be used with structs

C. run() method should return a value

D. Cannot create instance of Athlete

Solution

1. Step 1: Check protocol requirements

   The protocol Runnable requires a run() method to be implemented.

2. Step 2: Verify struct conformance

   The struct Athlete does not implement run(), so it does not conform properly.

3. Final Answer:

   Athlete struct must implement run() method -> Option A

4. Quick Check:

   Protocol methods must be implemented in conforming types [OK]

Hint: Check if all protocol methods are implemented in struct/class [OK]

Common Mistakes:

• Assuming protocols can't be used with structs
• Thinking run() must return a value
• Believing instance creation is the error

5. You want to create a reusable logging system in Swift using protocol-oriented programming. Which approach best supports easy reuse and maintenance?

hard

A. Use global variables to store logs

B. Define a protocol Loggable with a log() method, then extend it with default implementation

C. Write separate logging functions in each class without protocols

D. Create a base class Logger and inherit from it everywhere

Solution

1. Step 1: Understand protocol-oriented programming benefits

   Protocols with default implementations allow behavior sharing without inheritance.

2. Step 2: Evaluate options for reuse and maintenance

   Extending a protocol with default log() method lets many types reuse logging easily and maintain code in one place.

3. Final Answer:

   Define a protocol Loggable with a log() method, then extend it with default implementation -> Option B

4. Quick Check:

   Protocols + extensions = reusable, maintainable code [OK]

Hint: Use protocol with default methods for reusable behavior [OK]

Common Mistakes:

• Relying on inheritance instead of protocols
• Duplicating code in each class
• Using global variables for behavior