Introducción a la encapsulación y la abstracción

La encapsulación y la abstracción son principios fundamentales de la programación orientada a objetos (POO) que ayudan a gestionar la complejidad y a mejorar la organización del código.

La encapsulación restringe el acceso directo a los datos de un objeto, mientras que la abstracción oculta los detalles de implementación y expone únicamente las características esenciales.

¿Qué es la encapsulación?

La encapsulación consiste en agrupar los datos (atributos) y los métodos dentro de una clase, y restringir el acceso directo a ellos.

# Example of encapsulation
class Person:
    # Private attribute (indicated by double underscores)
    def __init__(self, name):
        self.__name = name

    # Public method to access the private attribute
    def get_name(self):
        return self.__name

person = Person("Alice")
# Accessing private data via a public method
print(person.get_name())

Atributos privados

En Python, los atributos privados se indican mediante dos guiones bajos __. No se puede acceder a ellos directamente desde fuera de la clase.

# Private attributes
class Car:
    def __init__(self, brand):
        self.__brand = brand  # Private attribute

    def get_brand(self):
        # Public method to access the private attribute
        return self.__brand

car = Car("Toyota")
print(car.get_brand())  # Outputs: Toyota

¿Qué es la abstracción?

La abstracción oculta los detalles internos de implementación de una clase y expone únicamente la funcionalidad necesaria para el usuario.

# Example of abstraction
from abc import ABC, abstractmethod

# Abstract Base Class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Subclass implementing the abstract method
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

circle = Circle(5)
print(circle.area())  # Outputs: 78.5

Clases abstractas

Las clases abstractas son clases que no se pueden instanciar directamente. Se utilizan para definir una interfaz común para sus subclases.

# Abstract Base Class with multiple subclasses
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

dog = Dog()
cat = Cat()
dog.speak()  # Outputs: Dog barks
cat.speak()  # Outputs: Cat meows

Encapsulación frente a abstracción

La encapsulación y la abstracción son conceptos estrechamente relacionados, pero distintos:

• Encapsulación: Restringe el acceso a los datos dentro de una clase.
• Abstracción: Oculta los detalles de implementación y proporciona una interfaz clara.

Ventajas de la encapsulación y la abstracción

Estas son algunas ventajas importantes:

• Mejora la seguridad y la facilidad de mantenimiento del código.
• Fomenta la creación de código modular y reutilizable.
• Facilita la lectura y la comprensión del código.

Errores comunes con la encapsulación y la abstracción

Estos son algunos errores que debe evitar:

• Acceder directamente a los atributos privados en lugar de utilizar métodos getter y setter.
• Instanciar directamente clases abstractas.
• No implementar todos los métodos abstractos en las subclases.

¿Qué aprendimos?

En esta lección, aprendió:

• Qué es la encapsulación y cómo restringir el acceso a los datos mediante atributos privados.
• Qué es la abstracción y cómo utilizar clases abstractas para definir interfaces comunes.
• Las diferencias y ventajas de la encapsulación y la abstracción.

¡Excelente trabajo! Pasemos al siguiente tema.