Ola pessoal,
È o seguinte, tenho que fazer esses exercicios:
1 . Utilizando o conceito de encapsulamento, crie uma superclasse abstrata Empregado.
Ex.: public abstract class Empregado{ }.
A classe deve declarar os atributos nome, sobrenome e CPF de um empregado. Esses atributos devem ser inicializados por meio de um construtor da classe.
Sobrescreva o método toString(), herdado da superclasse Object, para que ele retorne uma representação de string de Empregado.
Crie o método abstrato remuneracao() que será implementado pelas subclasses de Empregado.
Ex.: public abstract double remuneracao().
public abstract class Empregado {
private String nome,sobrenome,cpf;
public Empregado(String nome, String sobrenome, String cpf){
this.nome = nome;
this.sobrenome = sobrenome;
this.cpf = cpf;
}
public void setCpf(String cpf){
this.cpf = cpf;
}
public String getCpf(){
return cpf;
}
public void setSobrenome(String sobrenome){
this.sobrenome = sobrenome;
}
public String getSobrenome(){
return sobrenome;
}
public void setNome(String nome){
this.nome = nome;
}
public String getNome(){
return nome;
}
public String toString(){
return String.format("O nome do empregado é : %s %s\n O cpf do empregado é %s",getNome(),getSobrenome(),getCpf());
}
public abstract double remuneracao();
}
A classe deve declarar o atributo salario. Esse atributo deve ser inicializado no construtor da classe, porém por meio de seu método set() correspondente.
O salário será validado pelo método set() correspondente. Dessa forma, caso o salário fornecido na criação de um objeto da classe seja menor que zero, deverá ser atribuído zero ao salário; caso contrário, será atribuído o salário fornecido.
Sobrescreva o método toString(), herdado da superclasse Empregado, para que ele retorne uma representação de string de EmpregadoAssalariado.
Implemente o método abstrato remuneracao(), da superclasse abstrata, de forma que ele retorne o salário do empregado.
//import javax.swing.JOptionPane;
public class EmpregadoAssalariado extends Empregado {
private double salario;
public EmpregadoAssalariado(String nome, String sobrenome, String cpf, double salario){
super(nome, sobrenome ,cpf);
setSalario(salario);
}
public void setSalario(double salario){
this.salario = salario<=0.0 ? 0 : salario;
}
public double getSalario(){
return salario;
}
public String toString(){
return String.format("%s\n O salario do empregado assalariado é : %.2f",super.toString(),remuneracao());
}
public double remuneracao(){
return getSalario();
}
}
3. Estenda a superclasse Empregado e crie uma subclasse concreta EmpregadoHorista.
A classe deve declarar os atributos horasTrab(quantidade de horas trabalhadas) e salarioHora(valor da hora trabalhada). Esses atributos devem ser inicializados no construtor da classe, porém por meio de seus métodos set() correspondentes.
As horas trabalhadas devem ser validadas de forma que, caso a quantidade de horas trabalhas fornecidas seja menor que zero, deverá ser atribuído zero a horasTrab; caso contrário, estando a quantidade de horas trabalhadas dentro do intervalo fechado 0-168, será atribuída a quantidade de horas fornecidas.
Valide o valor da hora trabalhada da mesma forma que foi validado o salário no exercício anterior.
Sobrescreva o método toString(), herdado da superclasse Empregado, para que ele retorne uma representação de string de EmpregadoHorista.
Implemente o método abstrato remuneracao(), de forma que ele retorne o salário do empregado da seguinte forma:
//import javax.swing.JOptionPane;
public class EmpregadoHorista extends Empregado {
private double horasTrab, salarioHora;
public EmpregadoHorista(String nome, String sobrenome, String cpf, double horasTrab, double salarioHora){
super(nome, sobrenome, cpf);
setHorasTrab(horasTrab);
setSalarioHora(salarioHora);
}
public void setHorasTrab(double horasTrab){
if(horasTrab <= 0)
{
this.horasTrab = 0;
}
else
if(horasTrab >0 && horasTrab<=168)
{
this.horasTrab = horasTrab;
}
}
public double getHorasTrab(){
return horasTrab;
}
public void setSalarioHora(double salarioHora){
this.salarioHora = salarioHora;
}
public double getSalarioHora(){
return salarioHora;
}
public String toString(){
return String.format("%s\n O salario do empregado horista é : %.2f",super.toString(),remuneracao());
}
public double remuneracao(){
if(horasTrab >= 40)
{
this.salarioHora = (horasTrab - 40) * (50 * getSalarioHora()/100 + getSalarioHora());
}
else
{
this.salarioHora = getHorasTrab() * getSalarioHora();
}
return salarioHora;
}
}
Agora devo criar outra classe, EmpregadoComissionado:
//import javax.swing.JOptionPane;
public class EmpregadoComissionado extends Empregado {
private double totalVendas,comissao;
public EmpregadoComissionado(String nome, String sobrenome, String cpf, double totalVendas, double comissao){
super(nome, sobrenome ,cpf);
setTotalVendas(totalVendas);
setComissao(comissao);
}
public void setTotalVendas(double totalVendas){
if(totalVendas<= 0 )
{
this.totalVendas = 0;
}
else
{
this.totalVendas = totalVendas;
}
}
public double getTotalVendas(){
return totalVendas;
}
public void setComissao(double comissao){
if(totalVendas<0)
{
this.comissao = 0;
}
else
if(comissao >0 && comissao < 100)
{
this.comissao= comissao;
}
}
public double getComissao(){
return comissao;
}
public String toString(){
return String.format("%s\n O salario do empregado comissionado é : %.2f\n ",super.toString(),remuneracao() );
}
public double remuneracao(){
double salario = getComissao() * getTotalVendas() / 100;
if(salario <= 5000)
{
salario = salario - 10 * salario /100;
}
else
if(salario > 5000)
{
salario = salario - 30 * salario /100;
}
return salario;
}
}
Agora devo criar outra classe, para demostrar o processamento polimorfico da hierarquia de classes criada nos exercicios anteriores.
Caso o objeto sendo referenciado seja um objeto EmpregadoAssalariado , o salário do empregado deverá ser acrescido de 15% , a título de reajuste
salarial.
OK, eu fiz essa classe para demostrar o polimorfismo:
public class EmpregadoPolimorfo {
public static void main(String[] args) {
EmpregadoHorista empregadoHorista = new EmpregadoHorista("Luiz","Marques","[CPF removido]",80,10);
EmpregadoAssalariado empregadoAssalariado = new EmpregadoAssalariado("Ricardo","Souza","[CPF removido]",545.00);
EmpregadoComissionado empregadoComissionado = new EmpregadoComissionado("Charles","Silva Santos","[CPF removido]",1000,50);
Empregado[] empregado = {empregadoHorista, empregadoAssalariado,empregadoComissionado};
EmpregadoPolimorfo empregadoPolimorfo = new EmpregadoPolimorfo();
empregadoPolimorfo.demostraPolimorfismo(empregado);
}
public void demostraPolimorfismo(Empregado[] empregado){
for(Empregado funcionario : empregado)
{
if(funcionario instanceof EmpregadoAssalariado)
{
EmpregadoAssalariado empregadoAssalariado = (EmpregadoAssalariado) funcionario;// Downcast
empregadoAssalariado.setSalario(empregadoAssalariado.getSalario()* 1.08);
String sAux = String.format("%s",empregadoAssalariado);
JOptionPane.showMessageDialog(null,sAux);
}
else
if(funcionario instanceof EmpregadoComissionado)
{
funcionario.remuneracao();
String sAux = String.format("%s",funcionario);
JOptionPane.showMessageDialog(null,sAux);
}
else
{
String sAux = String.format("%s",funcionario);
JOptionPane.showMessageDialog(null,sAux);
}
}
}
}
Blz, fiz o Downcast em EmpregadoAssalariado, pois eu precisei usar o método getSalario e setSalario da subclasse EmpregadoAssalariado, ja que a referencia de
superclasse, funcionario , nao possui esses métodos, somente a subclasse EmpregadoAssalariado, possui esses métodos que eu precisei invocar para poder setar
o reajuste de salario. Eu entendo o processo de fazer o Downcast.
Mas minha duvida é a seguinte, caso o objeto sendo referenciado seja um objeto EmpregadoComissionado, nesse caso ae, se for, eu terei que fazer esse tratamento:
public double remuneracao(){
double salario = getComissao() * getTotalVendas() / 100;
if(salario <= 5000)
{
salario = salario - 10 * salario /100;
}
else
if(salario > 5000)
{
salario = salario - 30 * salario /100;
}
return salario;
}
Depois de feito, esse tratamento no método remuneracao, tenho que retornar o salario do EmpregadoComissionado.
Agora olhem la na classe EmpregadoPolimorfo:
else
if(funcionario instanceof EmpregadoComissionado)
{
funcionario.remuneracao();
String sAux = String.format("%s",funcionario);
JOptionPane.showMessageDialog(null,sAux);
}
Percebam que usei a referencia de superclasse, funcionario para invocar o método remuneracao da subclasse EmpregadoComissionado para demostrar o processamento
polimorfico. A minha duvida é exatamente nesse trecho de codigo, fiquei na duvida se era preciso fazer o Downcast, como feito com a subclasse
EmpregadoAssalariado, ja que nesse caso da subclasse EmpregadoAssalariado eu precisei fazer o Downcasta para setar o reajuste de salario.
Mas nesse caso do EmpregadoComissionado, nao sei si precisa fazer o Downcast, ja que nao estou reajustando nenhum salario, simplesmente usei
a referencia de superclasse para invocar o método remuneracao da subclasse EmpregadoComissionado, para mostrar o salario do Empregado, nessas condições:
public double remuneracao(){
double salario = getComissao() * getTotalVendas() / 100;
if(salario <= 5000)
{
salario = salario - 10 * salario /100;
}
else
if(salario > 5000)
{
salario = salario - 30 * salario /100;
}
return salario;