Aula 13: O Pilar da Abstração

Analogia do Controle Remoto

Pense em um controle remoto de TV. Você usa os botões "volume", "canal" e "ligar/desligar" sem se preocupar com os circuitos eletrônicos, os sinais infravermelhos ou como o volume é realmente alterado dentro da TV. O controle remoto é uma abstração: ele esconde a complexidade e expõe apenas a interface necessária para interagir com a TV.

Abstração em Código

Em programação, isso se traduz em criar classes e métodos que forneçam uma interface clara e simplificada, escondendo os detalhes da implementação interna. Isso é crucial para sistemas grandes e complexos, pois reduz a complexidade para quem usa o código.

class ProcessadorPagamento:
    def processar(self, valor):
        # Aqui, estamos interessados APENAS em PROCESSAR o pagamento.
        # Não precisamos saber os detalhes internos de como a
        # transação é enviada para o banco, validada, etc.
        pass # A implementação real está "abstraída"

class Carro:
    def ligar(self):
        # O motorista apenas sabe que o carro "liga".
        # Os detalhes de ignição, injeção, etc., são abstraídos.
        pass
    def acelerar(self):
        # O motorista apenas sabe que o carro "acelera".
        # Os detalhes do motor, transmissão, etc., são abstraídos.
        pass

Benefícios da Abstração

• **Redução de Complexidade:** Simplifica o uso de um sistema, pois o usuário não precisa entender todos os detalhes internos.
• **Reusabilidade:** Interfaces abstratas podem ser usadas em diversos contextos.
• **Manutenibilidade:** Mudanças na implementação interna de um método não afetam o código que o utiliza, desde que a interface (o "o que" ele faz) permaneça a mesma.
• **Segurança:** Impede o acesso direto a dados e lógicas internas que não deveriam ser expostos.

Classes `Impressora` e Seus Métodos Abstratos

class Impressora:
    def __init__(self, modelo):
        self.modelo = modelo
        self._conectada = False # Detalhe interno

    def conectar(self):
        self._conectada = True
        print(f"Impressora {self.modelo} conectada.")

    def imprimir(self, documento):
        # Este é o método "abstrato" para o usuário.
        # Ele esconde a complexidade de como a impressão é feita.
        if self._conectada:
            self._preparar_papel() # Detalhe interno
            self._aquecer_tinta()  # Detalhe interno
            print(f"Imprimindo: '{documento}' na {self.modelo}...")
            self._finalizar_impressao() # Detalhe interno
        else:
            print(f"Erro: Impressora {self.modelo} não está conectada.")

    # Métodos internos, detalhes de implementação que são abstraídos:
    def _preparar_papel(self):
        print("    -> Preparando papel...")

    def _aquecer_tinta(self):
        print("    -> Aquecendo tinta...")

    def _finalizar_impressao(self):
        print("    -> Impressão finalizada.")

# Exemplo de uso:
# minha_impressora = Impressora("HP LaserJet")
# minha_impressora.conectar()
# minha_impressora.imprimir("Relatório Anual.pdf")
# minha_impressora.imprimir("Imagem.jpg") # Não precisa saber como imagens são impressas.

Classe `ImpressoraSimulada` (simulada)

class ImpressoraSimulada:
    def __init__(self, modelo):
        self.modelo = modelo
        self._conectada = False

    def conectar(self):
        self._conectada = True
        return `Impressora ${self.modelo} conectada.`

    def imprimir(self, documento):
        if self._conectada:
            output = []
            output.append(f'Imprimindo: {documento} na {self.modelo}...')
            output.append(self._preparar_papel())
            output.append(self._aquecer_tinta())
            output.append(self._renderizar_pagina()) # Método fictício de complexidade
            output.append(self._finalizar_impressao())
            return '\n'.join(output)
        else:
            return f'Erro: Impressora {self.modelo} não está conectada.'

    # Métodos internos (abstraídos do usuário):
    def _preparar_papel(self):
        return "    -> Preparando papel..."

    def _aquecer_tinta(self):
        return "    -> Aquecendo tinta..."

    def _renderizar_pagina(self):
        return "    -> Renderizando página (complexidade interna oculta)..."

    def _finalizar_impressao(self):
        return "    -> Impressão finalizada."