Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » CALCULAR CUANTA AGUA GASTA CADA PERSONA EN UNA CASA

Java - CALCULAR CUANTA AGUA GASTA CADA PERSONA EN UNA CASA

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil
Val: 10
Ha aumentado su posición en 431 puestos en Java (en relación al último mes)
Gráfica de Java

CALCULAR CUANTA AGUA GASTA CADA PERSONA EN UNA CASA

Publicado por julian (3 intervenciones) el 10/06/2021 15:47:33
HOLA QUE TAL, ME AYUDARIAN DANDO IDEAS DE COMO HACER UNA SIMULACION EN JAVA.
LA SIMULACION CONSISTE EN CALCULAR CUANTA AGUA GASTA CADA PERSONA EN UNA CASA.
MUCHAS GRACIAS POR SUS SUGERENCIAS.
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

CALCULAR CUANTA AGUA GASTA CADA PERSONA EN UNA CASA

Publicado por Kabuto (1381 intervenciones) el 11/06/2021 00:44:04
¿El programa sería en modo consola o con interfaz gráfica?
¿Programación estructurada o Programación orientada a objetos?

Sobre ideas así en general...ofrecer distintos métodos/opciones de menú como lavarManos(), ponerLavadora(), darseDucha().....
Cada método/opción recibe un tiempo en segundos, o en minutos... y calcula cuánto se ha consumido en base a una constante definida para cada método.

Por ejemplo, el grifo para lavarse las manos puede tener definido como constante que gasta 0,25L/segundo.
Entonces, si lavarManos() recibe como parámetro un tiempo de 4 segundos, pues se calculará que esta persona, en este proceso, ha consumido 1 litro (4 x 0,25)

Con la ducha lo mismo, solo que consideraríamos que gasta más agua, su constante podría ser 0,5L/segundo.

Con la lavadora sería distinto, más que el tiempo, lo que cuenta es el tipo de programa escogido... nose, se puede busca info en la web sobre cuál es el consumo de una lavadora y así decidir como enfocar el programa para ella.
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
sin imagen de perfil
Val: 10
Ha aumentado su posición en 431 puestos en Java (en relación al último mes)
Gráfica de Java

CALCULAR CUANTA AGUA GASTA CADA PERSONA EN UNA CASA

Publicado por julian (3 intervenciones) el 11/06/2021 01:35:13
SERIA CON INTERFAZ GRÁFICA YA QUE ES UN PROYECTO QUE NOS PIDIERON EN EL COLEGIO.
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

CALCULAR CUANTA AGUA GASTA CADA PERSONA EN UNA CASA

Publicado por Kabuto (1381 intervenciones) el 14/06/2021 00:28:08
No se si algo así podría servirte como idea.

Un panel donde se gestionan las actividades habituales de un hogar que consumen agua: lavarse las manos/ducharse, lavar platos, usar la cisterna del WC y poner lavadora de ropa.

Habrían 4 paneles, uno para cada miembro de la familia, reflejando el consumo personal de cada uno y en la parte superior el consumo general de toda la casa, es decir, la suma de los consumos personales.

imagen_2021-06-13_235720

Para las tareas que usan grifos (ducha, lavar manos,..) se puede establecer el tiempo en segundos que ha durado la tarea.
Para las otras tareas, cisternaWC y lavadora, hay dos botones para escoger si ha sido un proceso de bajo consumo/ahorro, o un proceso completo.

Cada tarea esta programada como un panel individual.
Este sería el panel de lavarse las manos / ducharse.
Tiene un valor constante que representa los litros/segundo que consume este grifo.
Con un JSpinner se escoge la duración del proceso y con un botón se inicia la tarea, que es entonces cuando se calcula el consumo según el tiempo escogido.
El cálculo se lleva a cabo mediante un método.

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
public class PanelLavarManos extends JPanel{
 
	private final float GASTO = 0.1f;//litros/segundo, equivale a 6 litros por minuto
	private JSpinner spTiempo;
	public JButton btIniciar;
 
	public PanelLavarManos() {
 
		spTiempo = new JSpinner(new SpinnerNumberModel(1,1,300,1));
		btIniciar = new JButton("Iniciar");
 
		setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
		JPanel pnTiempo = new JPanel();
		pnTiempo.add(new JLabel("Segundos: "));
		pnTiempo.add(spTiempo);
		JPanel pnBoton = new JPanel();
		pnBoton.add(btIniciar);
		add(pnTiempo);
		add(pnBoton);
 
		setBorder(BorderFactory.createCompoundBorder(
				BorderFactory.createCompoundBorder(
						BorderFactory.createEtchedBorder(EtchedBorder.RAISED),
						BorderFactory.createEmptyBorder(15, 15, 15, 15)),
				BorderFactory.createCompoundBorder(
						BorderFactory.createTitledBorder("Lavar Manos / Ducharse"),
						BorderFactory.createEmptyBorder(10, 10, 10, 10))
				));
	}
 
	public float calculaConsumo() {
		return (int)spTiempo.getValue() * GASTO;
	}
}

El panel de lavar platos es prácticamente idéntico, solo varía el nivel de consumo, que es algo mayor.

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 PanelLavarPlatos extends JPanel{
 
	private final float GASTO = 0.13f;//litros/segundo, equivale a 8 litros por minuto
	private JSpinner spTiempo;
	public JButton btIniciar;
 
	public PanelLavarPlatos() {
 
		spTiempo = new JSpinner(new SpinnerNumberModel(1,1,300,1));
		btIniciar = new JButton("Iniciar");
 
		setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
		JPanel pnTiempo = new JPanel();
		pnTiempo.add(new JLabel("Segundos: "));
		pnTiempo.add(spTiempo);
		JPanel pnBoton = new JPanel();
		pnBoton.add(btIniciar);
		add(pnTiempo);
		add(pnBoton);
 
		setBorder(BorderFactory.createCompoundBorder(
				BorderFactory.createCompoundBorder(
						BorderFactory.createEtchedBorder(EtchedBorder.RAISED),
						BorderFactory.createEmptyBorder(15, 15, 15, 15)),
				BorderFactory.createCompoundBorder(
						BorderFactory.createTitledBorder("Lavar Platos"),
						BorderFactory.createEmptyBorder(10, 10, 10, 10))
				));
	}
 
	public float calculaConsumo() {
		return (int)spTiempo.getValue() * GASTO;
	}
 
}

El panel para tirar de la cisterna WC, es más sencillo.
Simplemente dos botones para elegir entre la descarga parcial o completa de la cisterna.
Ni siquiera va a requerir de un método para calcular nada.
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
public class PanelTirarCisterna extends JPanel{
 
	public JButton bt3L;
	public JButton bt5L;
 
	public PanelTirarCisterna() {
 
		bt3L = new JButton("Descarga 3 Litros");
		bt5L = new JButton("Descarga 5 Litros");
 
		setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
		JPanel pn3l = new JPanel();
		pn3l.add(bt3L);
		JPanel pn5l = new JPanel();
		pn5l.add(bt5L);
 
		add(pn3l);
		add(pn5l);
 
		setBorder(BorderFactory.createCompoundBorder(
				BorderFactory.createCompoundBorder(
						BorderFactory.createEtchedBorder(EtchedBorder.RAISED),
						BorderFactory.createEmptyBorder(15, 15, 15, 15)),
				BorderFactory.createCompoundBorder(
						BorderFactory.createTitledBorder("Cisterna WC"),
						BorderFactory.createEmptyBorder(10, 10, 10, 10))
				));
	}
 
}

Y el panel de la lavadora, es idéntico, dos botones para escoger programa "eco" o el normal
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
public class PanelLavadora extends JPanel{
 
	public JButton btEco;
	public JButton btNormal;
 
	public PanelLavadora() {
 
		btEco = new JButton("ECO 40L");
		btNormal = new JButton("Normal 60L");
 
		setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
		JPanel pnEco = new JPanel();
		pnEco.add(btEco);
		JPanel pnNormal = new JPanel();
		pnNormal.add(btNormal);
 
		add(pnEco);
		add(pnNormal);
 
		setBorder(BorderFactory.createCompoundBorder(
				BorderFactory.createCompoundBorder(
						BorderFactory.createEtchedBorder(EtchedBorder.RAISED),
						BorderFactory.createEmptyBorder(15, 15, 15, 15)),
				BorderFactory.createCompoundBorder(
						BorderFactory.createTitledBorder("Poner Lavadora"),
						BorderFactory.createEmptyBorder(10, 10, 10, 10))
				));
 
	}
 
}

Para mostrar los consumos, uso un quinto panel que básicamente consiste en un JLabel que irá mostrando el consumo acumulado.
Este mismo panel servirá para los consumos personales, como para el consumo general. La única diferencia será el tamaño de fuente, el cuál se lo indicamos mediante el constructor de la 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
public class PanelConsumo extends JPanel{
 
	private float consumo;
	private JLabel lbConsumo;
 
	public PanelConsumo(int tamFuente) {
		consumo = 0f;
		lbConsumo = new JLabel();
		setConsumo(consumo);
		lbConsumo.setFont(new Font("Verdana", Font.ITALIC, tamFuente));
		lbConsumo.setForeground(Color.BLUE);
		lbConsumo.setBackground(Color.WHITE);
		lbConsumo.setOpaque(true);
		lbConsumo.setBorder(BorderFactory.createLoweredSoftBevelBorder());
		add(lbConsumo);
		setBorder(BorderFactory.createEmptyBorder(15, 15, 15, 15));
	}
 
	public void setConsumo(float litros) {
		consumo += litros;
		lbConsumo.setText(String.format("Litros consumidos: %07.2f", consumo));
	}
 
}


Estos cinco paneles se unen en otro llamado PanelPersonal con el cuál se cosntruye un panel completo para cada miembro de la familia.
Por eso en su constructor le pasamos como parámetro un String con el nombre de la persona a la cuál se le asignará este panel personal.
También le pasamos como parámetro, una referencia al panel que mostrará el consumo general en la interfaz principal.
De esta manera, cada "panel personal" será capaz de gestionar lo que muestra su propio panel de "consumo personal", y también el panel general.

Al final del código están los ActionListeners para los botones de cada subpanel.
Para los paneles "con grifos", se invoca a sus métodos que calculan el consumo según el tiempo indicado.
Para los paneles de lavadora y WC, simplemente se comprueba cuál botón ha sido accionado para decidir el consumo que hay que añadir.
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
public class PanelPersonal extends JPanel{
 
	private PanelConsumo pnConsumoPersonal;
	private PanelLavarManos pnManos;
	private PanelLavarPlatos pnPlatos;
	private PanelTirarCisterna pnWC;
	private PanelLavadora pnLavadora;
 
	//Referencia al panel de consumo general
	private PanelConsumo pnConsumoGeneral;
 
 
	public PanelPersonal(String nombre, PanelConsumo general) {
		//Al referenciarlo, podemos actualizar su valor al mismo tiempo que los consumos personales
		pnConsumoGeneral = general;
 
		pnConsumoPersonal = new PanelConsumo(20);
		pnManos = new PanelLavarManos();
		pnManos.btIniciar.addActionListener(new AccionLavarManos());
		pnPlatos = new PanelLavarPlatos();
		pnPlatos.btIniciar.addActionListener(new AccionLavarPlatos());
		pnWC = new PanelTirarCisterna();
		pnWC.bt3L.addActionListener(new AccionTirarCisterna());
		pnWC.bt5L.addActionListener(new AccionTirarCisterna());
		pnLavadora = new PanelLavadora();
		pnLavadora.btEco.addActionListener(new AccionLavadora());
		pnLavadora.btNormal.addActionListener(new AccionLavadora());
 
		setLayout(new BorderLayout());
 
		add(pnConsumoPersonal, BorderLayout.NORTH);
 
		JPanel pnConsumos = new JPanel();
		pnConsumos.setLayout(new GridLayout(4,1,10,10));
		pnConsumos.add(pnManos);
		pnConsumos.add(pnPlatos);
		pnConsumos.add(pnWC);
		pnConsumos.add(pnLavadora);
 
		add(pnConsumos);
 
		setBorder(BorderFactory.createCompoundBorder(
				BorderFactory.createRaisedSoftBevelBorder(),
				BorderFactory.createTitledBorder(nombre))
				);
	}
 
	private class AccionLavarManos implements ActionListener {
 
		@Override
		public void actionPerformed(ActionEvent e) {
			float consumo = pnManos.calculaConsumo();
			pnConsumoGeneral.setConsumo(consumo);
			pnConsumoPersonal.setConsumo(consumo);
		}
	}
 
	private class AccionLavarPlatos implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			float consumo = pnPlatos.calculaConsumo();
			pnConsumoGeneral.setConsumo(consumo);
			pnConsumoPersonal.setConsumo(consumo);
		}
	}
 
	private class AccionTirarCisterna implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			JButton boton = (JButton) e.getSource();
			if (boton.equals(pnWC.bt3L)) {
				pnConsumoGeneral.setConsumo(3f);
				pnConsumoPersonal.setConsumo(3f);
			}
			else {
				pnConsumoGeneral.setConsumo(5f);
				pnConsumoPersonal.setConsumo(5f);
			}
		}
	}
 
	private class AccionLavadora implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			JButton boton = (JButton) e.getSource();
			if (boton.equals(pnLavadora.btEco)) {
				pnConsumoGeneral.setConsumo(40f);
				pnConsumoPersonal.setConsumo(40f);
			}
			else {
				pnConsumoGeneral.setConsumo(60f);
				pnConsumoPersonal.setConsumo(60f);
			}
		}
	}
}


Todo esto lo usamos para componer el marco JFrame principal.
Este marco tendrá en la parte superior el panel grande que muestra el consumo general.
Debajo se construye un panel con los 4 paneles personales de cada miembro de la familia.

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 CalculaConsumo extends JFrame{
 
	private PanelConsumo pnConsumoGeneral;//Panel que refleja el consumo general
 
	public CalculaConsumo() {
 
		pnConsumoGeneral = new PanelConsumo(40);
		pnConsumoGeneral.setBackground(new Color(150, 206, 235));
 
		//Paneles de consumos personales
		JPanel pnPersonales = new JPanel();
		pnPersonales.add(new PanelPersonal("Andrés", pnConsumoGeneral));
		pnPersonales.add(new PanelPersonal("Sara", pnConsumoGeneral));
		pnPersonales.add(new PanelPersonal("Juan", pnConsumoGeneral));
		pnPersonales.add(new PanelPersonal("Lucas", pnConsumoGeneral));
		pnPersonales.setBackground(new Color(150, 206, 235));
 
		setLayout(new BorderLayout());
		add(pnConsumoGeneral, BorderLayout.NORTH);
		add(pnPersonales, BorderLayout.CENTER);
 
		setTitle("Cálculo de Consumo");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		pack();
		setLocationRelativeTo(null);
		setVisible(true);
	}
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {
			@Override
			public void run() {
				new CalculaConsumo();
			}
		});
	}
}

Y bueno, es una idea simple pero puede servir como punto de partida para hacer algo más elaborado si fuera necesario.

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
2
Comentar
sin imagen de perfil
Val: 10
Ha aumentado su posición en 431 puestos en Java (en relación al último mes)
Gráfica de Java

CALCULAR CUANTA AGUA GASTA CADA PERSONA EN UNA CASA

Publicado por julian (3 intervenciones) el 14/06/2021 02:27:59
Muchas gracias me podrías pasar el código por correo por favor te lo agradecería mucho
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
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

CALCULAR CUANTA AGUA GASTA CADA PERSONA EN UNA CASA

Publicado por Kabuto (1381 intervenciones) el 15/06/2021 00:38:48
Mejor por aquí para que todo el mundo pueda verlo y si quieren, aportar cambios y mejoras.

Lo adjunto como archivo .zip en este mensaje.
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