Cos'è la programmazione orientata agli oggetti?

La programmazione orientata agli oggetti (OOP) è un paradigma di programmazione che si basa sul concetto di "oggetti", che possono contenere dati (attributi) e codice (metodi).

I principi fondamentali dell'OOP includono:

• Incapsulamento: Nascondere dati e metodi all'interno di un oggetto, a cui si accede tramite un'interfaccia ben definita.
• Ereditarietà: Meccanismo che permette a una classe (sottoclasse) di ereditare proprietà e comportamenti di un'altra classe (superclasse).
• Polimorfismo: La capacità di usare un'interfaccia comune per oggetti di classi diverse, dove ogni oggetto si comporta a modo suo.

// Esempio di incapsulamento 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) // Errore di compilazione: 'x' non accessibile a causa del livello di protezione 'private'
print(p1.distance(to: p2)) // Output: 5.0

// Esempio di ereditarietà in Swift
class Animal {
    func speak() {
        print("Suono generico")
    }
}

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

let myDog = Dog()
myDog.speak() // Output: Woof!

// Esempio di polimorfismo in Swift

// Utilizziamo le classi Animal e Dog dall'esempio di ereditarietà

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

let someAnimal: Animal = Animal()
let aDog: Animal = Dog() // Oggetto Dog, ma trattato come Animal

makeAnimalSpeak(animal: someAnimal) // Output: Suono generico
makeAnimalSpeak(animal: aDog) // Output: Woof!

Vantaggi dell'OOP:

• Riutilizzo del codice: Attraverso ereditarietà e composizione.
• Migliore leggibilità e manutenibilità: Il codice è organizzato in unità logiche (oggetti).
• Flessibilità: Il polimorfismo permette di aggiungere facilmente nuovi tipi di oggetti senza modificare il codice esistente.
• Più facile da debug: Permette di isolare i problemi all'interno di oggetti specifici.