O que é encapsulamento?

Imagine que um aplicativo de banco guarda o saldo de cada conta em uma variável comum. Qualquer linha em qualquer lugar do programa pode escrever account.balance = -500, e nada impede isso. Quando um saldo negativo aparece em produção, você precisa procurar no código inteiro todos os lugares que mexeram nele. O encapsulamento resolve isso: o saldo só pode mudar por meio de alguns métodos, e esses métodos garantem as regras, por exemplo que um saque nunca pode ser maior que o saldo.

Como o encapsulamento funciona

O encapsulamento combina duas ideias:

1. Agrupamento. Os dados (o saldo) e o código que trabalha com eles (depositar, sacar) ficam na mesma classe.
2. Ocultação. O resto do código vê só a interface pública da classe. Os dados por trás dela são internos, então só podem mudar das formas que a classe permite.

A regra que a classe protege se chama invariante: aqui, "o saldo nunca é negativo". Como toda alteração passa pelos métodos da classe, a invariante se mantém não importa o que o resto do programa faça.

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

O código de fora consegue ler acct.balance, mas a propriedade não tem setter, então acct.balance = 1000 lança um AttributeError. Se o saldo estiver errado algum dia, há exatamente dois métodos para investigar.

Encapsulamento em Python

O Python não tem a palavra-chave private. Ele depende de convenções de nomes que todo programador Python conhece:

• name: público, faz parte da interface.
• _name: interno. Nada impede você de lê-lo, mas o sublinhado inicial diz "não dependa disto".
• __name: o Python o renomeia dentro da classe (name mangling), para que uma subclasse não o sobrescreva por acidente.
• @property: transforma um método em algo que se lê como um atributo, para que você possa acrescentar verificações depois sem mudar nenhum código que o chama.

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

O name mangling evita acidentes, não o acesso: o nome modificado continua funcionando. O Python confia que os programadores respeitem o sublinhado. Na prática, a maior parte do código Python usa um único sublinhado mais @property, e reserva os dois sublinhados para classes feitas para ter subclasses. Há mais sobre como escrever classes na documentação de classes em Python.

Encapsulamento em Java, C++ e JavaScript

Outras linguagens garantem a ocultação. Em Java, um campo private só pode ser usado dentro da própria classe:

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;
    }
}

Escrever account.balance = 1000; em outra classe não compila: o javac informa balance has private access in BankAccount.

O C++ torna os membros de class privados por padrão e os de struct públicos. Os campos privados # do JavaScript, adicionados no ES2022, não podem ser lidos de fora da classe de jeito nenhum. A documentação cobre cada um: modificadores de acesso em Java, especificadores de acesso em C++ e campos privados em JavaScript.

Por que o encapsulamento importa

• As regras ficam em um só lugar. A verificação "nenhum saque acima do saldo" é escrita uma vez, dentro de withdraw, em vez de antes de cada saque do programa.
• Você pode mudar o interior à vontade. Se decidir guardar o dinheiro em centavos inteiros em vez de um float, só a classe muda. O código que chama deposit(100) continua funcionando.
• Depuração mais fácil. Quando um valor está errado, os suspeitos são os poucos métodos que podem alterá-lo, não todas as linhas do programa.
• Menos para aprender e testar. Uma classe com três métodos públicos pode ser entendida e testada por meio desses três métodos.

O encapsulamento também funciona acima do nível das classes. Um módulo que expõe duas funções e mantém dez auxiliares internas é encapsulado do mesmo jeito, assim como um sistema operacional que só deixa os programas abrirem arquivos por meio de chamadas de sistema.

Ele é muitas vezes confundido com abstração. A abstração decide o que a interface oferece; o encapsulamento protege os dados por trás dela. A página de abstração tem uma comparação completa lado a lado. Junto com o polimorfismo e a herança, eles são os quatro pilares da programação orientada a objetos.

Erros comuns

• Um getter e um setter para cada campo. Um setBalance que aceita qualquer número não protege nada. Ofereça as operações de que o objeto precisa (withdraw), não acesso direto a cada campo.
• Devolver objetos internos. Um método que devolve self._items entrega a quem chama a lista real, que agora pode ser alterada. Devolva uma cópia ou uma tupla.
• Tratar privado como segurança. Modificadores de acesso evitam erros, não ataques. Código Java consegue ler campos privados por reflexão, e código Python consegue ler _name diretamente. Senhas e chaves precisam de proteção de verdade, como hashing e criptografia.

Próximos passos

Leia a seguir abstração, que cobre a diferença entre as duas ideias, e depois polimorfismo. O curso de Python constrói classes passo a passo, e o curso de Java mostra o encapsulamento garantido pelo compilador.