Me dan lo siguiente:
************************************************
abstract class Empleado{
double sueldo;
Empleado(double sueldo){
this.sueldo=sueldo;
}
public abstract String toString();
public abstract int getIndex ();
boolean hacer_huelga(double reduccion_de_sueldo , int despidos , double valor_de_acciones){
//falta implementar
}
}
**********************************************
interface Conciencia{
double valor (int despidos );
}
**********************************************
interface Accionista{
double valor (int despidos , double valor_de_acciones );
}
**********************************************
1)La cosa es que tengo que implementar el metodo hacer_huelga() teniendo en
cuenta:
Un empleado se pondra en huelga si sus "costes" finales son menores que 40,
sino no. Estos "costes" se calculan de la siguiente forma:
Son resultado del producto del sueldo y reduccion_de_sueldo(que tendra un
valor entre 0.0 y 1.0). Hay que utilizar una estructura de Datos para
almacenar los valores.
Si Empleado es objeto de la interfaz Conciencia entonces sus "costes"
disminuyen en funcion al valor calculado a traves de la clase Conciencia
(dependiente de despidos)
Si el Empleado es objeto de la interfaz Accionista, entonces sus "costes"
subiran en funcion al valor calculado a traves de la clase Accionista
(dependiente de despidos)
**********************************************
2)Luego tengo que implementar la clase Trabajador a traves de la clase
Empleado que es objeto de la Interfaz Conciencia:
Además de sueldo tendra un valor_de_conciencia. Ambos valores se pasarán
al constructor
getIndex() dara 0 para todo Trabajador
toString() dara un String "Trabajador" seguido de informacion de sueldo
el metodo valor(int despidos) de Conciencia da el producto de despidos y
valor_de_conciencia.
**********************************************
3)Implementar la clase Jefe como Empleado que sea objeto de la clase
Conciencia y Accionista
getIndex() dara 1 para todo Trabajador
toString() dara un String "Jefe" seguido de informacion de sueldo
el metodo valor(int despidos) de Conciencia da el producto de despidos y
0.2.
el metodo double valor (int despidos , double valor_de_acciones ) de Accionista
da el producto de despidos y valor_de_acciones
**********************************************
4)Implementar la clase Empresa que utiliza una lista para administrar a los
Empleados. La clase implementa los siguiente metodos:
init(int numero) crea el numero de empleados. Con un 70% de probabilidad se
creara un Trabajador con un sueldo aleatorio entre 0.0 y 700.0 y
un valor_de_conciencia entre 0.0 y 1.5. En el resto de los casos se creara
un Jefe con un sueldo aleatorio entre 0.0 y 1000.0
get_huelguista() da una lista de Empleados que estan en huelga. Si un Empleado
hace huelga se informara de manera que se llame al metodo
hacer_huelga(double reduccion_de_sueldo=0.1,int despidos=10,double valor_de_acciones=2.5)
print_Statistics() saca por consola el tipo(Trabajador o Jefe) y el sueldo del
Empleado que esta en huelga. Luego se sacara la parte de los huelguista con
Index 0 es decir, los Trabajadores del total. Además se sacara la parte de
los huelguista con Index 1(Jefes) del total.
**********************************************
La verdad es que es la primera vez que tengo que hacer este tipo de trabajo,
donde tienes que organizar la información y en base a eso hacer el programa.
Me cuesta mucho arrancar en estos casos. Alguien me podría orientar, es decir,
decirme por donde debería de empezar y como seguir y me podría sugerir alguna
estructura de datos para almacenar los "costes" de los empleados. Lo de los
"costes" tampoco lo entiendo mucho a alguien se le ocurre que significa
exactamente? Gracias!