Java - ejercicio con poliformismo ayudaaaaaa

 
Vista:

ejercicio con poliformismo ayudaaaaaa

Publicado por Silvia (1 intervención) el 26/11/2021 06:26:03
Resolver el siguiente ejercicio en java utilizando polimorfismo.

Una empresa del sector tecnológico desea tener un sistema de información para administrar toda la información de su personal. Se conoce la siguiente información de cada empleado: número de identificación, nombres, apellidos, fecha de ingreso, sueldo básico mensual, porcentaje promedio de cumplimiento en los proyectos que participa y número de proyectos en los que participa. Desde el punto de vista de la contratación, se tienen empleados con contrato a término fijo, con contrato indefinido y por prestación de servicios. Para determinar el sueldo mensual de cada empleado, se tiene en cuenta:

Si el contrato es a término indefinido y el porcentaje de cumplimiento en proyectos es superior al 90%, se incrementará el 10% al sueldo básico mensual.
Si el contrato es a término fijo y el porcentaje de cumplimiento en proyectos es superior al 90%, se incrementará el 8 % al sueldo básico mensual.
Si el contrato es por prestación de servicios y le porcentaje de cumplimiento en proyectos es superior al 90%, se incrementará el 2% por cada proyecto en el que participe.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

ejercicio con poliformismo ayudaaaaaa

Publicado por Kabuto (1102 intervenciones) el 26/11/2021 20:28:01
Polimorfismo implica que un mismo objeto adopta comportamientos de clases distintas.
Esto puede hacerse mediante herencia de clases o, en algunos lenguajes como Java, también mediante implementación de interfaces.

En este caso, ambas formas podrían ser apropiadas, pero hagámoslo por herencia.

Tenemos tres tipos de empleados, donde cada uno realiza el cálculo de su sueldo de manera distinta.
Pero todos son empleados, y todos van a tener un método para calcular el sueldo (cada uno a su manera).

Así que podemos crear una clase madre llamada Empleado, con los atributos y métodos comunes a todos los tipos de empleados.
Y luego crearemos tres clases hijas, que pueden ser TerminoFijo, Indefinido y Prestacion.

La clase madre Empleado puede declararse como abstracta, no es obligatorio, pero ya que no vamos a querer crear simples Empleados conviene declararla abstracta. Así se obliga a que solo se puedan crear objetos de las clases hijas.

La clase abstracta Empleado tendrá, como hemos dicho, los atributos y métodos comunes en las clases hijas.
El método para calcular el sueldo, también es común a todas, pero el cálculo que se realiza es distinto para cada una. Así que este método también se puede declarar como abstracto, de esta manera se "obliga" a que las clases hijas implemente este método y sea en ellas donde se escribirá el código acorde a las condiciones de cada una.

Esta es la clase Empleado, en ella declaro a tres atributos como protected. Esto es porque las clases hijas van a necesitar acceso directo a estos atributos para poder hacer el cálculo de los sueldos.
Se podrían declarar todos los atributos como protected, pero parece que en principio solo se necesita acceso a esos tres en concreto.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
public abstract class Empleado {
 
	private String id;
	private String nombre;
	private String apellidos;
	private String fechaIngreso;
	protected double sueldo;
	protected int cumplimiento;
	protected int numProyectos;
 
	public Empleado(String id, String nombre, String apellidos, String fechaIngreso, double sueldo, int cumplimiento,
			int numProyectos) {
		this.id = id;
		this.nombre = nombre;
		this.apellidos = apellidos;
		this.fechaIngreso = fechaIngreso;
		this.sueldo = sueldo;
		this.cumplimiento = cumplimiento;
		this.numProyectos = numProyectos;
	}
 
	public String getId() {
		return id;
	}
 
	public void setId(String id) {
		this.id = id;
	}
 
	public String getNombre() {
		return nombre;
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public String getApellidos() {
		return apellidos;
	}
 
	public void setApellidos(String apellidos) {
		this.apellidos = apellidos;
	}
 
	public String getFechaIngreso() {
		return fechaIngreso;
	}
 
	public void setFechaIngreso(String fechaIngreso) {
		this.fechaIngreso = fechaIngreso;
	}
 
	public double getSueldoBase() {
		return sueldo;
	}
 
	public void setSueldoBase(double sueldo) {
		this.sueldo = sueldo;
	}
 
	public int getCumplimiento() {
		return cumplimiento;
	}
 
	public void setCumplimiento(int cumplimiento) {
		this.cumplimiento = cumplimiento;
	}
 
	public int getNumProyectos() {
		return numProyectos;
	}
 
	public void setNumProyectos(int numProyectos) {
		this.numProyectos = numProyectos;
	}
 
	public abstract double calcularSueldo();
 
}

Vamos con la clases hijas, comenzamos con TerminoFijo. Al indicar que hereda de Empleado, el compilador nos obliga a dos incluir dos cosas:
- un constructor con lo necesario para construir los atributos de la clase madre.
- Implemente el método abstracto para calcular el sueldo y sobreescribirlo para darle un código.

La verdad es que no necesitamos nada más, solo esas dos cosas.
Fíjate que en el método de calcular sueldo, podemos hacer referencia directamente a los atributos "cumplimiento" y "sueldo", esto es porque en la clase madre los declaramos como protected

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class TerminoFijo extends Empleado {
 
	public TerminoFijo(String id, String nombre, String apellidos, String fechaIngreso, double sueldo, int cumplimiento,
			int numProyectos) {
		super(id, nombre, apellidos, fechaIngreso, sueldo, cumplimiento, numProyectos);
	}
 
	@Override
	public double calcularSueldo() {
		/*
		 * Si el contrato es a término fijo y
		 * el porcentaje de cumplimiento en proyectos
		 * es superior al 90%, se incrementará el 8%
		 * al sueldo básico mensual.
		 */
		if (cumplimiento > 90)
			return sueldo + (sueldo * 8 / 100);
		else
			return sueldo;
	}
 
}

El resto de clases hijas serán idénticas, solo cambian las fórmulas para el cálculo de los sueldos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Indefinido extends Empleado {
 
	public Indefinido(String id, String nombre, String apellidos, String fechaIngreso, double sueldo, int cumplimiento,
			int numProyectos) {
		super(id, nombre, apellidos, fechaIngreso, sueldo, cumplimiento, numProyectos);
	}
 
	@Override
	public double calcularSueldo() {
		/*
		 * Si el contrato es a término indefinido
		 * y el porcentaje de cumplimiento en proyectos
		 * es superior al 90%, se incrementará el 10% al
		 * sueldo básico mensual.
		 */
		if (cumplimiento > 90)
			return sueldo + (sueldo * 10 / 100);
		else
			return sueldo;
	}
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Prestacion extends Empleado {
 
	public Prestacion(String id, String nombre, String apellidos, String fechaIngreso, double sueldo, int cumplimiento,
			int numProyectos) {
		super(id, nombre, apellidos, fechaIngreso, sueldo, cumplimiento, numProyectos);
	}
 
	@Override
	public double calcularSueldo() {
		/*
		 * Si el contrato es prestación de servicios y
		 * el porcentaje de cumplimiento en proyectos
		 * es superior al 90%, se incrementará el 2%
		 * por cada proyecto en el que participe.
		 */
		if (cumplimiento > 90) {
			double plus = sueldo * 2 / 100;
			return sueldo + (plus * numProyectos);
		}
		else
			return sueldo;
	}
 
}

Y ya solo falta poner a prueba las clases.
Podemos crear un ArrayList de clase Empleado, donde construir unos cuantos objetos de cada tipo de empleado.

Luego los recorremos con un foreach y mostramos el tipo de clase al que pertenecen y el sueldo calculado.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.ArrayList;
 
public class Prueba {
 
	public static void main(String[] args) {
 
		ArrayList<Empleado> listaEmpleados = new ArrayList<Empleado>();
		listaEmpleados.add(new TerminoFijo("ID001", "Raul", "Casas", "22/08/2007", 1000, 80, 3));
		listaEmpleados.add(new TerminoFijo("ID002", "Pedro", "Castillo", "06/02/2009", 1000, 95, 2));
		listaEmpleados.add(new Indefinido("ID003", "Sandra", "Roca", "12/09/2009", 900, 80, 3));
		listaEmpleados.add(new Indefinido("ID004", "Luis", "Sanchez", "20/10/2008", 900, 91, 3));
		listaEmpleados.add(new Prestacion("ID005", "Raquel", "Manzano", "30/03/2006", 975, 93, 3));
		listaEmpleados.add(new Prestacion("ID006", "Laura", "Juan", "07/08/2007", 975, 93, 6));
 
		for (Empleado emp: listaEmpleados) {
			System.out.print("Tipo: " + emp.getClass().getSimpleName());
			System.out.println(" -- Sueldo: " + emp.calcularSueldo());
		}
 
	}
 
}

De este modo se puede ver como, aunque todos los objetos están siendo almacenados y tratados bajo la clase Empleado, en realidad cada uno se comporta e identifica como pertenecientes a alguna de las distintas clases hijas.
Eso es polimorfismo
1
2
3
4
5
6
Tipo: TerminoFijo -- Sueldo: 1000.0
Tipo: TerminoFijo -- Sueldo: 1080.0
Tipo: Indefinido -- Sueldo: 900.0
Tipo: Indefinido -- Sueldo: 990.0
Tipo: Prestacion -- Sueldo: 1033.5
Tipo: Prestacion -- Sueldo: 1092.0
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar