Wat is objectgeoriënteerd programmeren?

Objectgeoriënteerd programmeren (OOP) is een programmeerparadigma dat gebaseerd is op het concept van "objecten", die gegevens (attributen) en code (methoden) kunnen bevatten.

De kernprincipes van OOP omvatten:

• Encapsulatie: Het verbergen van gegevens en methoden binnen een object, waar toegang toe wordt verkregen via een goed gedefinieerde interface.
• Erfelijkheid: Een mechanisme waarmee een klasse (subklasse) eigenschappen en gedrag kan erven van een andere klasse (superklasse).
• Polymorfisme: Het vermogen om één en dezelfde interface te gebruiken voor objecten van verschillende klassen, waarbij elk object zich naar eigen aard gedraagt.

// Voorbeeld van encapsulatie in Swift
struct Point {
    private var x: Double
    private var y: Double

    init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }

    func distance(to otherPoint: Point) -> Double {
        let deltaX = self.x - otherPoint.x
        let deltaY = self.y - otherPoint.y
        return sqrt(deltaX * deltaX + deltaY * deltaY)
    }
}

let p1 = Point(x: 0, y: 0)
let p2 = Point(x: 3, y: 4)
// print(p1.x) // Fout bij compilatie: 'x' is niet toegankelijk vanwege 'private' beschermingsniveau
print(p1.distance(to: p2)) // Uitvoer: 5.0

// Voorbeeld van overerving in Swift
class Animal {
    func speak() {
        print("Enig algemeen geluid")
    }
}

class Dog: Animal {
    override func speak() {
        print("Woef!")
    }
}

let myDog = Dog()
myDog.speak() // Uitvoer: Woef!

// Voorbeeld van polymorfisme in Swift

// We gebruiken de klassen Animal en Dog uit het overervingsvoorbeeld

func makeAnimalSpeak(animal: Animal) {
    animal.speak()
}

let someAnimal: Animal = Animal()
let aDog: Animal = Dog() // Dog-object, maar behandeld als Animal

makeAnimalSpeak(animal: someAnimal) // Uitvoer: Enig algemeen geluid
makeAnimalSpeak(animal: aDog) // Uitvoer: Woef!

Voordelen van OOP:

• Herbruikbaarheid van code: Via overerving en compositie.
• Betere leesbaarheid en onderhoudbaarheid: De code is georganiseerd in logische eenheden (objecten).
• Flexibiliteit: Polymorfisme maakt het gemakkelijk om nieuwe objecttypes toe te voegen zonder de bestaande code te wijzigen.
• Gemakkelijker debuggen: Maakt het mogelijk om problemen te isoleren binnen specifieke objecten.