Objetivo da Aula

Entender o conceito de Interfaces em POO, criando contratos que classes devem seguir, usando exemplos do universo DC.

Aula 04: Interfaces

Conceito de Interface

O que é uma Interface?

Uma interface é um contrato que define o que uma classe deve fazer, mas não como fazer. É uma lista de métodos que uma classe deve implementar.

Analogia: Uma interface é como um contrato de trabalho. Define o que você deve fazer (responsabilidades), mas não como fazer (implementação).

Características

✅ Define apenas assinaturas de métodos (sem implementação)
✅ Não pode ter campos/variáveis
✅ Pode ter propriedades (mas são abstratas)
✅ Uma classe pode implementar múltiplas interfaces
✅ Não pode ser instanciada diretamente

Por que Usar Interfaces?

Contratos: Garante que classes implementem métodos específicos
Flexibilidade: Uma classe pode implementar várias interfaces
Polimorfismo: Tratar objetos diferentes de forma uniforme
Desacoplamento: Código mais flexível e fácil de manter

Exemplos de Interfaces no Universo DC

Interface: IVoador (Pode Voar)

// TÓPICO: Definição de Interface
// Interfaces começam com 'I' por convenção (IVoador, IPoder, etc.)
// 'interface' define um contrato que classes devem seguir
public interface IVoador
{
    // TÓPICO: Método de Interface
    // Interfaces só definem a ASSINATURA do método (nome, parâmetros, retorno)
    // NÃO definem a IMPLEMENTAÇÃO (o código dentro do método)
    // Qualquer classe que implementar IVoador DEVE ter este método

    void Voar();

    // TÓPICO: Propriedade em Interface
    // Interfaces podem ter propriedades, mas são abstratas
    // A classe que implementar deve fornecer get e set
    int AltitudeMaxima { get; set; }

    // Outro método da interface
    void Pousar();
}

Interface: ICorredor (Pode Correr Rápido)

// TÓPICO: Interface para Corredores
// Define o contrato para personagens que correm muito rápido
public interface ICorredor
{
    // Método para correr
    void Correr();

    // Propriedade para velocidade máxima
    int VelocidadeMaxima { get; set; }

    // Método para criar tornado (efeito da velocidade)
    void CriarTornado();
}

Interface: IInteligente (Tem Inteligência Superior)

// TÓPICO: Interface para Personagens Inteligentes
public interface IInteligente
{
    // Método para resolver problemas
    void ResolverProblema(string problema);

    // Propriedade para QI
    int QI { get; set; }

    // Método para criar invenções
    void CriarInvencao(string invencao);
}

Implementando Interfaces nas Classes

TÓPICO: Usando Classes Já Criadas

IMPORTANTE: As interfaces são explicadas usando as classes Heroi e Vilao que já foram criadas nas aulas anteriores. Não criamos classes específicas como "Batman" ou "Flash" - esses são apenas objetos (instâncias) das classes Heroi e Vilao.

Heroi Implementando Interfaces

// TÓPICO: Implementação de Múltiplas Interfaces
// Uma classe pode implementar várias interfaces usando vírgula
// Usamos a classe Heroi (já criada) e adicionamos interfaces a ela
// Heroi pode implementar IVoador e IInteligente
public class Heroi : Personagem, IVoador, IInteligente
{
    public string Equipe { get; set; }
    public int VidasSalvas { get; set; }

    // TÓPICO: Propriedades de Interfaces
    // DEVE implementar propriedades das interfaces
    public int AltitudeMaxima { get; set; }  // De IVoador
    public int QI { get; set; }              // De IInteligente

    public Heroi(string nome, int nivel, string equipe) : base(nome, nivel)
    {
        Equipe = equipe;
        VidasSalvas = 0;
    }

    // TÓPICO: Implementação de Métodos de Interface
    // DEVE implementar TODOS os métodos das interfaces implementadas

    // Implementação de IVoador
    public void Voar()
    {
        Console.WriteLine($"{Nome} está voando a {AltitudeMaxima} metros de altitude!");
    }

    public void Pousar()
    {
        Console.WriteLine($"{Nome} pousou suavemente no chão.");
    }

    // Implementação de IInteligente
    public void ResolverProblema(string problema)
    {
        Console.WriteLine($"{Nome} (QI: {QI}) está resolvendo: {problema}");
        Console.WriteLine("Problema resolvido com sucesso!");
    }

    public void CriarInvencao(string invencao)
    {
        Console.WriteLine($"{Nome} criou a invenção: {invencao}");
    }

    // Métodos da classe base (abstratos)
    public override void UsarPoder()
    {
        Console.WriteLine($"{Nome} usa seu poder para proteger os inocentes!");
    }

    public override void Apresentar()
    {
        Console.WriteLine($"Olá! Eu sou {Nome}, herói da {Equipe}, nível {Nivel}!");
    }
}

Vilao Implementando Interfaces

// TÓPICO: Classe Vilao Implementando Interfaces
// Vilao pode implementar interfaces diferentes de Heroi
// Exemplo: Lex Luthor é inteligente, Darkseid pode voar
public class Vilao : Personagem, IInteligente, IVoador
{
    public string Organizacao { get; set; }
    public int PlanosExecutados { get; set; }

    // TÓPICO: Propriedades de Interfaces
    // Implementa propriedades das interfaces
    public int QI { get; set; }              // De IInteligente
    public int AltitudeMaxima { get; set; }  // De IVoador

    public Vilao(string nome, int nivel, string organizacao) : base(nome, nivel)
    {
        Organizacao = organizacao;
        PlanosExecutados = 0;
    }

    // TÓPICO: Implementação de IInteligente
    public void ResolverProblema(string problema)
    {
        Console.WriteLine($"{Nome} (QI: {QI}) está planejando: {problema}");
        Console.WriteLine("Plano maléfico criado!");
    }

    public void CriarInvencao(string invencao)
    {
        Console.WriteLine($"{Nome} criou a invenção maléfica: {invencao}");
    }

    // TÓPICO: Implementação de IVoador
    public void Voar()
    {
        Console.WriteLine($"{Nome} está voando a {AltitudeMaxima} metros!");
    }

    public void Pousar()
    {
        Console.WriteLine($"{Nome} pousou com intenções sombrias.");
    }

    // Métodos da classe base
    public override void UsarPoder()
    {
        Console.WriteLine($"{Nome} usa seu poder para causar caos!");
    }

    public override void Apresentar()
    {
        Console.WriteLine($"Cuidado! Eu sou {Nome}, vilão da {Organizacao}!");
    }
}

Usando Interfaces

Exemplo: Lista de Voadores

// TÓPICO: Polimorfismo com Interfaces
// Podemos tratar objetos diferentes de forma uniforme através da interface
List<IVoador> voadores = new List<IVoador>();

// TÓPICO: Criando Objetos da Classe Heroi
// Superman é um OBJETO (instância) da classe Heroi
// A classe Heroi implementa IVoador, então seus objetos podem voar
Heroi heroiQueVoa = new Heroi("Herói que Voa", 100, "Liga da Justiça");
heroiQueVoa.AltitudeMaxima = 10000;  // Configurando propriedade da interface

// Adicionando à lista de voadores
voadores.Add(heroiQueVoa);

// Iterando sobre voadores
foreach (IVoador voador in voadores)
{
    // Todos podem voar, independente de serem heróis ou vilões
    voador.Voar();      // Polimorfismo através da interface!
    voador.Pousar();
}

Exemplo: Lista de Corredores

// TÓPICO: Usando Interface ICorredor
// Criando herói que implementa ICorredor
// (Usando a classe Heroi que implementa a interface, não uma classe Flash específica)
List<ICorredor> corredores = new List<ICorredor>();

// TÓPICO: Criando Objeto que Implementa Interface
// Criamos um objeto Heroi e o tratamos como ICorredor
// (Em código real, Heroi precisaria implementar ICorredor)
Heroi heroiRapido = new Heroi("Herói Rápido", 90, "Liga da Justiça");
// Se Heroi implementasse ICorredor:
// corredores.Add(heroiRapido);

foreach (ICorredor corredor in corredores)
{
    corredor.Correr();
    corredor.CriarTornado();
}

Exemplo: Lista de Inteligentes

// TÓPICO: Usando Interface IInteligente
// Usando as classes Heroi e Vilao que implementam IInteligente
List<IInteligente> inteligentes = new List<IInteligente>();

// TÓPICO: Objetos de Classes Diferentes na Mesma Lista
// Heroi e Vilao podem estar na mesma lista através da interface
Heroi heroiInteligente = new Heroi("Herói Inteligente", 85, "Liga da Justiça");
heroiInteligente.QI = 192;
inteligentes.Add(heroiInteligente);

Vilao vilaoInteligente = new Vilao("Vilão Inteligente", 80, "Legião do Mal");
vilaoInteligente.QI = 200;
inteligentes.Add(vilaoInteligente);

// TÓPICO: Polimorfismo através da Interface
// Trata objetos diferentes (Heroi e Vilao) de forma uniforme
foreach (IInteligente inteligente in inteligentes)
{
    inteligente.ResolverProblema("Problema complexo");
    inteligente.CriarInvencao("Invenção poderosa");
}

Comparação: Interface vs Classe Abstrata

Aspecto	Interface	Classe Abstrata
Implementação	Apenas assinaturas	Pode ter implementação
Múltipla Herança	✅ SIM (múltiplas interfaces)	❌ NÃO (uma classe base)
Campos/Variáveis	❌ NÃO	✅ SIM
Construtores	❌ NÃO	✅ SIM
Modificadores	Todos públicos	Podem ser privados/protegidos
Quando usar	Contratos, capacidades	Código compartilhado + contrato

Resumo

✅ Interface: Contrato que define o que uma classe deve fazer
✅ interface: Palavra-chave para definir interface
✅ : Interface: Implementa uma interface
✅ Múltiplas Interfaces: Classe pode implementar várias interfaces
✅ Polimorfismo: Tratar objetos diferentes através da interface

Próxima Aula

Na próxima aula, veremos Polimorfismo em detalhes e como objetos diferentes podem ser tratados de forma uniforme.

← Aula 03 ← Índice Aula 05 →

🎓 Aulas de Programação Orientada a Objetos