POP vs OOP decision patterns in Swift

Introduction

We use POP (Protocol-Oriented Programming) and OOP (Object-Oriented Programming) to organize code in ways that make it easier to build and change apps.

When you want to share behavior between different types without forcing a class hierarchy.

When you need to model real-world objects with clear relationships and inheritance.

When you want to write flexible and reusable code using protocols and extensions.

When you want to use classes with inheritance and reference semantics.

When you want to decide the best way to structure your Swift code for clarity and maintenance.

Syntax

Swift

protocol SomeProtocol {
    func doSomething()
}

class SomeClass: SomeProtocol {
    func doSomething() {
        print("Doing something")
    }
}

POP uses protocol to define blueprints for methods and properties.

OOP uses class to create objects with inheritance and shared behavior.

Examples

This shows POP: a protocol Drivable and a struct Car that follows it.

Swift

protocol Drivable {
    func drive()
}

struct Car: Drivable {
    func drive() {
        print("Car is driving")
    }
}

This shows OOP: a base class Vehicle and a subclass Bike that changes behavior.

Swift

class Vehicle {
    func drive() {
        print("Vehicle is driving")
    }
}

class Bike: Vehicle {
    override func drive() {
        print("Bike is driving")
    }
}

Sample Program

This program shows both POP and OOP using the same protocol Flyer. A struct Bird and a class Airplane both implement fly(). The function letItFly accepts anything that can fly.

Swift

protocol Flyer {
    func fly()
}

struct Bird: Flyer {
    func fly() {
        print("Bird is flying")
    }
}

class Airplane: Flyer {
    func fly() {
        print("Airplane is flying")
    }
}

func letItFly(_ flyer: Flyer) {
    flyer.fly()
}

let sparrow = Bird()
let boeing = Airplane()

letItFly(sparrow)
letItFly(boeing)

Important Notes

POP encourages using protocols and structs for safer, value-based code.

OOP uses classes and inheritance, which can be easier to understand for some real-world models.

Swift supports both, so choose based on your app's needs and code clarity.

Summary

POP uses protocols to define behavior and structs or classes to implement it.

OOP uses classes and inheritance to share and override behavior.

Decide between POP and OOP by thinking about flexibility, code reuse, and how your data should behave.