O que é abstração em programação?

Quando você escreve print("hi"), não pensa em como essas letras chegam à tela. Por baixo dessa única linha, o Python transforma o texto em bytes e pede ao sistema operacional que os escreva, o sistema operacional os entrega ao seu terminal, e o terminal desenha cada letra como pixels usando uma fonte. Cada camada oferece à camada de cima uma promessa simples e esconde como cumpre essa promessa. Esse esconder é a abstração, e todo programa está apoiado em muitas camadas assim.

Níveis de abstração

Cada nível é construído a partir do nível de baixo e pode ser entendido sem ele. Você consegue escrever Python que funciona sem saber o que é um bloco de disco, e o sistema operacional consegue armazenar um arquivo sem saber que ele contém código Python.

Como a abstração funciona no código

Os programadores constroem as próprias camadas de duas formas principais.

A abstração procedural é uma função. O nome, os parâmetros e o valor de retorno são a interface; o corpo é o detalhe escondido. Depois que average(scores) existe, o resto do programa a usa sem ler como ela soma e divide.

A abstração de dados define um tipo pelo que você pode fazer com ele, não por como ele guarda as coisas. Uma fila é "acrescentar no fim, retirar do começo". Como os itens ficam na memória é uma decisão privada:

from collections import deque

class Queue:
    """First in, first out. Callers only see add() and next()."""
    def __init__(self):
        self._items = deque()     # swap this for a list and callers never notice
    def add(self, item):
        self._items.append(item)
    def next(self):
        return self._items.popleft()
    def __len__(self):
        return len(self._items)

orders = Queue()
for dish in ["soup", "pasta", "cake"]:
    orders.add(dish)
while len(orders):
    print("serving", orders.next())

serving soup
serving pasta
serving cake

O código no final não sabe nada sobre deque. Se você o trocar por uma lista comum e pop(0), a saída é idêntica, só mais lenta para filas longas, porque remover o primeiro item de uma lista move todos os outros itens. A interface continuou a mesma, então nada fora da classe precisou mudar.

Classes abstratas e interfaces

Na programação orientada a objetos, abstração costuma significar declarar o que uma família de classes precisa fazer e deixar o como para cada classe. Em Python, o módulo abc marca um método como abstrato; uma classe com um método abstrato não implementado não pode ser instanciada:

from abc import ABC, abstractmethod

class Notifier(ABC):
    @abstractmethod
    def send(self, to, text):
        """Every notifier must say how it sends a message."""

class Email(Notifier):
    def send(self, to, text):
        print(f"email to {to}: {text}")

class SMS(Notifier):
    def send(self, to, text):
        print(f"sms to {to}: {text}")

def remind(notifier, user):
    notifier.send(user, "Your package arrives today")

remind(Email(), "ana@example.com")
remind(SMS(), "+15550100")
try:
    Notifier()
except TypeError:
    print("Notifier is abstract: create an Email or an SMS instead")

email to ana@example.com: Your package arrives today
sms to +15550100: Your package arrives today
Notifier is abstract: create an Email or an SMS instead

remind() depende só da abstração: qualquer coisa que tenha um método send. Acrescentar notificações push significa escrever uma classe nova, e remind() fica intocada. Esse último passo, uma chamada executando código diferente para classes diferentes, é o polimorfismo: a abstração define a interface comum, o polimorfismo a faz funcionar.

O Java tem as mesmas ferramentas como palavras-chave:

interface Notifier {
    void send(String to, String text);
}

class Email implements Notifier {
    public void send(String to, String text) { /* talk to the mail server */ }
}

Escrever new Notifier() é um erro de compilação, porque uma interface não tem implementação para executar. A documentação explica em detalhe classes abstratas e interfaces em Java.

Abstração e encapsulamento

As duas ideias aparecem juntas com tanta frequência que é fácil confundi-las.

A abstração decide quais operações mostrar; o encapsulamento garante que o resto fique escondido. A Queue acima faz as duas coisas: add e next são a abstração, e o sublinhado em _items é o encapsulamento.

Abstrações que vazam e outros erros

Joel Spolsky deu nome à lei das abstrações que vazam (law of leaky abstractions) em 2002: toda abstração não trivial deixa passar parte do detalhe escondido. Os números de ponto flutuante são o vazamento clássico. Eles parecem decimais comuns, até que o armazenamento binário por baixo aparece:

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

0.30000000000000004
False

Nem 0,1 nem 0,2 podem ser armazenados exatamente em bits binários, então a soma sai um pouco errada. Você pode usar floats por anos sem pensar nisso, mas não para sempre, e é por isso que ajuda conhecer uma camada abaixo daquela em que você trabalha.

Dois outros erros são comuns:

• Abstrair cedo demais. Uma hierarquia de classes construída para casos que nunca chegam é código extra para ler e mudar. Sandi Metz resumiu assim: "duplicação é muito mais barata do que a abstração errada".
• Confundir abstração com a palavra-chave abstract. Classes abstratas são uma ferramenta. Toda função com um bom nome também é uma abstração.

Próximos passos

Leia encapsulamento e polimorfismo para completar o quadro da orientação a objetos. A página de sistema operacional mostra a maior abstração de que os seus programas dependem. Para praticar, o curso de Python constrói classes e funções desde o início, e o curso de Java cobre classes abstratas e interfaces.