Was ist objektorientierte Programmierung?

Objektorientierte Programmierung (OOP) ist ein Programmierparadigma, das um das Konzept der "Objekte" herum aufgebaut ist, die Daten (Attribute) und Code (Methoden) enthalten können.

Die Grundprinzipien der OOP umfassen:

• Kapselung: Verbergen von Daten und Methoden innerhalb eines Objekts, auf das über eine gut definierte Schnittstelle zugegriffen wird.
• Vererbung: Mechanismus, der es einer Klasse (Unterklasse) ermöglicht, Eigenschaften und Verhalten einer anderen Klasse (Oberklasse) zu erben.
• Polymorphismus: Die Fähigkeit, eine einheitliche Schnittstelle für Objekte verschiedener Klassen zu verwenden, wobei jedes Objekt sich auf seine Weise verhält.

// Beispiel für Kapselung 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) // Kompilierungsfehler: 'x' ist aufgrund des Schutzlevels 'private' nicht zugänglich
print(p1.distance(to: p2)) // Ausgabe: 5.0

// Beispiel für Vererbung in Swift
class Animal {
    func speak() {
        print("Ein generisches Geräusch")
    }
}

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

let myDog = Dog()
myDog.speak() // Ausgabe: Wuff!

// Beispiel für Polymorphismus in Swift

// Wir verwenden die Klassen Animal und Dog aus dem Vererbungsbeispiel

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

let someAnimal: Animal = Animal()
let aDog: Animal = Dog() // Dog-Objekt, aber behandelt als Animal

makeAnimalSpeak(animal: someAnimal) // Ausgabe: Ein generisches Geräusch
makeAnimalSpeak(animal: aDog) // Ausgabe: Wuff!

Vorteile der OOP:

• Wiederverwendung von Code: Durch Vererbung und Komposition.
• Verbesserte Lesbarkeit und Wartbarkeit: Der Code ist in logische Einheiten (Objekte) organisiert.
• Flexibilität: Polymorphismus ermöglicht es, neue Objekttypen leicht hinzuzufügen, ohne den bestehenden Code zu ändern.
• Einfacheres Debuggen: Ermöglicht die Isolierung von Problemen innerhalb spezifischer Objekte.