POO: herança, polimorfismo e encapsulamento com código

A programação orientada a objetos (POO) organiza o software em torno de objetos que combinam dados e comportamento. Os conceitos são cobrados de forma teórica em provas de TI, normalmente com Java como referência, mas valem para a maioria das linguagens do paradigma. Para tornar os conceitos concretos, este guia usa um exemplo em Python executado e indica o que muda em outras linguagens quando há diferença de regra.

Classe e objeto

A classe é o molde: define os atributos (dados) e os métodos (comportamentos). O objeto (ou instância) é uma criação concreta a partir da classe. Uma classe Servidor pode ter atributos nome e _base e um método pontos(); cada servidor criado é um objeto com valores próprios.

class Servidor:
    contador = 0
    def __init__(self, nome, base):
        self.nome = nome
        self._base = base
        Servidor.contador += 1
    def pontos(self):
        return self._base

O __init__ é o construtor, que inicializa o objeto. O atributo contador pertence à classe e é compartilhado por todas as instâncias (em Java, seria um atributo static). Criados três objetos no teste, Servidor.contador valeu 3.

Herança

Herança permite que uma classe (subclasse ou derivada) reaproveite e especialize outra (superclasse ou base). Expressa a relação “é um”: um analista é um servidor.

class Analista(Servidor):
    def pontos(self):
        return super().pontos() + 20

class Tecnico(Servidor):
    def pontos(self):
        return self._base + 5

Instâncias de Analista, Tecnico e Servidor, todas com base 100, deram 120, 105 e 100 pontos. Também se verificou que um analista é instância de Servidor (verdadeiro) e que um técnico não é instância de Analista (falso). O super() acessa a versão da superclasse. Herança promove reuso, mas cria acoplamento: mudanças na superclasse afetam as subclasses. Quando a relação não é “é um” e sim “tem um”, prefere-se composição: o objeto guarda outro objeto como atributo.

Herança múltipla: Python e C++ permitem; Java não permite herança de classes (só de interface), e esse é um ponto clássico de prova.

Polimorfismo

Polimorfismo (muitas formas) permite tratar objetos de classes diferentes por meio de uma interface comum, com cada um respondendo à sua maneira. No exemplo, o laço abaixo chama pontos() sem saber qual a classe exata:

for x in (analista, tecnico, servidor):
    print(x.pontos())

Saída: 120, 105 e 100. A chamada é resolvida em tempo de execução conforme o tipo real do objeto (ligação dinâmica). Duas formas costumam ser distinguidas:

Tipo	Ideia	Exemplo
Sobrescrita (override)	subclasse redefine método herdado, com a mesma assinatura	pontos() em Analista
Sobrecarga (overload)	mesmo nome de método com parâmetros diferentes na mesma classe	existe em Java e C++; em Python, não existe da mesma forma

Em Java, sobrecarga é resolvida na compilação (pelos tipos dos parâmetros) e sobrescrita, na execução.

Encapsulamento

Encapsulamento esconde o estado interno do objeto e expõe operações controladas. Na prática, atributos privados e métodos públicos que validam as alterações:

class Conta:
    def __init__(self, saldo):
        self.__saldo = saldo
    def depositar(self, v):
        if v <= 0:
            raise ValueError('valor invalido')
        self.__saldo += v
    @property
    def saldo(self):
        return self.__saldo

Com saldo inicial 10 e depósito de 5, o saldo lido foi 15. Tentar depositar -1 gerou ValueError: valor invalido, e acessar c.__saldo de fora gerou AttributeError. Em Python, a privacidade é por convenção: o nome com dois sublinhados sofre “desfiguração” de nome e continua acessível pelo nome alterado (c._Conta__saldo, que também devolveu 15). Em Java, private é imposto pelo compilador. Níveis de acesso típicos em Java: private (só a classe), padrão (o pacote), protected (pacote e subclasses) e public (todos).

Abstração, classe abstrata e interface

Abstração é focar no essencial. Uma classe abstrata não pode ser instanciada e pode declarar métodos sem implementação, que as subclasses devem implementar. No teste, tentar criar a classe abstrata Forma gerou TypeError: Can't instantiate abstract class Forma without an implementation for abstract method 'area', e uma subclasse Quad (quadrado) com lado 3 calculou área 9. Em Java, usa-se abstract para a classe e para os métodos.

Uma interface é um contrato: define o que uma classe deve oferecer, sem dizer como. Em Java, uma classe herda de uma única classe, mas pode implementar várias interfaces. A diferença que a prova costuma explorar: classe abstrata pode ter estado (atributos) e métodos já implementados; a interface, tradicionalmente, só especifica o contrato (versões modernas de Java permitem métodos com implementação padrão, mas a ideia de contrato permanece).

Herança múltipla e ordem de resolução

Em Python, com D(B, C), onde B e C herdam de A e cada um chama super().f(), a chamada D().f() devolveu 'BCA'. A ordem de busca de métodos, chamada MRO, foi: D, B, C, A, object. A ordem segue a declaração e garante que a superclasse comum apareça por último. É o chamado problema do diamante, que Java evita ao proibir herança múltipla de classes.

Resumo dos pilares

Pilar	Pergunta que responde
Abstração	o que importa modelar?
Encapsulamento	quem pode ver ou alterar o estado?
Herança	como reaproveitar e especializar?
Polimorfismo	como tratar tipos diferentes de modo uniforme?

Erros comuns

• Confundir classe (molde) com objeto (instância).
• Dizer que sobrescrita e sobrecarga são o mesmo conceito.
• Achar que herança serve para qualquer reuso; a relação deve ser “é um”.
• Esquecer que a classe abstrata não é instanciável.
• Afirmar que Java permite herança múltipla de classes.
• Tomar a convenção de privacidade do Python como proteção real.

Fontes e atualização

Não há norma oficial brasileira sobre programação orientada a objetos; o conteúdo segue a literatura clássica da área, e o exemplo em Python foi executado para conferir cada saída. As regras específicas de Java foram descritas em termos gerais; confira a versão da linguagem e a bibliografia no edital.

Próximos passos

• Pratique a sintaxe em Python: funções, escopo, exceções e pegadinhas.
• Veja a modelagem em UML: diagrama de classes, relações e multiplicidade.
• Retome estruturas em pilha, fila e lista.