¿Qué es el encapsulamiento?

Imagina que una app bancaria guarda el saldo de cada cuenta en una variable normal. Cualquier línea de cualquier parte del programa puede escribir account.balance = -500, y nada lo impide. Cuando aparece un saldo negativo en producción, tienes que buscar en todo el código cada sitio que lo tocó. El encapsulamiento lo soluciona: el saldo solo puede cambiar a través de unos pocos métodos, y esos métodos imponen las reglas, por ejemplo que una retirada nunca puede superar el saldo.

Cómo funciona el encapsulamiento

El encapsulamiento combina dos ideas:

1. Agrupar. Los datos (el saldo) y el código que trabaja con ellos (ingresar, retirar) viven en la misma clase.
2. Ocultar. El resto del código solo ve la interfaz pública de la clase. Los datos que hay detrás son internos, así que solo pueden cambiar de las formas que la clase permite.

La regla que protege la clase se llama invariante: aquí, "el saldo nunca es negativo". Como todo cambio pasa por los métodos de la clase, el invariante se cumple haga lo que haga el resto del programa.

class BankAccount:
    def __init__(self):
        self._balance = 0  # internal: change it only through the methods

    @property
    def balance(self):     # read-only from outside
        return self._balance

    def deposit(self, amount):
        self._balance += amount

    def withdraw(self, amount):
        if amount > self._balance:
            raise ValueError("not enough money")
        self._balance -= amount

acct = BankAccount()
acct.deposit(100)
acct.withdraw(30)
print(acct.balance)
try:
    acct.withdraw(500)
except ValueError as err:
    print("refused:", err)

70
refused: not enough money

El código de fuera puede leer acct.balance, pero la propiedad no tiene setter, así que acct.balance = 1000 lanza un AttributeError. Si el saldo sale mal alguna vez, hay exactamente dos métodos que revisar.

El encapsulamiento en Python

Python no tiene una palabra clave private. Se apoya en convenciones de nombres que todo programador de Python conoce:

• name: público, parte de la interfaz.
• _name: interno. Nada te impide leerlo, pero el guion bajo inicial dice "no dependas de esto".
• __name: Python lo renombra dentro de la clase (name mangling), para que una subclase no pueda sobrescribirlo por accidente.
• @property: convierte un método en algo que se lee como un atributo, así que puedes añadir comprobaciones más adelante sin cambiar el código que lo llama.

class Counter:
    def __init__(self):
        self._count = 0      # one underscore: "internal, please don't touch"
        self.__secret = 42   # two underscores: the name gets mangled

c = Counter()
print(c._count)                   # still readable: it is only a convention
print(hasattr(c, "__secret"))     # the plain name does not exist
print(c._Counter__secret)         # Python renamed it to _Counter__secret

0
False
42

El name mangling evita accidentes, no el acceso: el nombre transformado sigue funcionando. Python confía en que los programadores respeten el guion bajo. En la práctica, la mayor parte del código Python usa un solo guion bajo más @property, y reserva el doble guion bajo para las clases pensadas para tener subclases. Tienes más sobre cómo escribir clases en la documentación de clases de Python.

El encapsulamiento en Java, C++ y JavaScript

Otros lenguajes imponen la ocultación. En Java, un atributo private solo se puede usar dentro de su propia clase:

public class BankAccount {
    private int balance;  // hidden from every other class

    public int getBalance() { return balance; }

    public void withdraw(int amount) {
        if (amount > balance) throw new IllegalArgumentException("not enough money");
        balance -= amount;
    }
}

Escribir account.balance = 1000; en otra clase no compila: javac informa de balance has private access in BankAccount.

C++ hace privados por defecto los miembros de una class y públicos los de un struct. Los campos privados con # de JavaScript, añadidos en ES2022, no se pueden leer en absoluto desde fuera de la clase. La documentación cubre cada caso: modificadores de acceso en Java, especificadores de acceso en C++ y campos privados en JavaScript.

Por qué importa el encapsulamiento

• Las reglas viven en un solo sitio. La comprobación "ninguna retirada por encima del saldo" se escribe una vez, dentro de withdraw, en lugar de antes de cada retirada del programa.
• Puedes cambiar el interior con libertad. Si decides guardar el dinero en céntimos enteros en lugar de en un float, solo cambia la clase. El código que llama a deposit(100) sigue funcionando.
• Depurar es más fácil. Cuando un valor está mal, los sospechosos son los pocos métodos que pueden cambiarlo, no todas las líneas del programa.
• Hay menos que aprender y que probar. Una clase con tres métodos públicos se puede entender y probar a través de esos tres métodos.

El encapsulamiento también funciona por encima del nivel de las clases. Un módulo que expone dos funciones y mantiene diez auxiliares internas está encapsulado de la misma forma, y también lo está un sistema operativo que solo deja a los programas abrir archivos mediante llamadas al sistema.

A menudo se confunde con la abstracción. La abstracción decide qué ofrece la interfaz; el encapsulamiento protege los datos que hay detrás. La página de abstracción tiene una comparación completa lado a lado. Junto con el polimorfismo y la herencia, son los cuatro pilares de la programación orientada a objetos.

Errores comunes

• Un getter y un setter para cada atributo. Un setBalance que acepta cualquier número no protege nada. Ofrece las operaciones que necesita el objeto (withdraw), no acceso directo a cada atributo.
• Devolver objetos internos. Un método que devuelve self._items le entrega a quien lo llama la lista real, que ahora puede modificar. Devuelve una copia o una tupla.
• Tratar lo privado como seguridad. Los modificadores de acceso evitan errores, no ataques. El código Java puede leer atributos privados mediante reflexión, y el código Python puede leer _name directamente. Las contraseñas y las claves necesitan protección real, como el hashing y el cifrado.

Qué leer después

Lee a continuación abstracción, que explica la diferencia entre las dos ideas, y después polimorfismo. El curso de Python construye clases paso a paso, y el curso de Java muestra el encapsulamiento impuesto por el compilador.