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 atributos nome e salario e um método calcularSalario().
  • Duas subclasses que herdam de Empregado:
    • EmpregadoFixo, que tem salário fixo.
    • EmpregadoPorHora, que calcula o salário a partir de horasTrabalhadas e valorHora.
  • Uma classe de teste (TesteEmpregados) que usa um ArrayList<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á:
  1. Campos privados nome e salario.
  2. Construtor para inicializar esses campos.
  3. Getters e setters (encapsulamento).
  4. Método calcularSalario(), que na classe base simplesmente retorna o campo salario.
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:
  1. Cria um ArrayList<Empregado>.
  2. Adiciona um EmpregadoFixo e um EmpregadoPorHora.
  3. 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étodo calcularSalario().
  • EmpregadoFixo reutiliza o salário da superclasse.
  • EmpregadoPorHora soma horas trabalhadas vezes valor da hora.
  • TesteEmpregados usa um ArrayList<Empregado> para demonstrar herança e polimorfismo e calcula o total de salários.

Exercícios relacionados