• TABLA DE CONTENIDOS

Fundamentos de la Programación Orientada a Objetos (POO)

La Programación Orientada a Objetos (POO) es un paradigma de programación que organiza el diseño del software en torno a objetos.

Los objetos son instancias de clases, y pueden tener:

• Atributos: Datos que describen las características del objeto.
• Métodos: Funciones que definen el comportamiento del objeto.

Conceptos Clave

1. Clase:
   • Es un molde o plantilla que define los atributos (datos) y métodos (funciones) que tendrán los objetos.
   • Define las características comunes para un grupo de objetos.
2. Objeto:
   • Es una instancia específica creada a partir de una clase.
   • Representa un elemento concreto con características y comportamientos definidos.
3. Atributo:
   • Es una variable que pertenece a un objeto o clase.
   • Describe las características del objeto.
4. Método:
   • Es una función que pertenece a un objeto o clase.
   • Describe las acciones que el objeto puede realizar.

4 Pilares de la POO

1. Herencia:

   • Permite que una clase (subclase) herede atributos y métodos de otra clase (superclase).
   • Facilita la reutilización de código y la creación de jerarquías.

   Ejemplo:

   class Animal:
       def __init__(self, nombre):
           self.nombre = nombre
       def hacer_sonido(self):
           return "Hace un sonido genérico"
   
   class Perro(Animal):  # Hereda de Animal
       def hacer_sonido(self):
           return "Ladra"
   
   

2. Encapsulamiento:

   • Consiste en ocultar los detalles internos del objeto, permitiendo el acceso y la modificación de sus datos solo a través de métodos específicos.
   • Protege los datos sensibles de manipulaciones externas.

   Ejemplo:

   class CuentaBancaria:
       def __init__(self, saldo):
           self.__saldo = saldo  # Atributo privado
       def depositar(self, monto):
           if monto > 0:
               self.__saldo += monto
       def obtener_saldo(self):
           return self.__saldo
   
   

3. Abstracción:

   • Simplifica el diseño del programa ocultando detalles complejos y mostrando solo lo esencial.
   • Se implementa utilizando métodos abstractos que deben ser definidos en las subclases.

   Ejemplo:

   from abc import ABC, abstractmethod
   
   class Forma(ABC):  # Clase abstracta
       @abstractmethod
       def calcular_area(self):
           pass
   
   class Rectangulo(Forma):
       def __init__(self, ancho, alto):
           self.ancho = ancho
           self.alto = alto
       def calcular_area(self):
           return self.ancho * self.alto
   
   

4. Polimorfismo:

   • Es la capacidad de tratar objetos de diferentes clases como si fueran del mismo tipo, a través de una interfaz común.
   • Los métodos con el mismo nombre pueden tener diferentes implementaciones en distintas clases.

   Ejemplo:

   class Animal:
       def hacer_sonido(self):
           return "Sonido genérico"
   class Perro(Animal):
       def hacer_sonido(self):
           return "Ladra"
   class Gato(Animal):
       def hacer_sonido(self):
           return "Maúlla"
   
   def emitir_sonidos(animales):
       for animal in animales:
           print(animal.hacer_sonido())
   
   animales = [Perro(), Gato(), Animal()]
   emitir_sonidos(animales)
   # Salida:
   # Ladra
   # Maúlla
   # Sonido genérico