Object-Oriented Programming 🏗️

// A STRUCT is a VALUE type. Assigning it makes an independent COPY.
struct Point {
    var x: Int
    var y: Int
}

var pointA = Point(x: 3, y: 5)
var pointB = pointA        // pointB is a separate COPY of pointA
pointB.x = 99              // change the copy only

print("pointA = (\(pointA.x), \(pointA.y))")   // (3, 5)  — untouched
print("pointB = (\(pointB.x), \(pointB.y))")   // (99, 5) — copy changed

// A CLASS is a REFERENCE type. Assigning it SHARES the same object.
class Counter {
    var value: Int
    init(value: Int) {     // an initialiser sets up a new instance
        self.value = value // self.value = the property; value = the argument
    }
}

let counterA = Counter(value: 0)
let counterB = counterA    // counterB points to the SAME object as counterA
counterB.value = 99        // there is only one object, so both "see" it

print("counterA.value = \(counterA.value)")     // 99 — same object!
print("counterB.value = \(counterB.value)")     // 99

pointA = (3, 5)
pointB = (99, 5)
counterA.value = 99
counterB.value = 99

struct Temperature {
    // STORED property — holds a value in memory.
    var celsius: Double {
        // PROPERTY OBSERVER — didSet runs every time celsius changes.
        didSet {
            print("Temp changed: \(oldValue)°C -> \(celsius)°C")
        }
    }

    // COMPUTED property — no storage; it calculates on every read.
    var fahrenheit: Double {
        celsius * 9 / 5 + 32
    }
}

var temp = Temperature(celsius: 20)
print("Start: \(temp.celsius)°C = \(temp.fahrenheit)°F")  // 20.0 = 68.0
temp.celsius = 100         // didSet fires here
print("Now:   \(temp.celsius)°C = \(temp.fahrenheit)°F")  // 100.0 = 212.0

Start: 20.0°C = 68.0°F
Temp changed: 20.0°C -> 100.0°C
Now:   100.0°C = 212.0°F

// A base class with stored properties and methods.
class Animal {
    let name: String
    init(name: String) {       // required initialiser — every Animal has a name
        self.name = name
    }
    func speak() -> String {
        "\(name) makes a sound"
    }
}

// Dog INHERITS from Animal (single inheritance with a colon).
class Dog: Animal {
    let breed: String
    init(name: String, breed: String) {
        self.breed = breed
        super.init(name: name)  // call the parent's initialiser
    }
    // OVERRIDE replaces the inherited method. The keyword is required.
    override func speak() -> String {
        "\(name) the \(breed) says Woof!"
    }
}

let generic = Animal(name: "Creature")
let rex = Dog(name: "Rex", breed: "Corgi")
print(generic.speak())     // Creature makes a sound
print(rex.speak())         // Rex the Corgi says Woof!  (overridden)
print("Rex is still an Animal: \(rex is Animal)")   // true

Creature makes a sound
Rex the Corgi says Woof!
Rex is still an Animal: true

// A PROTOCOL is a contract: WHAT a type must do, not HOW.
protocol Shape {
    var name: String { get }       // conformers must provide a name
    func area() -> Double          // ...and an area() method
}

// A protocol EXTENSION gives every conformer a default method for free.
extension Shape {
    func describe() -> String {
        "\(name) has area \(area())"
    }
}

// A STRUCT can conform to a protocol (so can a class or enum).
struct Square: Shape {
    let side: Double
    let name = "Square"
    func area() -> Double { side * side }
}

struct Circle: Shape {
    let radius: Double
    let name = "Circle"
    func area() -> Double { (radius * radius * 3.14 * 100).rounded() / 100 }
}

// Protocol-oriented programming: code to the protocol, not the type.
let shapes: [Shape] = [Square(side: 4), Circle(radius: 2)]
for shape in shapes {
    print(shape.describe())        // uses the default describe()
}

Square has area 16.0
Circle has area 12.56