Was sind die Prinzipien der objektorientierten…

Grundsätze der OOP:

Kapselung: Zusammenfassung von Daten (Eigenschaften) und Methoden, die mit diesen Daten arbeiten, in einem einzigen Objekt und Verbergen der internen Implementierung vor der Außenwelt. Der Zugriff auf die Daten erfolgt über bestimmte öffentliche Schnittstellen (Methoden).

// Verbergen der internen Implementierung der Eigenschaft balance
class Account {
    private var balance: Double = 0.0

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

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

Vererbung: Mechanismus, der es ermöglicht, eine neue Klasse (Unterklasse) auf Basis einer bestehenden Klasse (Oberklasse) zu erstellen, wobei deren Eigenschaften und Methoden geerbt werden. Dies fördert die Wiederverwendung von Code.

// Klassen Dog und Cat erben die Eigenschaften und Methoden der Klasse Animal
class Animal {
    let name: String

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

    func makeSound() {
        print("\(name) macht Geräusch")
    }
}

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

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

Polymorphismus: Fähigkeit von Objekten verschiedener Klassen, auf eine gleiche Nachricht (Methodenaufruf) unterschiedlich zu reagieren, abhängig von ihrem Typ.

// Verschiedene Implementierungen der Methode makeSound() in den Klassen Dog und Cat
func playSound(of animal: Animal) {
    animal.makeSound() // Polymorpher Aufruf
}

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

playSound(of: myDog) // Gibt "Bobby bellt" aus
playSound(of: myCat) // Gibt "Murka miaut" aus

Abstraktion: Hervorhebung der wesentlichen Eigenschaften eines Objekts und Ignorieren der unwesentlichen. Erstellung allgemeiner Darstellungen von Objekten.

// Darstellung einer geometrischen Figur ohne konkrete Implementierung
protocol Shape {
    func calculateArea() -> Double
    func calculatePerimeter() -> Double
}

// Konkrete Implementierungen für Kreis und Quadrat
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
    }
}

Was sind die Prinzipien der objektorientierten Programmierung?