QUESTÃO 3. (3 PONTOS) Crie uma classe Empregado com atributos de nome e salário e um método calcularSalario. Em seguida, crie duas classes que herdam de Empregado: EmpregadoFixo e EmpregadoPorHora. O EmpregadoFixo terá salário fixo (atributo), e o EmpregadoPorHoras terá salário baseado nas horas trabalhadas e no valor da hora (dois atributos).
Faça uma classe TesteEmpregados e utilize um ArrayList para armazenar um funcionário do tipo EmpregadoFixo e um do tipo EmpregadoPorHoras (no mesmo ArrayList) e calcular o salário total de todos os Empregados. Obs: Use encapsulamento nos membros da classe.
Passo 1
O enunciado pede para criarmos uma hierarquia de classes em Java:
- Uma classe base
Empregado
com atributosnome
esalario
e um métodocalcularSalario()
. - Duas subclasses que herdam de
Empregado
:EmpregadoFixo
, que tem salário fixo.EmpregadoPorHora
, que calcula o salário a partir dehorasTrabalhadas
evalorHora
.
- Uma classe de teste (
TesteEmpregados
) que usa umArrayList<Empregado>
para guardar instâncias de ambos os tipos e soma todos os salários.
O conteúdo aqui é orientação a objetos em Java: encapsulamento, herança e polimorfismo.
Passo 2
Vamos criar a classe base
Empregado
. Ela terá:- Campos privados
nome
esalario
. - Construtor para inicializar esses campos.
- Getters e setters (encapsulamento).
- Método
calcularSalario()
, que na classe base simplesmente retorna o camposalario
.
public class Empregado {
private String nome;
private double salario;
public Empregado(String nome, double salario) {
this.nome = nome;
this.salario = salario;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public double getSalario() {
return salario;
}
public void setSalario(double salario) {
this.salario = salario;
}
/**
* Método que retorna o salário.
* Nas subclasses esse método pode ser sobrescrito.
*/
public double calcularSalario() {
return salario;
}
}
Passo 3
Agora criamos
EmpregadoFixo
, que herda de Empregado
e não adiciona nada de novo — só reutiliza o salário fixo da superclasse:public class EmpregadoFixo extends Empregado {
public EmpregadoFixo(String nome, double salarioFixo) {
super(nome, salarioFixo);
}
// Herda calcularSalario() de Empregado, que já devolve o salário fixo.
}
Passo 4
Em seguida,
EmpregadoPorHora
terá dois atributos próprios: horasTrabalhadas
e valorHora
. A gente sobrescreve calcularSalario()
para usar esses dois campos:public class EmpregadoPorHora extends Empregado {
private double horasTrabalhadas;
private double valorHora;
public EmpregadoPorHora(String nome, double horasTrabalhadas, double valorHora) {
super(nome, 0.0); // salário da superclasse não será usado
this.horasTrabalhadas = horasTrabalhadas;
this.valorHora = valorHora;
}
public double getHorasTrabalhadas() {
return horasTrabalhadas;
}
public void setHorasTrabalhadas(double horasTrabalhadas) {
this.horasTrabalhadas = horasTrabalhadas;
}
public double getValorHora() {
return valorHora;
}
public void setValorHora(double valorHora) {
this.valorHora = valorHora;
}
/**
* Polimorfismo: aqui o salário é horasTrabalhadas * valorHora.
*/
@Override
public double calcularSalario() {
return horasTrabalhadas * valorHora;
}
}
Passo 5
Por fim, a classe de teste
TesteEmpregados
faz o seguinte:- Cria um
ArrayList<Empregado>
. - Adiciona um
EmpregadoFixo
e umEmpregadoPorHora
. - Percorre a lista, chama
calcularSalario()
em cada um (polimorfismo!) e soma tudo.
import java.util.ArrayList;
public class TesteEmpregados {
public static void main(String[] args) {
ArrayList<Empregado> lista = new ArrayList<>();
// cria um empregado com salário fixo de 3000
EmpregadoFixo eFixo = new EmpregadoFixo("João", 3000.0);
// cria um empregado que trabalhou 120 horas a 25 por hora
EmpregadoPorHora eHora = new EmpregadoPorHora("Maria", 120, 25.0);
lista.add(eFixo);
lista.add(eHora);
double totalSalarios = 0.0;
for (Empregado e : lista) {
totalSalarios += e.calcularSalario();
}
System.out.println("Salário total de todos os empregados: " + totalSalarios);
}
}
Resposta
As quatro classes acima implementam o que foi solicitado:
Empregado
com campos privados, getters/setters e métodocalcularSalario()
.EmpregadoFixo
reutiliza o salário da superclasse.EmpregadoPorHora
soma horas trabalhadas vezes valor da hora.TesteEmpregados
usa umArrayList<Empregado>
para demonstrar herança e polimorfismo e calcula o total de salários.