Quali sono i principi della programmazione orientata…

Principi di OOP:

Incapsulamento: Raggruppare dati (proprietà) e metodi che operano su questi dati in un unico oggetto e nascondere l'implementazione interna al mondo esterno. L'accesso ai dati avviene tramite interfacce pubbliche specifiche (metodi).

// Nascondere l'implementazione interna della proprietà balance
class Account {
    private var balance: Double = 0.0

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

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

Ereditarietà: Meccanismo che permette di creare una nuova classe (figlia) basata su una esistente (genitore), ereditando le sue proprietà e metodi. Favorisce il riutilizzo del codice.

// Le classi Dog e Cat ereditano le proprietà e i metodi della classe Animal
class Animal {
    let name: String

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

    func makeSound() {
        print("\(name) emette un suono")
    }
}

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

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

Polimorfismo: Capacità di oggetti di classi diverse di rispondere a un messaggio (chiamata di metodo) in modo diverso, a seconda del loro tipo.

// Diverse implementazioni del metodo makeSound() nelle classi Dog e Cat
func playSound(of animal: Animal) {
    animal.makeSound() // Chiamata polimorfica
}

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

playSound(of: myDog) // Mostrerà "Bobby abbaia"
playSound(of: myCat) // Mostrerà "Murka miagola"

Astrazione: Evidenziare le caratteristiche essenziali di un oggetto e ignorare quelle non essenziali. Creare rappresentazioni generali di oggetti.

// Rappresentazione di una figura geometrica senza implementazione concreta
protocol Shape {
    func calculateArea() -> Double
    func calculatePerimeter() -> Double
}

// Implementazioni concrete per cerchio e quadrato
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
    }
}

Quali sono i principi della programmazione orientata agli oggetti?