Jaké jsou principy objektově orientovaného…

Principy OOP:

Zapouzdření: Spojení dat (vlastností) a metod, které s těmito daty pracují, do jednoho objektu a skrytí vnitřní implementace před vnějším světem. Přístup k datům je umožněn prostřednictvím určitých veřejných rozhraní (metod).

// Skrytí vnitřní implementace vlastnosti balance
class Account {
    private var balance: Double = 0.0

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

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

Dědičnost: Mechanismus, který umožňuje vytvářet novou třídu (odvozenou) na základě existující (základní), dědící její vlastnosti a metody. To podporuje opakované použití kódu.

// Třídy Dog a Cat dědí vlastnosti a metody třídy Animal
class Animal {
    let name: String

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

    func makeSound() {
        print("\(name) vydává zvuk")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("\(name) štěká")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("\(name) mňouká")
    }
}

Polymorfismus: Schopnost objektů různých tříd reagovat na stejnou zprávu (volání metody) odlišně v závislosti na jejich typu.

// Různé implementace metody makeSound() ve třídách Dog a Cat
func playSound(of animal: Animal) {
    animal.makeSound() // Polymorfní volání
}

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

playSound(of: myDog) // Vypíše "Bobeš štěká"
playSound(of: myCat) // Vypíše "Murka mňouká"

Abstrakce: Vyčlenění podstatných vlastností objektu a ignorování nepodstatných. Vytváření obecných představ o objektech.

// Představa o geometrickém tvaru bez konkrétní implementace
protocol Shape {
    func calculateArea() -> Double
    func calculatePerimeter() -> Double
}

// Konkrétní implementace pro kruh a čtverec
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
    }
}

Jaké jsou principy objektově orientovaného programování?