Java - ayuda con ejercicio en java

 
Vista:
sin imagen de perfil

ayuda con ejercicio en java

Publicado por Alejandro (1 intervención) el 16/10/2021 18:51:38
estoy comenzando con este lenguaje de programacion, la verdad no se nada, queria ver si alguien me puede orientar o ayudar con este ejercicio para mas o menos ubicarme en cuanto a sintaxis y como funciona java
Desarrolle una aplicación en Java que determine el sueldo bruto para cada uno de los empleados de una empresa. La empresa paga la tarifa normal en las primeras 40 horas de trabajo de cada empleado, y paga tarifa y media en todas las horas trabajadas que excedan de 40.
El programa creará los objetos que quiera el usuario (uno para cada empleado) los meterá en una lista y se le pedirá al usuario que rellene la información para cada empleado en el constructor.

Por cada empleado se almacenará:
• Nombre empleado.
• Número de horas que trabajó.
• Tarifa que cobra por hora de trabajo.

Para finalizar, el programa debe determinar y mostrar el sueldo bruto de cada empleado.
Ejemplo: Francisco trabajó 42 horas, cobra $7.500 la hora y le corresponde un sueldo de $315.000 pesos.

• Realiza un método para establecer el nombre de cada empleado, otro para establecer para las horas y otro para establecer la tarifa.
• Crea otros 3 métodos para devolver el nombre de cada empleado, otro para devolver las horas y otro para devolver la tarifa.
• Utiliza un método que calcule el sueldo que corresponde al empleado y que lo devuelva. (return).
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

ayuda con ejercicio en java

Publicado por Kabuto (1082 intervenciones) el 17/10/2021 12:41:09
Hola.
Lo primero es crear una clase Empleado.
Nos piden estos atributos:

1
2
3
4
Por cada empleado se almacenará:
• Nombre empleado.
• Número de horas que trabajó.
• Tarifa que cobra por hora de trabajo.

Podemos comenzar así:

1
2
3
4
5
6
7
public class Empleado {
 
	private String nombre;
	private int horas; //Horas trabajadas
	private double tarifa; //Importe que cobra por hora trabajada
 
}

Ahora le añadimos un constructor que reciba los valores para inicializar los atributos. Así cada vez que queramos construir un objeto Empleado, podremos proporcionarle directamente los valores:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Empleado {
 
	private String nombre;
	private int horas; //Horas trabajadas
	private double tarifa; //Importe que cobra por hora trabajada
 
	public Empleado(String nombre, int horas, double tarifa) {
		this.nombre = nombre;
		this.horas = horas;
		this.tarifa = tarifa;
	}
 
}

Veamos ahora qué método tendrá esta clase.
1
• Realiza un método para establecer el nombre de cada empleado, otro para establecer para las horas y otro para establecer la tarifa.

Estos métodos, son los llamados "setters" porque, una vez el objeto ya ha sido construido, permiten establecer (set) nuevos valores para los atributos del objeto.
Estos métodos pueden ser tan sencillos como simplemente asignar el valor recibido al atributo. Pero también nos ofrecen la oportunidad de añadir más código de manera que podamos establecer reglas para los valores, hacer tareas extras, etc...
Por ejemplo, podemos impedir que los atributos "horas" reciban valores con signo negativo, ya que no tiene sentido dar esos valores a los atributos y si se tratase de un programa "real" se podrían provocar graves inconsistencias, como que el sueldo de alguien saliera con valor negativo y ese mes se quedase sin cobrar

También se puede (si se quiere) acotar los valores para las "tarifas", para asegurarnos que se asigna una tarifa que esté dentro de un mínimo y un máximo, para que nadie cobre muy poquito, ni tampoco demasiado..

Estas "reglas" para hora y tarifa, te las propongo a modo de ejemplo, para que veas que con los setters podemos hacer mucho más que no simplemente aceptar un nuevo valor.
Por cierto, estas mismas reglas sería importante que se aplicasen al construir un objeto, así que podemos modificar el constructor para que llame a los setters y que se ocupen ellos de asignar los valores recibidos.
Como para el atributo nombre no hemos puesto ninguna regla, no es necesario usar su getter en el constructor:
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
public class Empleado {
 
	private String nombre;
	private int horas; //Horas trabajadas
	private double tarifa; //Importe que cobra por hora trabajada
 
	public Empleado(String nombre, int horas, double tarifa) {
		this.nombre = nombre;
		setHoras(horas);
		setTarifa(tarifa);
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public void setHoras(int horas) {
		if (horas < 0) {
			System.out.println("ERROR: Horas trabajadas no pueden tener valor negativo");
			System.out.println("Las horas quedarán contabilizadas a valor 0");
		}
		else
			this.horas = horas;
	}
 
	public void setTarifa(double tarifa) {
		if (tarifa < 6000) {
			System.out.println("ERROR: Importe tarifa demasiado bajo, se establecerá el mínimo");
			this.tarifa = 6000;
		}
		else if (tarifa > 10000) {
			System.out.println("ERROR: Importe tarifa demasiado alto, se establecerá el máximo");
			this.tarifa = 10000;
		}
		else //La tarifa se encuentra entre el mínimo y máximo
			this.tarifa = tarifa;
	}
 
}


¿Qué más piden?
1
• Crea otros 3 métodos para devolver el nombre de cada empleado, otro para devolver las horas y otro para devolver la tarifa.

Estos son los llamados getters, porque son métodos que una vez creado el objeto, permiten obtener (get) los valores de los atributos, ya sea para mostrarlos en pantalla, o hacer algún cálculo, o lo que sea...

Si se quiere/necesita, también se puede añadir código para hacer algo más que simplemente retornar el valor.
Por ejemplo, podemos asegurarnos de que el nombre se va a retornar siempre con la primera letra en mayúscula.

Supongamos que alguien ha introducido en el sistema el nombre de un empleado, pero de forma poco elegante:
1
peDRO sANCHEZ lopeZ
Una empresa seria no puede permitirse hacer listados de nombres con ese aspecto jeje, vamos a querer imprimirlos así:
1
Pedro Sanchez Lopez

Así que antes de devolver el valor del atributo nombre, vamos a asegurarnos de darle el formato correcto añadiendo código extra en su correspondiente getter.
Para hacerlo, crearemos además un método PRIVADO que se encargará únicamente de "capitalizar" palabras(poner primera letra mayúscula y el resto en minúscula)

Este método será PRIVADO(private) porque es un proceso interno de la clase Empleado, no está pensado para que se pueda usar FUERA de esta clase, únicamente se podrá usar DENTRO de ella.
Los demás métodos sí han de ser PUBLICOS(public) porque queremos que también se puedan usar FUERA de su clase.

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
81
82
83
84
85
86
87
88
89
public class Empleado {
 
	private String nombre;
	private int horas; //Horas trabajadas
	private double tarifa; //Importe que cobra por hora trabajada
 
	public Empleado(String nombre, int horas, double tarifa) {
		this.nombre = nombre;
		setHoras(horas);
		setTarifa(tarifa);
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public void setHoras(int horas) {
		if (horas < 0) {
			System.out.println("ERROR: Horas trabajadas no pueden tener valor negativo");
			System.out.println("Las horas quedarán contabilizadas a valor 0");
		}
		else
			this.horas = horas;
	}
 
	public void setTarifa(double tarifa) {
		if (tarifa < 6000) {
			System.out.println("ERROR: Importe tarifa demasiado bajo, se establecerá el mínimo");
			this.tarifa = 6000;
		}
		else if (tarifa > 10000) {
			System.out.println("ERROR: Importe tarifa demasiado alto, se establecerá el máximo");
			this.tarifa = 10000;
		}
		else //La tarifa se encuentra entre el mínimo y máximo
			this.tarifa = tarifa;
	}
 
	public String getNombre() {
		/*
		 * Dividiremos el nombre completo en palabras
		 * separadas y nos aseguramos de que cada una
		 * tendrá la primera letra en mayúscula y el
		 * resto en minúscula
		 */
 
		//Separamos el nombre en palabras, partiendo donde encontremos un espacio en blanco
		String[] palabras = nombre.split(" "); //Esto nos proporciona un array con las palabras separadas
		/*
		 * El array que hemos obtenido puede tener dos palabras, tres, cuatro... no lo sabemos.
		 * Pero no importa, las recorreremos todas, las capitalizaremos y construiremos con ellas
		 * un nuevo String
		 */
		String nombreCapitalizado = "";
		for (int i = 0; i < palabras.length; i++)
			nombreCapitalizado = nombreCapitalizado + capitalizar(palabras[i] + " ");
		//Listo, ya podemos retornar el nombre correctamente formateado
		return nombreCapitalizado;
	}
 
	public int getHoras() {
		return horas;
	}
 
	public double getTarifa() {
		return tarifa;
	}
 
	/*
	 * Este método es PRIVADO y se encarga de
	 * capitalizar una palabra, es decir, convierte
	 * su primera letra en mayúscula y las demás
	 * en minúsuculas
	 */
	private String capitalizar(String palabra) {
		//Primera letra
		String primera = palabra.substring(0, 1);
		//Resto
		String resto = palabra.substring(1);
		/*
		 * Volvemos a juntarlas y la retornamos,
		 * pero convirtiendo en mayúscula la primera
		 * y en minúscula el resto
		 */
 
		return primera.toUpperCase() + resto.toLowerCase();
	}
 
}


Llegamos al último método:
1
2
• Utiliza un método que calcule el sueldo que corresponde al empleado
y que lo devuelva. (return).
Este cálculo del sueldo, ha de seguir esta regla:
1
2
3
La empresa paga la tarifa normal en las primeras 40 horas
de trabajo de cada empleado, y paga tarifa y media
en todas las horas trabajadas que excedan de 40.

Así que habrá que comprobar si ha trabajado más de 40 horas o no, y calcular según cada caso:
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
public class Empleado {
 
	private String nombre;
	private int horas; //Horas trabajadas
	private double tarifa; //Importe que cobra por hora trabajada
 
	public Empleado(String nombre, int horas, double tarifa) {
		this.nombre = nombre;
		setHoras(horas);
		setTarifa(tarifa);
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public void setHoras(int horas) {
		if (horas < 0) {
			System.out.println("ERROR: Horas trabajadas no pueden tener valor negativo");
			System.out.println("Las horas quedarán contabilizadas a valor 0");
		}
		else
			this.horas = horas;
	}
 
	public void setTarifa(double tarifa) {
		if (tarifa < 6000) {
			System.out.println("ERROR: Importe tarifa demasiado bajo, se establecerá el mínimo");
			this.tarifa = 6000;
		}
		else if (tarifa > 10000) {
			System.out.println("ERROR: Importe tarifa demasiado alto, se establecerá el máximo");
			this.tarifa = 10000;
		}
		else //La tarifa se encuentra entre el mínimo y máximo
			this.tarifa = tarifa;
	}
 
	public String getNombre() {
		/*
		 * Dividiremos el nombre completo en palabras
		 * separadas y nos aseguramos de que cada una
		 * tendrá la primera letra en mayúscula y el
		 * resto en minúscula
		 */
 
		//Separamos el nombre en palabras, partiendo donde encontremos un espacio en blanco
		String[] palabras = nombre.split(" "); //Esto nos proporciona un array con las palabras separadas
		/*
		 * El array que hemos obtenido puede tener dos palabras, tres, cuatro... no lo sabemos.
		 * Pero no importa, las recorreremos todas, las capitalizaremos y construiremos con ellas
		 * un nuevo String
		 */
		String nombreCapitalizado = "";
		for (int i = 0; i < palabras.length; i++)
			nombreCapitalizado = nombreCapitalizado + capitalizar(palabras[i] + " ");
		//Listo, ya podemos retornar el nombre correctamente formateado
		return nombreCapitalizado;
	}
 
	public int getHoras() {
		return horas;
	}
 
	public double getTarifa() {
		return tarifa;
	}
 
	/*
	 * Este método es PRIVADO y se encarga de
	 * capitalizar una palabra, es decir, convierte
	 * su primera letra en mayúscula y las demás
	 * en minúsuculas
	 */
	private String capitalizar(String palabra) {
		//Primera letra
		String primera = palabra.substring(0, 1);
		//Resto
		String resto = palabra.substring(1);
		/*
		 * Volvemos a juntarlas y la retornamos,
		 * pero convirtiendo en mayúscula la primera
		 * y en minúscula el resto
		 */
 
		return primera.toUpperCase() + resto.toLowerCase();
	}
 
	public double calcularSueldo() {
		double sueldo = 0;
 
		//Si ha trabajado 40 horas o menos, cada hora vale la tarifa normal.
		if (horas <= 40)
			sueldo = horas * tarifa;
		//Pero si ha trabajado más de 40 horas, las horas superadas valen tarifa y media
		else {
			//Las primeras 40, son tarifa normal
			sueldo = 40 * tarifa;
			//Ahora calculamos la diferencia de horas que superan 40
			int diferencia = horas - 40;
			//Y sumamos el importe de estas horas con tarifa especial
			sueldo = sueldo + diferencia * (tarifa * 1.5);
		}
 
		//El sueldo ya está calculado, podemos retornarlo
		return sueldo;
	}
 
}

Pues con esto ya tendríamos terminada la clase Empleado.
Ahora habría que crear otra clase , con un método main(), que ponga en marcha el programa y permita registrar Empleados.
Lo vemos en el siguiente mensaje
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
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

ayuda con ejercicio en java

Publicado por Kabuto (1082 intervenciones) el 17/10/2021 12:46:34
Para registrar empleados usaremos un objeto Scanner para pedir datos por teclado.
Preguntaremos cuántos empleados se quieren registrar y crearemos un array con dicho tamaño.

Pediremos datos para cada empleado y los registraremos en el array. Después, lo recorreremos y mostraremos el sueldo calculado para cada uno.

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
import java.util.Scanner;
 
public class TestEmpleados {
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
		Empleado[] empleados; //Array de empleados
 
		System.out.print("¿Cuántos empleados quiere registrar?: ");
		int cantidad = Integer.parseInt(teclado.nextLine());
		if (cantidad <= 0) {
			System.out.println("Cantidad incorrecta, se crearán 5 empleados.");
			empleados = new Empleado[5];
		}
		else
			empleados = new Empleado[cantidad];
 
		//Pedimos datos de los Empleados
		for (int i = 0; i < empleados.length; i++) {
			System.out.println("\nDatos del Empleado #" + (i+1));
			System.out.println("---------------------");
			System.out.print("Nombre: ");
			String nombre = teclado.nextLine();
			System.out.print("Horas trabajadas: ");
			int horas = Integer.parseInt(teclado.nextLine());
			System.out.print("Tarifa por hora: ");
			double tarifa = Double.parseDouble(teclado.nextLine());
			//Datos capturados, creamos nuevo empleado en el array
			empleados[ i] = new Empleado(nombre, horas, tarifa);
		}
 
		//Petición de datos terminada, calculamos y mostramos los sueldos a percibir
		System.out.println("\n\n\t\tSueldos de empleados");
		System.out.println("\t\t--------------------\n");
 
		//Usamos un for each para recorrer el array de empleados
		for (Empleado emp: empleados) {
			System.out.println("\t\t***************");
			System.out.println(emp.getNombre() + "trabajó " + emp.getHoras() + " horas.");
			System.out.println("Cobra $" + emp.getTarifa() + " la hora.");
			System.out.println("Le corresponde un sueldo de $" + emp.calcularSueldo() + " pesos");
			System.out.println("\t\t***************\n");
		}
 
		System.out.println("\n\n\t\tFIN DE PROGRAMA");
		teclado.close();
	}
 
}

Si lo ejecutamos, en pantalla veremos que todo parece funciona bien.
Los Empleados se registran, la reglas que hemos creado en los setter se aplican y vemos que da igual lo mal que escribamos los nombres, o de cuantas palabras se compongan, luego en pantalla se imprimen con más elegancia:

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
¿Cuántos empleados quiere registrar?: 3
 
Datos del Empleado #1
---------------------
Nombre: juan reina
Horas trabajadas: 38
Tarifa por hora: 4300
ERROR: Importe tarifa demasiado bajo, se establecerá el mínimo
 
Datos del Empleado #2
---------------------
Nombre: JUAN SEBASTIAN ELCANO
Horas trabajadas: 46
Tarifa por hora: 8000
 
Datos del Empleado #3
---------------------
Nombre: kABUTO
Horas trabajadas: 1
Tarifa por hora: 9999999
ERROR: Importe tarifa demasiado alto, se establecerá el máximo
 
 
		Sueldos de empleados
		--------------------
 
		***************
Juan Reina trabajó 38 horas.
Cobra $6000.0 la hora.
Le corresponde un sueldo de $228000.0 pesos
		***************
 
		***************
Juan Sebastian Elcano trabajó 46 horas.
Cobra $8000.0 la hora.
Le corresponde un sueldo de $392000.0 pesos
		***************
 
		***************
Kabuto trabajó 1 horas.
Cobra $10000.0 la hora.
Le corresponde un sueldo de $10000.0 pesos
		***************
 
 
 
		FIN DE PROGRAMA


Estudia a fondo todo el código y no dudes en preguntar cada duda que te surja, aunque te parezca tonta o poca cosa.
He intentando explicarlo todo añadiendo comentarios al código, pero si estás empezando y todo esto es nuevo para ti, siempre habrá algo que no se entienda a la primera, así que pregunta lo que necesites.

Un saludo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

ayuda con ejercicio en java

Publicado por ANom (1 intervención) el 23/10/2021 15:28:37
kabuto, muy pocas personas se dejan todo para explica tan bien el código en un foro como este se agradece por el esfuerzo que has dado al explicarlo tan detalladamente muchísimas gracias.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar