POP vs OOP decision patterns in Swift - Hands-On Comparison

POP vs OOP Decision Patterns in Swift

📖 Scenario: You are building a simple app to manage different types of vehicles. Each vehicle can start and stop, but some vehicles have special features like flying or floating. You want to decide whether to use Protocol-Oriented Programming (POP) or Object-Oriented Programming (OOP) to organize your code.

🎯 Goal: Learn how to create vehicle types using both POP and OOP patterns in Swift. You will define protocols and classes, then decide which approach fits best for adding new vehicle behaviors.

📋 What You'll Learn

Create a protocol called Vehicle with start() and stop() methods

Create a class called Car that conforms to Vehicle and implements the methods

Create a protocol called Flyable with a fly() method

Create a struct called FlyingCar that conforms to Vehicle and Flyable

Print outputs showing how Car and FlyingCar behave

💡 Why This Matters

🌍 Real World

Many apps need to model real-world objects with shared and unique behaviors. Choosing between OOP and POP helps organize code for easier maintenance and extension.

💼 Career

Understanding POP and OOP decision patterns is important for Swift developers to write clean, reusable, and scalable code in iOS and macOS app development.

1

Define the Vehicle protocol

Create a protocol called Vehicle with two methods: start() and stop(). Both methods should not take any parameters and return nothing.

Swift

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

Need a hint?

Protocols define a blueprint of methods. Use protocol Vehicle {} and add the two method signatures inside.

2

Create the Car class conforming to Vehicle

Create a class called Car that conforms to the Vehicle protocol. Implement the start() method to print "Car started" and the stop() method to print "Car stopped".

Swift

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

// Create Car class conforming to Vehicle
# Your code here

Need a hint?

Use class Car: Vehicle and implement the two methods with print statements.

3

Define Flyable protocol and FlyingCar struct

Create a protocol called Flyable with a method fly() that returns nothing. Then create a struct called FlyingCar that conforms to both Vehicle and Flyable. Implement start() to print "FlyingCar started", stop() to print "FlyingCar stopped", and fly() to print "FlyingCar is flying".

Swift

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

class Car: Vehicle {
    func start() {
        print("Car started")
    }
    func stop() {
        print("Car stopped")
    }
}

// Define Flyable protocol and FlyingCar struct
# Your code here

Need a hint?

Protocols can be combined. Use struct FlyingCar: Vehicle, Flyable and implement all required methods with print statements.

4

Create instances and print behaviors

Create an instance called myCar of type Car and an instance called myFlyingCar of type FlyingCar. Call start() and stop() on myCar. Call start(), fly(), and stop() on myFlyingCar. Print the outputs.

Swift

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

class Car: Vehicle {
    func start() {
        print("Car started")
    }
    func stop() {
        print("Car stopped")
    }
}

protocol Flyable {
    func fly()
}

struct FlyingCar: Vehicle, Flyable {
    func start() {
        print("FlyingCar started")
    }
    func stop() {
        print("FlyingCar stopped")
    }
    func fly() {
        print("FlyingCar is flying")
    }
}

// Create instances and call methods
# Your code here

Need a hint?

Create instances with let and call the methods in order. The output should show the correct messages.