Quels sont les principes de la programmation orientée…

Principes de la POO:

Encapsulation: Regrouper les données (propriétés) et les méthodes qui opèrent sur ces données en un seul objet et cacher l'implémentation interne du monde extérieur. L'accès aux données se fait via des interfaces publiques spécifiques (méthodes).

// Cacher l'implémentation interne de la propriété balance
class Account {
    private var balance: Double = 0.0

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

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

Héritage: Mécanisme permettant de créer une nouvelle classe (fille) basée sur une existante (parent), en héritant ses propriétés et méthodes. Cela favorise la réutilisation du code.

// Les classes Dog et Cat héritent des propriétés et méthodes de la classe Animal
class Animal {
    let name: String

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

    func makeSound() {
        print("\(name) émet un son")
    }
}

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

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

Polymorphisme: Capacité d'objets de classes différentes à répondre à un même message (appel de méthode) de manière différente, selon leur type.

// Différentes implémentations de la méthode makeSound() dans les classes Dog et Cat
func playSound(of animal: Animal) {
    animal.makeSound() // Appel polymorphe
}

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

playSound(of: myDog) // Affichera "Bobby aboie"
playSound(of: myCat) // Affichera "Murka miaule"

Abstraction: Mettre en évidence les caractéristiques essentielles d'un objet et ignorer celles non essentielles. Créer des représentations générales d'objets.

// Représentation d'une figure géométrique sans implémentation concrète
protocol Shape {
    func calculateArea() -> Double
    func calculatePerimeter() -> Double
}

// Implémentations concrètes pour cercle et carré
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
    }
}

Quels sont les principes de la programmation orientée objet?