Care sunt principiile programării orientate pe…

Principiile OOP:

Încapsulare: Combinarea datelor (proprietăților) și a metodelor care lucrează cu aceste date într-un singur obiect și ascunderea implementării interne față de lumea exterioară. Accesul la date se face prin interfețe publice specifice (metode).

// Ascunderea implementării interne a proprietății balance
class Account {
    private var balance: Double = 0.0

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

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

Moștenire: Mecanism care permite crearea unei noi clase (subclasă) pe baza uneia existente (superclasă), moștenind proprietățile și metodele acesteia. Favorizează reutilizarea codului.

// Clasele Dog și Cat moștenesc proprietățile și metodele clasei Animal
class Animal {
    let name: String

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

    func makeSound() {
        print("\(name) emite un sunet")
    }
}

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

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

Polimorfism: Capacitatea obiectelor din clase diferite de a răspunde la același mesaj (apel de metodă) în mod diferit, în funcție de tipul lor.

// Diferite implementări ale metodei makeSound() în clasele Dog și Cat
func playSound(of animal: Animal) {
    animal.makeSound() // Apel polimorfic
}

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

playSound(of: myDog) // Va afișa "Bobby latră"
playSound(of: myCat) // Va afișa "Murka miaună"

Abstracție: Evidențierea caracteristicilor esențiale ale unui obiect și ignorarea celor nesemnificative. Crearea de reprezentări generale ale obiectelor.

// Reprezentarea unei figuri geometrice fără implementare concretă
protocol Shape {
    func calculateArea() -> Double
    func calculatePerimeter() -> Double
}

// Implementări concrete pentru cerc și pătrat
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
    }
}

Care sunt principiile programării orientate pe obiecte?