Aula 14: Classes Abstratas

Por que usar Classes Abstratas?

• **Forçar Implementação:** Garante que todas as subclasses sigam um padrão e implementem os métodos essenciais.
• **Definir Interfaces:** Cria uma interface comum para um grupo de classes relacionadas, mesmo que a implementação de cada método seja diferente.
• **Reutilização de Código:** Classes abstratas podem ter métodos concretos (não abstratos) que são herdados pelas subclasses.
• **Melhorar a Organização:** Ajuda a modelar sistemas complexos de forma mais clara e estruturada.

Métodos Abstratos

Um método abstrato é um método declarado em uma classe abstrata, mas que não possui implementação na própria classe abstrata. Ele serve como um placeholder que DEVE ser implementado por qualquer subclasse concreta que herdar dela.

# Exemplo conceitual (não Python real ainda)
class ClasseAbstrata:
    def metodo_abstrato(self):
        # Nenhuma implementação aqui
        pass 

class ClasseConcreta(ClasseAbstrata):
    def metodo_abstrato(self):
        # Implementação OBRIGATÓRIA aqui
        print("Método abstrato implementado!")

# obj_abstrato = ClasseAbstrata() # Isso não seria permitido!
# obj_concreto = ClasseConcreta() # Isso seria permitido!

Como Usar o Módulo `abc`

Você precisa importar `ABC` (Abstract Base Class) e `abstractmethod` de `abc`:

from abc import ABC, abstractmethod

Para tornar uma classe abstrata, ela deve herdar de `ABC`.

Para definir um método como abstrato, use o decorador `@abstractmethod` sobre o método. Esse método não terá corpo na classe abstrata, apenas `pass`.

Classes `FormaGeometrica`, `Circulo` e `Retangulo`

from abc import ABC, abstractmethod
import math

class FormaGeometrica(ABC): # Herda de ABC
    @abstractmethod # Decorador para método abstrato
    def calcular_area(self):
        pass # Nenhuma implementação aqui, apenas um contrato

    def exibir_info(self): # Método concreto (não abstrato)
        print("Esta é uma forma geométrica.")

class Circulo(FormaGeometrica):
    def __init__(self, raio):
        self.raio = raio

    def calcular_area(self): # Implementação obrigatória para Circulo
        return math.pi * (self.raio ** 2)

class Retangulo(FormaGeometrica):
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura

    def calcular_area(self): # Implementação obrigatória para Retangulo
        return self.largura * self.altura

# Exemplo de uso:
# # forma = FormaGeometrica() # Isso geraria um TypeError! Não pode ser instanciada.

# circulo = Circulo(5)
# print(f"Área do Círculo: {circulo.calcular_area():.2f}")
# circulo.exibir_info() # Método concreto herdado

# retangulo = Retangulo(4, 6)
# print(f"Área do Retângulo: {retangulo.calcular_area():.2f}")
# retangulo.exibir_info() # Método concreto herdado

Classes Abstratas (Simuladas)

Aqui, simulamos o comportamento de um método abstrato forçando um erro se ele não for sobrescrito, e impedindo a instanciação direta da classe base.

// Simulação de classes abstratas 
# Importa as ferramentas necessárias do módulo de Classes Abstratas (abc)
from abc import ABC, abstractmethod
import math

class FormaGeometrica(ABC):
    """
    Esta é uma Classe Abstrata (Abstract Base Class - ABC).
    Ela serve como um "contrato" que define métodos que suas subclasses
    são obrigadas a implementar.
    Não é possível criar um objeto diretamente desta classe.
    """
    @abstractmethod
    def calcular_area(self):
        """
        Este é um método abstrato. Qualquer classe que herdar de
        FormaGeometrica DEVE implementar seu próprio método calcular_area.
        """
        pass

class Circulo(FormaGeometrica):
    """
    Subclasse concreta que herda de FormaGeometrica.
    """
    def __init__(self, raio):
        self.raio = raio
    
    def calcular_area(self):
        """
        Implementação obrigatória e específica do método abstrato.
        """
        return math.pi * (self.raio ** 2)

class Retangulo(FormaGeometrica):
    """
    Outra subclasse concreta que herda de FormaGeometrica.
    """
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura
    
    def calcular_area(self):
        """
        Implementação obrigatória e específica do método abstrato.
        """
        return self.largura * self.altura
# 1. Criando instâncias das classes concretas
circulo = Circulo(10)
retangulo = Retangulo(5, 4)

print(f"Área do Círculo: {circulo.calcular_area():.2f}")
print(f"Área do Retângulo: {retangulo.calcular_area()}")

# 2. O que acontece se tentarmos instanciar a classe abstrata?
try:
    forma = FormaGeometrica()
except TypeError as e:
    print(f"\nErro ao tentar instanciar a classe abstrata: {e}")

# 3. O que acontece se uma subclasse não implementar o método abstrato?
class Triangulo(FormaGeometrica):
    def __init__(self, base, altura):
        self.base = base
        self.altura = altura
    # OBS: Note que não implementamos o método 'calcular_area()'

try:
    triangulo = Triangulo(10, 5)
except TypeError as e:
    print(f"Erro ao tentar instanciar uma subclasse incompleta: {e}")