[classe abstrata, herança, sobrescrita, polimorfismo] Crie uma hierarquia de classes para representar os diferentes tipos de funcionários de um escritório que tem os seguintes cargos: gerente, assistente, vendedor. Escreva uma classe base abstrata chamada Funcionario que declara um método abstrato:

public double calculaSalario()

Esta classe também deve definir os seguintes atributos: nome (tipo String), matricula (tipo String) e salario_base (tipo double). Use encapsulamento e forneça um construtor que recebe os valores correspondentes a serem armazenados nos respectivos atributos. Esta classe abstrata deverá ser estendida pelas outras classes representativas dos tipos de funcionários, portanto devem ser escritas as classes Gerente, Assistente e Vendedor. Em cada classe deve-se sobrescrever o método calculaSalario de forma que cálculo do salário é feito assim: O gerente recebe duas vezes o salário_base, o assistente recebe o salário_base e o vendedor
recebe o salário_base mais uma comissão definida no construtor de sua classe. Crie uma classe Teste com um método main que cria um objeto de cada tipo e os armazena em uma lista e depois calcula a folha salarial dos três funcionários e imprime o valor total. Indique quais conceitos de POO você usou e como foi usado.

Passo 1

Beleza, vamos entender o que a questão está pedindo. Precisamos criar uma hierarquia de classes para diferentes tipos de funcionários de um escritório: gerente, assistente e vendedor. Vamos usar conceitos de Programação Orientada a Objetos (POO) como classe abstrata, herança, sobrescrita de métodos e polimorfismo. Para isso, vamos criar uma classe base abstrata chamada Funcionario com atributos nome, matricula e salario_base. Essa classe terá um método abstrato calculaSalario() que será implementado nas classes filhas (Gerente, Assistente e Vendedor). No final, vamos fazer um teste criando um objeto de cada tipo, armazenando em uma lista, calculando a folha salarial total e imprimindo o valor.

Passo 2

Primeiro, vamos criar a classe abstrata Funcionario. Como é uma classe abstrata, ela não pode ser instanciada diretamente e terá pelo menos um método abstrato que as classes filhas precisam implementar.
public abstract class Funcionario {
    private String nome;
    private String matricula;
    private double salario_base;

    public Funcionario(String nome, String matricula, double salario_base) {
        this.nome = nome;
        this.matricula = matricula;
        this.salario_base = salario_base;
    }

    public String getNome() {
        return nome;
    }

    public String getMatricula() {
        return matricula;
    }

    public double getSalario_base() {
        return salario_base;
    }

    public abstract double calculaSalario();
}
Aqui, usamos encapsulamento para proteger os atributos, tornando-os privados e fornecendo métodos get para acessá-los. O método calculaSalario() é abstrato porque cada tipo de funcionário vai calcular o salário de forma diferente.

Passo 3

Agora, vamos criar as classes filhas que estendem Funcionario e implementam o método calculaSalario() de acordo com as regras:

Classe Gerente

O gerente recebe duas vezes o salário base.
public class Gerente extends Funcionario {

    public Gerente(String nome, String matricula, double salario_base) {
        super(nome, matricula, salario_base);
    }

    @Override
    public double calculaSalario() {
        return 2 * getSalario_base();
    }
}

Classe Assistente

O assistente recebe o salário base.
public class Assistente extends Funcionario {

    public Assistente(String nome, String matricula, double salario_base) {
        super(nome, matricula, salario_base);
    }

    @Override
    public double calculaSalario() {
        return getSalario_base();
    }
}

Classe Vendedor

O vendedor recebe o salário base mais uma comissão definida no construtor.
public class Vendedor extends Funcionario {
    private double comissao;

    public Vendedor(String nome, String matricula, double salario_base, double comissao) {
        super(nome, matricula, salario_base);
        this.comissao = comissao;
    }

    public double getComissao() {
        return comissao;
    }

    @Override
    public double calculaSalario() {
        return getSalario_base() + comissao;
    }
}
Aqui, na classe Vendedor, adicionamos um atributo comissao e modificamos o construtor para recebê-la. O método calculaSalario() soma o salário base com a comissão.

Passo 4

Agora, vamos criar a classe de teste que vai criar objetos de cada tipo de funcionário, armazená-los em uma lista, calcular a folha salarial total e imprimir o valor.
import java.util.ArrayList;
import java.util.List;

public class Teste {
    public static void main(String[] args) {
        List<Funcionario> funcionarios = new ArrayList<>();

        Funcionario gerente = new Gerente("Ana", "G001", 5000.0);
        Funcionario assistente = new Assistente("Bruno", "A001", 3000.0);
        Funcionario vendedor = new Vendedor("Carlos", "V001", 2500.0, 1500.0);

        funcionarios.add(gerente);
        funcionarios.add(assistente);
        funcionarios.add(vendedor);

        double folhaSalarial = 0.0;
        for (Funcionario f : funcionarios) {
            folhaSalarial += f.calculaSalario();
        }

        System.out.println("Folha Salarial Total: R$ " + folhaSalarial);
    }
}
Nesse trecho, usamos uma lista (ArrayList) para armazenar os diferentes funcionários. Utilizamos o polimorfismo ao tratar todos os objetos como do tipo Funcionario, mesmo sendo instâncias de Gerente, Assistente ou Vendedor. Ao chamar calculaSalario(), o método apropriado de cada classe é executado.

Resposta

Implementando as classes conforme os passos acima, a folha salarial total será calculada e impressa corretamente. No exemplo dado, com os salários e comissão definidos, a saída será:
Folha Salarial Total: R$ 11500.0

Exercícios relacionados