Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » URGENTE, podrían ayudarme con este ejercicio?

Java - URGENTE, podrían ayudarme con este ejercicio?

Volver
Nuevo Tema
<<>>
 
Vista:

URGENTE, podrían ayudarme con este ejercicio?

Publicado por FREDDY ALONSO BRICEÑO (4 intervenciones) el 25/08/2021 06:34:17
Buenas noches, necesito ayuda con un ejercicio con suma urgencia, he estado enfermo trato de repasar pero no me rinde y se me acaba el tiempo, les agradezco ayuda en este ejercicio por favor

La administración de un conjunto residencial conformado por casas,
apartamentos y locales comerciales, requiere calcular el valor a pagar
por cada predio por concepto de administración.
• El valor de la administración está conformado por valor del área o
metros cuadrados, valor de parqueaderos, valor uso de ascensor,
valor por ubicación de los locales y valor por áreas comunes.
• Las casas, apartamentos y locales pagan de acuerdo al área un
valor por cada metro cuadrado, casas $1000, apartamentos $1200
y locales $1500.
• Además, cada predio tiene asignado uno o dos parqueaderos y por
cada parqueadero se paga $5000.
• Las torres de apartamentos son de 10 pisos y los dos primeros pisos
son de parqueaderos. Los apartamentos ubicados entre el tercer y
quinto piso pagan el 10% del valor del área y los ubicados en pisos
superiores el 15% del valor del área, por el uso del ascensor.
• Los locales pueden tener ubicación interna o externa del conjunto,
los locales ubicados al exterior pagan un 30% del valor del área y
los de ubicación interna 20% del valor del área.
• Todos los predios pagan un valor por concepto de áreas comunes,
las casas:10% del valor del área y parqueaderos, los apartamentos:
10% del valor del área, parqueaderos y uso de ascensor y los
locales: 10% del valor del área, parqueaderos y valor por ubicación.

Como requisitos me piden que cumplan con estas condiciones:
Todos los atributos de la super clase deben estar encapsulados.
• El método liquidar() debe calcular el valor de los metros cuadrados y los valores de los
conceptos: parqueaderos, ascensor y ubicación del local y grabar los valores de estos tres
conceptos en los respectivos atributos en la superclase.
• El método factura() debe presentar el valor de cada concepto y el valor total de
administración.
• Se debe implementar una interface para las constantes de tarifas de mts2 y parqueaderos.
• En la interface implementar el método que permite calcular el valor por concepto de áreas
comunes.

Mis disculpas si los interrumpo, pero ando realizando otros ejercicios que son entregables y seria de gran ayuda que alguien profesional como ustedes me ayudaran, les agradezco
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

URGENTE, podrían ayudarme con este ejercicio?

Publicado por Kabuto (1381 intervenciones) el 28/08/2021 02:25:16
A ver, según creo entender.
Tenemos un ConjuntoResidencial
Este conjunto tiene un área en m2 y tiene una cantidad de Predios

Y queremos conocer su valor total. Dicho valor depende de lo que cada Predio ha de pagar en concepto de:
- valor del Area
- valor de Parqueaderos
- valor de uso de ascensores
- valor de la ubicación de los locales
- valor de las áreas comunes.

Así que, por ahora, podemos codificar la clase ConjuntoResidencial de esta manera:

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
public class ConjuntoResidencial {
 
	private int area; //metros2
	private Predio[] predios;
	//Valores
	private float valorTotalArea;
	private float valorTotalParqueaderos;
	private float valorTotalUsoAscensor;
	private float valorTotalUbicacionLocales;
	private float valorTotalAreasComunes;
 
	public ConjuntoResidencial(int area) {
		this.area = area;
	}
 
	public void setPredios(Predio[] predios) {
		this.predios = predios;
	}
 
	public void liquidar() {
		//TODO: Calcular cada valor según cada Predio
	}
 
	public void factura() {
		//TODO: Desglosar en pantalla los valores calculados y el total.
	}
 
}

En su constructor le damos un área. Los Predios, que podemos coleccionarlos en un array simple, se los haremos llegar luego mediante un método.
El código de los métodos liquidar() y factura() ya los escribiremos después, según desarrollemos el resto de clases.

Bien, la siguiente clase ha desarrollar sería Predio, que de hecho hay tres tipos de Predio distintos: Casa, Apartamentos(un bloque) y Locales

Así que Predio podría ser la clase madre y las otras tres serían herederas de esta.

Además, se nos pide crear una interfaz con las constantes para los valores que paga cada tipo de Predio según el área del conjunto.
Y también nos pide que la interfaz implemente el método que calcula el valor por áreas comunes.
Bueno, esto último no tiene mucho sentido, o implementamos TODOS los métodos en la interfaz, o ninguno... pero solo uno..
Así que yo lo veo absurdo, pero bueno, lo haremos. Si será necesario que reciba como parámetro al valor del área, así que la interfaz podría quedar así:


1
2
3
4
5
6
7
8
9
10
11
12
13
public interface Tarifas {
	//Tarifas por area, según tipo de Predio
	public final int VALOR_CASAS = 1000;//Dólares por m2
	public final int VALOR_APARTAMENTOS = 1200;
	public final int VALOR_LOCALES = 1500;
 
	//Tarifa por parqueadero asignado
	public final int VALOR_PARQUEADERO = 5000;
 
	//Método para calcular valor por áreas comunes
	public float calcularValorAreaComun(int area);
 
}

No se nos dice que clase ha de implementar esta interfaz, creo que lo más lógico es que la implemente la clase Predio, y como las demás clases serán herederas, también heredarán la interfaz Tarifas

Entonces, la clase Predio puede ser abstracta y tener el único atributo que es común a los tres tipos de predios: los parqueadores asignados.
Esta clase puede ser tan simplona como esto:
1
2
3
4
5
public abstract class Predio implements Tarifas{
 
	protected int parqueaderos; //Uno o dos parqueaderos asignados
 
}

La clase Casa hereda de Predio y en su constructor recibimos el parámetros para indicar cuantos parqueaderos tiene asignados.
Además tendrá los métodos para calcular el valor que paga por el área, el valor que paga por los parqueaderos asignados y el valor que paga por la zonas comunes (este viene obligado por la interfaz Tarifas)
Así queda:
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 Casa extends Predio {
 
	public Casa(int parqueaderos) {
		this.parqueaderos = parqueaderos;
	}
 
	public float calculaValorArea(int area) {
		return area * VALOR_CASAS;
	}
 
	public float calculaValorParqueadero() {
		return parqueaderos * VALOR_PARQUEADERO;
	}
 
	@Override
	public float calcularValorAreaComun(int area) {
		//10% del valor del área y parqueaderos
		float valorArea = calculaValorArea(area) / 10;
		float valorParc = calculaValorParqueadero() / 10;
 
		return valorArea + valorParc;
	}
 
}

La clase Apartamentos, muy parecido, solo que directamente indicamos que tiene dos parqueaderos asignados, ya que las dos primeras plantas se consideran parqueaderos.
Además incluye otro método para calcular el valor que paga toda la torre por el uso del ascensor. Este valor es el resultado de la suma de dos tramos distintos, ya que los primeros pisos pagan menos que los pisos más altos.
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
public class Apartamentos extends Predio{
 
	public Apartamentos() {
		parqueaderos = 2; //Las dos primeras plantas son parqueaderos
	}
 
	public float calculaValorArea(int area) {
		return area * VALOR_APARTAMENTOS;
	}
 
	public float calculaValorParqueadero() {
		return parqueaderos * VALOR_PARQUEADERO;
	}
 
	public float calculaValorUsoAscensor(int area) {
		//apartamentos ubicados entre el tercer y quinto piso pagan el 10% del valor del área
		float tramoBajo = (calculaValorArea(area) / 10) * 3; //Son tres pisos
 
		//los ubicados en pisos superiores el 15% del valor del área
		float tramoAlto = (calculaValorArea(area) * 15 / 100) * 5;//Son 5 pisos, del sexto al decimo
 
		return tramoBajo + tramoAlto;
	}
 
	@Override
	public float calcularValorAreaComun(int area) {
 
		//10% del valor del área, parqueaderos y uso ascensor
		float valorArea = calculaValorArea(area) / 10;
		float valorParc = calculaValorParqueadero() / 10;
		float valorAsc = calculaValorUsoAscensor(area) / 10;
		return valorArea + valorParc + valorAsc;
	}
 
}

Y la clase Local, en este caso sí que se añade un atributo extra. Hay locales de ubicación externa e interna, podemos representarlo con un boolean.
Este boolean determinará el valor que pagan por su ubicación, que se calcula mediante un método propio de esta 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
public class Local extends Predio {
 
	private boolean esExterno; //Indica si su ubicacion es externa(true) o interna(false)
 
	public Local(int parqueaderos, boolean esExterno) {
		this.parqueaderos = parqueaderos;
		this.esExterno = esExterno;
	}
 
	public float calculaValorArea(int area) {
		return area * VALOR_LOCALES;
	}
 
	public float calculaValorParqueadero() {
		return parqueaderos * VALOR_PARQUEADERO;
	}
 
	public float calculaValorUbicacion(int area) {
		//los locales ubicados al exterior pagan un 30% del valor del área
		//los de ubicación interna 20% del valor del área
		if (esExterno)
			return calculaValorArea(area) * 30 / 100;
		else
			return calculaValorArea(area) * 20 / 100;
	}
 
	@Override
	public float calcularValorAreaComun(int area) {
		//10% del valor del área, parqueaderos y valor por ubicación
		float valorArea = calculaValorArea(area) / 10;
		float valorParc = calculaValorParqueadero() / 10;
		float valorUbic = calculaValorUbicacion(area) / 10;
 
		return valorArea + valorParc + valorUbic;
	}
 
}

Tenemos ya todas las clases. Solo falta terminar de codificar la clase principal llamada ConjuntoResidencial

Vamos a hacer el método liquidar().
Dicho método ha de calcular el importe de cada uno de los valores que paga el conjunto residencial.
Lo mejor es que utilicemos métodos específicos para cada uno de ellos y el método liquidar() simplemente los invoque para que hagan sus tareas.
Fijémonos en que para calcular estos valores, en cada caso hay que recorrer el array de Predios, preguntar que tipo de Predio es (Casa, Local o Apartamentos), convertir (casting) al tipo que pertenezca y ahora sí invocar el método correspondiente que cada clase hija posee para calcular cada valor.
Marco en negrita los cambios. Esta es ya la versión definitiva de la clase ConjuntoResidencial
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
public class ConjuntoResidencial {
 
	private int area; //metros2
	private Predio[] predios;
	//Valores
	private float valorTotalArea;
	private float valorTotalParqueaderos;
	private float valorTotalUsoAscensor;
	private float valorTotalUbicacionLocales;
	private float valorTotalAreasComunes;
 
	public ConjuntoResidencial(int area) {
		this.area = area;
	}
 
	public void setPredios(Predio[] predios) {
		this.predios = predios;
	}
 
	/*
	 * El método liquidar() debe calcular el valor
	 * de los metros cuadrados y los valores de los
	 * conceptos: parqueaderos, ascensor y ubicación del local
	 */
	public void liquidar() {
		valorTotalArea = calcularTotalArea();
		valorTotalParqueaderos = calcularTotalParqueaderos();
		valorTotalUsoAscensor = calcularTotalAscensor();
		valorTotalUbicacionLocales = calcularTotalUbicaciones();
		valorTotalAreasComunes = calcularTotalAreasComunes();
	}
 
	public void factura() {
		//TODO: Desglosar en pantalla los valores calculados y el total.
	}
 
	private float calcularTotalArea() {
		float total = 0f;
		//Recorremos todos los predios
		for (int i = 0; i < predios.length; i++) {
			//Consultamos que tipo de predio es para hacer el casting correspondiente
			if (predios instanceof Casa)
				total += ((Casa)predios[i]).calculaValorArea(area);
			else if (predios[i] instanceof Apartamentos)
				total += ((Apartamentos)predios[i]).calculaValorArea(area);
			else //Si no es ningunos de los dos anteriores, pues es un Local
				total += ((Local)predios[i]).calculaValorArea(area);
		}
		//Terminado el recorrido, ya tenemos el total
		return total;
	}
 
	private float calcularTotalParqueaderos() {
		float total = 0f;
 
		for (int i = 0; i < predios.length; i++) {
			if (predios[i] instanceof Casa)
				total += ((Casa)predios[i]).calculaValorParqueadero();
			else if (predios[i] instanceof Apartamentos)
				total += ((Apartamentos)predios[i]).calculaValorParqueadero();
			else
				total += ((Local)predios[i]).calculaValorParqueadero();
		}
 
		return total;
	}
 
	private float calcularTotalAscensor() {
		float total = 0f;
 
		for (int i = 0; i < predios.length; i++) {
			//En este caso, solo nos interesan los Apartamentos
			if (predios[i] instanceof Apartamentos)
				total += ((Apartamentos)predios[i]).calculaValorUsoAscensor(area);
		}
 
		return total;
	}
 
	private float calcularTotalUbicaciones() {
		float total = 0f;
 
		for (int i = 0; i < predios.length; i++) {
			//En este caso, solo nos interesan los Locales
			if (predios[i] instanceof Local)
				total += ((Local)predios[i]).calculaValorUbicacion(area);
		}
 
		return total;
	}
 
	private float calcularTotalAreasComunes() {
		float total = 0f;
 
		for (int i = 0; i < predios.length; i++)
			//Al ser un método heredado de la clase Predio (a través de la interfaz Tarifas)
			//no es necesario hacer casting a ninguna clase hija
			total += predios[i].calcularValorAreaComun(area);
 
		return total;
	}
}

Y ahora toca hacer el método [i]factura(). Que básicamente es presentar en pantalla todos los valores calculados y la suma de ellos.
Marco en negrita los cambios:
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package administracion;
 
public class ConjuntoResidencial {
 
	private int area; //metros2
	private Predio[] predios;
	//Valores
	private float valorTotalArea;
	private float valorTotalParqueaderos;
	private float valorTotalUsoAscensor;
	private float valorTotalUbicacionLocales;
	private float valorTotalAreasComunes;
 
	public ConjuntoResidencial(int area) {
		this.area = area;
	}
 
	public void setPredios(Predio[] predios) {
		this.predios = predios;
	}
 
	/*
	 * El método liquidar() debe calcular el valor
	 * de los metros cuadrados y los valores de los
	 * conceptos: parqueaderos, ascensor y ubicación del local
	 */
	public void liquidar() {
		valorTotalArea = calcularTotalArea();
		valorTotalParqueaderos = calcularTotalParqueaderos();
		valorTotalUsoAscensor = calcularTotalAscensor();
		valorTotalUbicacionLocales = calcularTotalUbicaciones();
		valorTotalAreasComunes = calcularTotalAreasComunes();
	}
 
	/*
	 * Debe presentar el valor de cada concepto
	 * y el valor total de administración.
	 */
	public void factura() {
		System.out.println("\t\tAdministración del Conjunto Residencial");
		System.out.println("\t\t-------------- --- -------- -----------");
		System.out.printf("Área total: %dm2\n", area);
		System.out.printf("Predios totales: %d\n", predios.length);
 
		System.out.printf("\nValor total por Área: %.2f$", valorTotalArea);
		System.out.printf("\nValor total por Parqueaderos: %.2f$", valorTotalParqueaderos);
		System.out.printf("\nValor total por Uso de Ascensor: %.2f$", valorTotalUsoAscensor);
		System.out.printf("\nValor total por Ubicación de Locales: %.2f$", valorTotalUbicacionLocales);
		System.out.printf("\nValor total por Áreas Comunes: %.2f$\n", valorTotalAreasComunes);
 
		float totalAdmin = valorTotalArea + valorTotalParqueaderos + valorTotalUsoAscensor +
				valorTotalUbicacionLocales + valorTotalAreasComunes;
 
		System.out.printf("\nValor total por Conjunto Residencia: %.2f$", totalAdmin);
 
	}
 
	private float calcularTotalArea() {
		float total = 0f;
		//Recorremos todos los predios
		for (int i = 0; i < predios.length; i++) {
			//Consultamos que tipo de predio es para hacer el casting correspondiente
			if (predios[i] instanceof Casa)
				total += ((Casa)predios[i]).calculaValorArea(area);
			else if (predios[i] instanceof Apartamentos)
				total += ((Apartamentos)predios[i]).calculaValorArea(area);
			else //Si no es ningunos de los dos anteriores, pues es un Local
				total += ((Local)predios[i]).calculaValorArea(area);
		}
		//Terminado el recorrido, ya tenemos el total
		return total;
	}
 
	private float calcularTotalParqueaderos() {
		float total = 0f;
 
		for (int i = 0; i < predios.length; i++) {
			if (predios[i] instanceof Casa)
				total += ((Casa)predios[i]).calculaValorParqueadero();
			else if (predios[i] instanceof Apartamentos)
				total += ((Apartamentos)predios[i]).calculaValorParqueadero();
			else
				total += ((Local)predios[i]).calculaValorParqueadero();
		}
 
		return total;
	}
 
	private float calcularTotalAscensor() {
		float total = 0f;
 
		for (int i = 0; i < predios.length; i++) {
			//En este caso, solo nos interesan los Apartamentos
			if (predios[i] instanceof Apartamentos)
				total += ((Apartamentos)predios[i]).calculaValorUsoAscensor(area);
		}
 
		return total;
	}
 
	private float calcularTotalUbicaciones() {
		float total = 0f;
 
		for (int i = 0; i < predios.length; i++) {
			//En este caso, solo nos interesan los Locales
			if (predios[i] instanceof Local)
				total += ((Local)predios[i]).calculaValorUbicacion(area);
		}
 
		return total;
	}
 
	private float calcularTotalAreasComunes() {
		float total = 0f;
 
		for (int i = 0; i < predios.length; i++)
			//Al ser un método heredado de la clase Predio (a través de la interfaz Tarifas)
			//no es necesario hacer casting a ninguna clase hija
			total += predios[i].calcularValorAreaComun(area);
 
		return total;
	}
}


¿Y que falta?
Pues una última clase, con un método main() para ponerlo a prueba.
Creamos un array de Predios, un conjunto residencial al que asignamos estos predios.
Liquidamos, y presentamos factura en pantalla;

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
public class Test {
 
	public static void main(String[] args) {
 
		//Creamos un array con distintos Predios
		Predio[] predios = new Predio[] {
				new Casa(1), new Casa(2), new Apartamentos(), new Local(1, true),
				new Apartamentos(), new Casa(2), new Local(2, false), new Local(1, true),
				new Casa(2), new Casa(2), new Casa(1), new Local(1, false),
				new Apartamentos(), new Casa(1), new Local(1, false), new Local(1, true),
		};
 
		//Creamos un Conjunto Residencial indicando area
		ConjuntoResidencial cr = new ConjuntoResidencial(2300);
 
		//Le asignamos los predios
		cr.setPredios(predios);
 
		//Hacemos liquidacion
		cr.liquidar();
 
		//Presentamos factura
		cr.factura();
	}
 
}

Creo que ha quedado todo explicado. Cualquier duda, solo hay que preguntar.
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
1
Comentar