Wat zijn de principes van objectgeoriënteerd…

Principes van OOP:

Encapsulatie: Het samenvoegen van gegevens (eigenschappen) en methoden die met deze gegevens werken in één object en het verbergen van de interne implementatie voor de buitenwereld. Toegang tot de gegevens gebeurt via specifieke openbare interfaces (methoden).

// Verbergen van de interne implementatie van de eigenschap balance
class Account {
    private var balance: Double = 0.0

    func deposit(amount: Double) {
        if amount > 0 {
            balance += amount
        }

    }

    func getBalance() -> Double {
        return balance
    }
}

Erfelijkheid: Mechanisme dat het mogelijk maakt om een nieuwe klasse (afgeleid) te maken op basis van een bestaande klasse (oorspronkelijk), waarbij de eigenschappen en methoden worden geërfd. Dit bevordert hergebruik van code.

// Klassen Dog en Cat erven de eigenschappen en methoden van de klasse Animal
class Animal {
    let name: String

    init(name: String) {
        self.name = name
    }

    func makeSound() {
        print("\(name) maakt geluid")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("\(name) blaft")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("\(name) miauwt")
    }
}

Polymorfisme: Vermogen van objecten van verschillende klassen om op dezelfde boodschap (methode-aanroep) op verschillende manieren te reageren, afhankelijk van hun type.

// Verschillende implementaties van de methode makeSound() in de klassen Dog en Cat
func playSound(of animal: Animal) {
    animal.makeSound() // Polymorfe aanroep
}

let myDog = Dog(name: "Bobby")
let myCat = Cat(name: "Murka")

playSound(of: myDog) // Zal "Bobby blaft" afdrukken
playSound(of: myCat) // Zal "Murka miauwt" afdrukken

Abstractie: Het benadrukken van de essentiële kenmerken van een object en het negeren van niet-essentiële. Het creëren van algemene representaties van objecten.

// Weergave van een geometrische figuur zonder concrete implementatie
protocol Shape {
    func calculateArea() -> Double
    func calculatePerimeter() -> Double
}

// Concrete implementaties voor cirkel en vierkant
struct Circle: Shape {
    let radius: Double

    func calculateArea() -> Double {
        return Double.pi * radius * radius
    }

    func calculatePerimeter() -> Double {
        return 2 * Double.pi * radius
    }
}

struct Square: Shape {
    let side: Double

    func calculateArea() -> Double {
        return side * side
    }

    func calculatePerimeter() -> Double {
        return 4 * side
    }
}

Wat zijn de principes van objectgeoriënteerd programmeren?