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):
- 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:
já cria uma constante pública e imutável.
Passo 4
Implementando LampadaIncandescente (passo a passo e explicação):
- A classe precisa:
- atributo privado
do tipo ; - atributo privado
do tipo (watts); - construtor para inicializar
e opcionalmente (por padrão desligada); - implementar os métodos da interface Lampada.
- atributo privado
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:
- ligar():
- desligar():
- estaLigada():
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:
- LampadaDeNatal implementa Lampada e Cor:
- atributo privado
(boolean); - atributo privado
(String); - construtor que inicializa
(validar se é cor válida — se não, definir uma cor padrão); - método
: valida a nova cor contra as constantes da interface Cor (comparação case-insensitive) e atualiza se válida; se inválida, pode manter a cor e avisar no console.
- atributo privado
Validação simples (lógica explicada):
- Comparar
com cada constante usando equalsIgnoreCase para aceitar entradas como “vermelho” ou “Vermelho”. - Se encontrar correspondência, atribuir
(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.,
. - Criar uma instância de LampadaDeNatal com cor inicial, por ex.,
. - 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());
}
}