¿Qué es la programación orientada a objetos?

La programación orientada a objetos (POO) es un paradigma de programación que se basa en el concepto de "objetos", los cuales pueden contener datos (atributos) y código (métodos).

Los principios básicos de la POO incluyen:

• Encapsulación: Ocultar datos y métodos dentro de un objeto, al que se accede a través de una interfaz bien definida.
• Herencia: Mecanismo que permite a una clase (subclase) heredar propiedades y comportamientos de otra clase (superclase).
• Polimorfismo: La capacidad de usar una misma interfaz para objetos de diferentes clases, donde cada objeto se comporta a su manera.

// Ejemplo de encapsulación en 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) // Error de compilación: 'x' no accesible debido a nivel de protección 'private'
print(p1.distance(to: p2)) // Salida: 5.0

// Ejemplo de herencia en Swift
class Animal {
    func speak() {
        print("Algún sonido genérico")
    }
}

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

let myDog = Dog()
myDog.speak() // Salida: ¡Guau!

// Ejemplo de polimorfismo en Swift

// Usamos las clases Animal y Dog del ejemplo de herencia

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

let someAnimal: Animal = Animal()
let aDog: Animal = Dog() // Objeto Dog, pero tratado como Animal

makeAnimalSpeak(animal: someAnimal) // Salida: Algún sonido genérico
makeAnimalSpeak(animal: aDog) // Salida: ¡Guau!

Ventajas de la POO:

• Reutilización del código: A través de herencia y composición.
• Mejor legibilidad y mantenibilidad: El código está organizado en unidades lógicas (objetos).
• Flexibilidad: El polimorfismo permite agregar fácilmente nuevos tipos de objetos sin modificar el código existente.
• Facilidad de depuración: Permite aislar problemas dentro de objetos específicos.