Escreva a interface Lampada representando o comportamento genérico de uma lâmpada. A interface deve conter os métodos ligar(), desligar() e estaLigada(), que retornam respectivamente a ação de ligar, desligar e verificar o estado da lâmpada. Em seguida, crie duas classes concretas que implementem essa interface: LampadaIncandescente e LampadaDeNatal.
A classe LampadaIncandescente deve conter os atributos ligada (para indicar se a lâmpada está ligada ou desligada) e potencia (para armazenar a potência em watts da lâmpada). Já a classe LampadaDeNatal deve implementar tanto a interface Lampada quanto a interface Cor. Além do atributo ligada, essa classe deve possuir um atributo corAtual, representando a cor atual da lâmpada natalina. A interface Cor deve conter constantes de cores padrão, como: “Vermelho”, “Verde”, “Azul” e “Amarelo”. Além disso, a classe LampadaDeNatal deve adicionar um método mudarCor(String novaCor) para alterar a cor atual da lâmpada.
Por fim, escreva uma classe principal (Main) que instancie objetos das duas classes e demonstre o funcionamento dos métodos implementados, exibindo no console o estado e as características de cada lâmpada.

Passo 1

O enunciado pede que eu crie uma estrutura em Java com as seguintes peças e comportamentos:
  • Deve haver uma interface chamada Lampada que contenha três métodos:
    • ligar() — ação de ligar a lâmpada;
    • desligar() — ação de desligar a lâmpada;
    • estaLigada() — que verifica e devolve se a lâmpada está ligada.
  • Deve haver uma interface chamada Cor que contenha constantes de cores padrão (strings): “Vermelho”, “Verde”, “Azul” e “Amarelo”.
  • Deve haver uma classe LampadaIncandescente que implemente a interface Lampada e contenha:
    • atributo para indicar se está ligada (por ex. ligada);
    • atributo potencia (em watts);
    • implementação dos métodos da interface.
  • Deve haver uma classe LampadaDeNatal que implemente as interfaces Lampada e Cor, e que contenha:
    • atributo ligada;
    • atributo corAtual (string com a cor atual);
    • método adicional mudarCor(String novaCor) para alterar a cor atual;
    • implementação dos métodos da interface Lampada;
    • (usar as constantes da interface Cor como cores válidas).
  • Deve haver uma classe Main com método main que instancie objetos das duas lâmpadas e demonstre no console o funcionamento dos métodos (ligar/desligar/mudarCor/estaLigada) exibindo o estado e características de cada uma.
Essas são as informações fornecidas pelo enunciado. Não devo pedir mais dados — vou assumir padrões razoáveis (por exemplo, métodos ligar/desligar são void e estaLigada retorna boolean).

Passo 2

Plano e decisões de projeto (por que escolhi isso):
  • Assumi assinaturas simples para os métodos da interface Lampada:
    • ligar(): void — liga a lâmpada;
    • desligar(): void — desliga a lâmpada;
    • estaLigada(): boolean — retorna true se estiver ligada.
      Essa escolha é a mais direta e a que o enunciado sugere (“retornam respectivamente a ação de ligar, desligar e verificar o estado”).
  • A interface Cor conterá constantes públicas, estáticas e finais (padrão em interfaces Java) com nomes em maiúsculas: VERMELHO, VERDE, AZUL, AMARELO, cada uma como String.
  • As classes concretas terão:
    • construtores para inicializar atributos importantes (por ex. potência e cor inicial);
    • método toString() para facilitar imprimir o estado ao mostrar no console;
    • validação simples em mudarCor para aceitar apenas as cores definidas em Cor (comparação case-insensitive) — assim o programa demonstra uso das constantes.
  • Vou usar modificadores privados para atributos e métodos públicos para a API, e anotar @Override nos métodos da interface para clareza.
Agora parto para explicar e implementar cada peça (didaticamente).

Passo 3

Entendendo interfaces em Java (aula rápida e didática):
  • Interface em Java é um contrato: define métodos que uma classe deve implementar. Não contém implementação (antes do Java 8), mas pode conter constantes.
  • Sintaxe básica (exemplo didático, não é todo o código final):
\text{public interface Lampada \{ void ligar(); void desligar(); boolean estaLigada(); \}}
  • Significado de cada parte:
    • public interface Lampada: declaração da interface pública chamada Lampada;
    • void ligar(): método que não retorna valor e representa a ação de ligar;
    • boolean estaLigada(): método que retorna um booleano — true/false — indicando o estado.
  • Constantes em interfaces são implicitamente public static final. Então declarar:
\text{String VERMELHO = "Vermelho";}
já cria uma constante pública e imutável.

Passo 4

Implementando LampadaIncandescente (passo a passo e explicação):
  • A classe precisa:
    • atributo privado \text{ligada} do tipo \text{boolean};
    • atributo privado \text{potencia} do tipo \text{int} (watts);
    • construtor para inicializar \text{potencia} e opcionalmente \text{ligada} (por padrão desligada);
    • implementar os métodos da interface Lampada.
Por que usar boolean e int?
  • boolean é o tipo natural para estados ligado/desligado.
  • int é suficiente para representar potência em watts sem complicar com floats.
Exemplo de assinatura do construtor e métodos (explicando a lógica):
  • Construtor:
\text{public LampadaIncandescente(int potencia) \{ this.potencia = potencia; this.ligada = false; \}}
  • ligar():
\text{public void ligar() \{ this.ligada = true; \}}
  • desligar():
\text{public void desligar() \{ this.ligada = false; \}}
  • estaLigada():
\text{public boolean estaLigada() \{ return this.ligada; \}}
Também é útil implementar um método toString() que retorne uma string legível com potência e estado, para exibir no console.

Passo 5

Implementando LampadaDeNatal e a interface Cor — fundamentos e método mudarCor:
  • Interface Cor terá constantes:
\text{String VERMELHO = "Vermelho";}\\\ \text{String VERDE = "Verde";}\\\ \text{String AZUL = "Azul";}\\\ \text{String AMARELO = "Amarelo";}
  • LampadaDeNatal implementa Lampada e Cor:
    • atributo privado \text{ligada} (boolean);
    • atributo privado \text{corAtual} (String);
    • construtor que inicializa \text{corAtual} (validar se é cor válida — se não, definir uma cor padrão);
    • método \text{mudarCor(String novaCor)}: valida a nova cor contra as constantes da interface Cor (comparação case-insensitive) e atualiza \text{corAtual} se válida; se inválida, pode manter a cor e avisar no console.
Validação simples (lógica explicada):
  • Comparar \text{novaCor} com cada constante usando equalsIgnoreCase para aceitar entradas como “vermelho” ou “Vermelho”.
  • Se encontrar correspondência, atribuir \text{this.corAtual = Constante} (usar a constante para manter capitalização consistente).
Também implementar toString() para mostrar estado e cor atual.

Passo 6

Classe Main — demonstrando comportamento no console (o que mostrar e por quê):
  • Criar uma instância de LampadaIncandescente com, por ex., \text{potencia = 60}.
  • Criar uma instância de LampadaDeNatal com cor inicial, por ex., \text{"Vermelho"}.
  • Exibir estado inicial (usar System.out.println(infoLâmpada.toString())).
  • Ligar as lâmpadas e exibir novamente.
  • Para LampadaDeNatal, usar mudarCor com uma cor válida e com uma inválida para demonstrar validação.
  • Desligar uma lâmpada e mostrar resultado final.
Motivação: quem vai fazer a prova tende a lembrar ações concretas (criar objeto, chamar métodos, imprimir).

Passo 7

Observações finais e dicas para a prova (resumo rápido de conceitos):
  • Interface = contrato; classe que implementa deve fornecer os métodos.
  • Constantes em interface são public static final automaticamente.
  • Use @Override para marcar implementações de métodos da interface (ajuda a detectar erros de assinatura).
  • Sempre pense em encapsulamento: atributos privados, métodos públicos.
  • Em uma prova, desenhe rapidamente as classes e os métodos antes de codar: quais atributos, quais métodos, assinaturas.
  • Agora, abaixo está o código final completo pronto para compilar e executar.

Resposta

// Interface Lampada
public interface Lampada {
    void ligar();
    void desligar();
    boolean estaLigada();
}

// Interface Cor com constantes de cores
public interface Cor {
    String VERMELHO = "Vermelho";
    String VERDE = "Verde";
    String AZUL = "Azul";
    String AMARELO = "Amarelo";
}

// Classe LampadaIncandescente que implementa Lampada
public class LampadaIncandescente implements Lampada {
    private boolean ligada;
    private int potencia; // em watts

    public LampadaIncandescente(int potencia) {
        this.potencia = potencia;
        this.ligada = false;
    }

    @Override
    public void ligar() {
        if (!this.ligada) {
            this.ligada = true;
            System.out.println("Lâmpada incandescente ligada.");
        } else {
            System.out.println("Lâmpada incandescente já está ligada.");
        }
    }

    @Override
    public void desligar() {
        if (this.ligada) {
            this.ligada = false;
            System.out.println("Lâmpada incandescente desligada.");
        } else {
            System.out.println("Lâmpada incandescente já está desligada.");
        }
    }

    @Override
    public boolean estaLigada() {
        return this.ligada;
    }

    public int getPotencia() {
        return this.potencia;
    }

    @Override
    public String toString() {
        return "LampadaIncandescente{potencia=" + this.potencia + "W, ligada=" + this.ligada + "}";
    }
}

// Classe LampadaDeNatal que implementa Lampada e Cor
public class LampadaDeNatal implements Lampada, Cor {
    private boolean ligada;
    private String corAtual;

    public LampadaDeNatal(String corInicial) {
        if (isCorValida(corInicial)) {
            // padroniza para a constante correta (mesma capitalização)
            this.corAtual = padronizarCor(corInicial);
        } else {
            this.corAtual = VERMELHO; // cor padrão se inválida
        }
        this.ligada = false;
    }

    @Override
    public void ligar() {
        if (!this.ligada) {
            this.ligada = true;
            System.out.println("Lâmpada de Natal ligada.");
        } else {
            System.out.println("Lâmpada de Natal já está ligada.");
        }
    }

    @Override
    public void desligar() {
        if (this.ligada) {
            this.ligada = false;
            System.out.println("Lâmpada de Natal desligada.");
        } else {
            System.out.println("Lâmpada de Natal já está desligada.");
        }
    }

    @Override
    public boolean estaLigada() {
        return this.ligada;
    }

    public String getCorAtual() {
        return this.corAtual;
    }

    public void mudarCor(String novaCor) {
        if (isCorValida(novaCor)) {
            this.corAtual = padronizarCor(novaCor);
            System.out.println("Cor da lâmpada de Natal alterada para: " + this.corAtual);
        } else {
            System.out.println("Cor inválida: \"" + novaCor + "\". Cores válidas: "
                    + VERMELHO + ", " + VERDE + ", " + AZUL + ", " + AMARELO + ".");
        }
    }

    // Helper: verifica se a string corresponde a uma das constantes (case-insensitive)
    private boolean isCorValida(String cor) {
        if (cor == null) return false;
        String c = cor.trim();
        return c.equalsIgnoreCase(VERMELHO)
                || c.equalsIgnoreCase(VERDE)
                || c.equalsIgnoreCase(AZUL)
                || c.equalsIgnoreCase(AMARELO);
    }

    // Helper: retorna a constante com a capitalização padronizada
    private String padronizarCor(String cor) {
        String c = cor.trim();
        if (c.equalsIgnoreCase(VERMELHO)) return VERMELHO;
        if (c.equalsIgnoreCase(VERDE)) return VERDE;
        if (c.equalsIgnoreCase(AZUL)) return AZUL;
        if (c.equalsIgnoreCase(AMARELO)) return AMARELO;
        return VERMELHO; // fallback (não deve acontecer se validado antes)
    }

    @Override
    public String toString() {
        return "LampadaDeNatal{corAtual=" + this.corAtual + ", ligada=" + this.ligada + "}";
    }
}

// Classe Main para demonstrar o funcionamento
public class Main {
    public static void main(String[] args) {
        // Instancia lâmpada incandescente de 60W
        LampadaIncandescente incandescente = new LampadaIncandescente(60);
        System.out.println(incandescente.toString());
        incandescente.ligar();
        System.out.println("Estado após ligar: ligada = " + incandescente.estaLigada());
        incandescente.desligar();
        System.out.println("Estado após desligar: ligada = " + incandescente.estaLigada());
        System.out.println();

        // Instancia lâmpada de Natal com cor inicial Vermelho
        LampadaDeNatal natal = new LampadaDeNatal(Cor.VERMELHO);
        System.out.println(natal.toString());
        natal.ligar();
        System.out.println("Estado após ligar: ligada = " + natal.estaLigada() + ", cor = " + natal.getCorAtual());

        // Muda para uma cor válida
        natal.mudarCor("Azul");
        System.out.println("Depois de mudarCor(\"Azul\"): cor = " + natal.getCorAtual());

        // Tenta mudar para uma cor inválida
        natal.mudarCor("Roxo");
        System.out.println("Depois de mudarCor(\"Roxo\"): cor = " + natal.getCorAtual());

        natal.desligar();
        System.out.println("Estado final: " + natal.toString());
    }
}

Exercícios relacionados