19 noviembre, 2018

Métodos tipo void


Cuando comenzábamos a diseñar nuestros primeros programas, normalmente toda la tarea lo hacíamos en un solo método, sin embargo, al encontrarnos con tareas cada vez más complejas o grandes se hace engorroso tener que trabajarlo todo en un solo método, para lo cual debemos de aplicar la técnica de descomposición modular.

Asi, en el tema de hoy utilizando descomposición en módulos mediante métodos tipo void y las estructuras básicas y de selección, diseñaremos programas en Java que resuelvan problemas planteados.




Estos posts te servirán tanto si estás empezando de cero en el mundo de la programación, si eres estudiante de primer año y necesitas reforzar algunos temas, o si eres un curioso que le entró la duda y las ganas de aprender a programar. Sea el motivo que fuese por lo que estás aquí, te invito a seguir esta serie de publicaciones que estaré realizando, en donde aprenderás con los temas que te vaya enseñando lo básico de la programación para que puedas realizar tú mismo tus propios programas.

¡Comencemos!

¿Qué es el método tipo void?


Un método tipo void es un módulo de programa que puede recibir datos de entrada a través de variables locales denominadas parámetros; pero, que no retorna ningún resultado al punto donde es invocado, razón por el que se le conoce también como método sin valor de retorno. Tanto este tipo de método, al igual que los métodos que retornan un valor, pueden recibir datos de entrada a través de sus parámetros.

Los métodos tipo void pueden dividirse a su vez en dos tipos:

. Métodos tipo void sin parámetros.
. Métodos tipo void con parámetros.

Método tipo void sin parámetros

Estos métodos no pueden recibir datos de entrada ni retornar ningún resultado al punto de su invocación.

Método tipo void sin parámetros

Cuando se programa usando métodos se siguen dos etapas.

Primero, el método debe definirse. Esto consiste en crear el método ubicándolo en alguna parte del programa.
Segundo, el método creado debe ser invocado en el lugar donde se requiera. Esto consiste en poner el método en ejecución.

Definición

Este tipo de método se define de la siguiente manera:

1
2
3
4
5
6
7
void nombre(){
 
   // Declaración de variables locales
 
   // Cuerpo del método
 
}

Invocación

Este tipo de método se invoca de la siguiente manera:

1
nombre();

Donde:

nombre: es el nombre del método.

Métodos tipo void con parámetros


Estos métodos reciben datos de entrada a través de variables locales al método denominadas parámetros; pero, igual que en el caso anterior no pueden retornar ningún resultado al punto de su invocación.

Método tipo void con parámetros

Donde:

p1, p2, p3, etc: son los parámetros del método.

El número de parámetros es variable y depende de las necesidades del método.

Definición

Este tipo de método se define de la siguiente manera:

1
2
3
4
5
6
7
void nombre( tipo1 p1, tipo2 p2, tipo3 p3, . . . ){
 
   // Declaración de variables locales
 
   // Cuerpo del método
 
}

Donde:

nombre: es el nombre del método
p1, p2, p3, ...: son los nombres de los parámetros
tipo1, tipo2, tipo3, …: son los tipos de datos de los parámetros

Llamada

Este tipo de método se invoca de la siguiente manera:

1
nombre(v1, v2, v3, . . .);


Donde:

nombre: es el nombre del método invocado
v1, v2, v3, ...: son los valores dados a los parámetros

Ejemplos


Problema 1

En una universidad, los alumnos están categorizados en cuatro categorías. A cada categoría le corresponde una pensión mensual distinta dada en la siguiente tabla:


Semestralmente, la universidad efectúa rebajas en las pensiones de sus estudiantes a partir del segundo ciclo en base al promedio ponderado del ciclo anterior en porcentajes dados en la tabla siguiente:


Diseñe un programa que determine cuánto de rebaja recibirá un estudiante sobre su pensión actual y a cuánto asciende su nueva pensión. Declare todas las variables como globales y use métodos tipo void.

Programa


Código Fuente Modo 1
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema01 extends JApplet implements ActionListener {
 
 // Declaración de variables globales para la GUI
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JComboBox choCategoria;
 JLabel lblCategoria, lblPromedio;
 JTextField txtPromedio;
 JScrollPane scpScroll;
 
 // Declaración de variables globales para el algoritmo
 int categoria;
 double actualpen, nuevapen, descuento, promedio;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  setBackground(new Color(214, 211, 206));
 
  txtPromedio = new JTextField();
  txtPromedio.setBounds(79, 40, 87, 23);
  getContentPane().add(txtPromedio);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(305, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(305, 39, 101, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  choCategoria = new JComboBox();
  choCategoria.setBounds(79, 15, 87, 23);
  choCategoria.addItem("A");
  choCategoria.addItem("B");
  choCategoria.addItem("C");
  choCategoria.addItem("D");
  getContentPane().add(choCategoria);
 
  lblCategoria = new JLabel("Categoría");
  lblCategoria.setBounds(15, 15, 61, 23);
  getContentPane().add(lblCategoria);
 
  lblPromedio = new JLabel("Promedio");
  lblPromedio.setBounds(15, 40, 56, 23);
  getContentPane().add(lblPromedio);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 75, 394, 75);
  getContentPane().add(scpScroll);
 
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  // Si hizo clic en Procesar
  if (e.getSource() == btnProcesar)
   procesar();
 
  // Si hizo clic en Borrar
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  ingresarDatos();
  calcularPensionActual();
  calcularDescuento();
  calcularNuevaPension();
  mostrarResultados();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtS.setText("");
  txtPromedio.setText("");
  txtPromedio.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Ingresa datos
 void ingresarDatos() {
  categoria = choCategoria.getSelectedIndex();
  promedio = Double.parseDouble(txtPromedio.getText());
 }
 
 // -----------------------------------------------------------------------
 // Calcula la pensión actual
 void calcularPensionActual() {
  if (categoria == 0)
   actualpen = 550;
  else if (categoria == 1)
   actualpen = 500;
  else if (categoria == 2)
   actualpen = 460;
  else
   actualpen = 400;
 }
 
 // -----------------------------------------------------------------------
 // Cálcula el descuento
 void calcularDescuento() {
  if (promedio <= 13.99)
   descuento = 0;
  else if (promedio <= 15.99)
   descuento = 0.10 * actualpen;
  else if (promedio <= 17.99)
   descuento = 0.12 * actualpen;
  else
   descuento = 0.15 * actualpen;
 }
 
 // -----------------------------------------------------------------------
 // Calcula la nueva pensión
 void calcularNuevaPension() {
  nuevapen = actualpen - descuento;
 }
 
 // -----------------------------------------------------------------------
 // Muestra resultados
 void mostrarResultados() {
  txtS.setText("");
  imprimir("Pensión actual : " + actualpen);
  imprimir("Descuento : " + descuento);
  imprimir("Nueva pensión : " + nuevapen);
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena de texto incluyendo un salto de línea al final
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
}


Código Fuente Modo 2

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema01b extends JApplet implements ActionListener {
 
 // Declaración de variables globales para la GUI
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JComboBox choCategoria;
 JLabel lblCategoria, lblPromedio;
 JTextField txtPromedio;
 JScrollPane scpScroll;
 
 // Declaración de variables globales para el algoritmo
 int categoria;
 double actualpen, nuevapen, descuento, promedio;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  setBackground(new Color(214, 211, 206));
 
  txtPromedio = new JTextField();
  txtPromedio.setBounds(79, 40, 87, 23);
  getContentPane().add(txtPromedio);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(305, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(305, 39, 101, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  choCategoria = new JComboBox();
  choCategoria.setBounds(79, 15, 87, 23);
  choCategoria.addItem("A");
  choCategoria.addItem("B");
  choCategoria.addItem("C");
  choCategoria.addItem("D");
  getContentPane().add(choCategoria);
 
  lblCategoria = new JLabel("Categoría");
  lblCategoria.setBounds(15, 15, 61, 23);
  getContentPane().add(lblCategoria);
 
  lblPromedio = new JLabel("Promedio");
  lblPromedio.setBounds(15, 40, 56, 23);
  getContentPane().add(lblPromedio);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 75, 394, 75);
  getContentPane().add(scpScroll);
 
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  // Si hizo clic en Procesar
  if (e.getSource() == btnProcesar)
   procesar();
 
  // Si hizo clic en Borrar
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Entrada de datos
  categoria = getCategoria();
  promedio = getPromedio();
 
  // Proceso de cálculo
  actualpen = calcularPensionActual(categoria);
  descuento = calcularDescuento(promedio, actualpen);
  nuevapen = calcularNuevaPension(actualpen, descuento);
 
  // Salida de resultados
  txtS.setText("");
  imprimir("Pensión actual : " + actualpen);
  imprimir("Descuento : " + descuento);
  imprimir("Nueva pensión : " + nuevapen);
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtS.setText("");
  txtPromedio.setText("");
  txtPromedio.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna la categoría
 int getCategoria() {
  return choCategoria.getSelectedIndex();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna el promedio
 double getPromedio() {
  return Double.parseDouble(txtPromedio.getText());
 }
 
 // -----------------------------------------------------------------------
 // Calcula y retorna la pensión actual
 double calcularPensionActual(int categoria) {
  switch (categoria) {
  case 0:
   return 550;
  case 1:
   return 500;
  case 2:
   return 460;
  default:
   return 400;
  }
 }
 
 // -----------------------------------------------------------------------
 // Cálcula el descuento
 double calcularDescuento(double promedio, double actualpen) {
  if (promedio <= 13.99)
   return 0;
  else if (promedio <= 15.99)
   return 0.10 * actualpen;
  else if (promedio <= 17.99)
   return 0.12 * actualpen;
  else
   return 0.15 * actualpen;
 }
 
 // -----------------------------------------------------------------------
 // Calcula la nueva pensión
 double calcularNuevaPension(double actualpen, double descuento) {
  return actualpen - descuento;
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena de texto incluyendo un salto de línea al final
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
}

Problema 2

Una empresa evalúa a sus empleados bajo dos criterios: puntualidad y rendimiento.

En cada caso el empleado recibe un puntaje que va de 1 a 10, de acuerdo a los siguientes criterios:

Puntaje por puntualidad: está en función a los minutos de tardanza de acuerdo a la siguiente tabla:


Puntaje por rendimiento: está en función a la cantidad de observaciones efectuadas al empleado por no cumplir sus obligaciones de acuerdo a la siguiente tabla:


El puntaje total del empleado es la suma del puntaje por puntualidad más el puntaje por rendimiento. En base al puntaje total, el empleado recibe una bonificación anual de acuerdo a la siguiente tabla:


Diseñe un programa que determine el puntaje por puntualidad, el puntaje por rendimiento, el puntaje total y la bonificación que le corresponden a un empleado de la empresa. Declare todas las variables y use métodos tipo void.

Programa


Código Fuente

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema02 extends JApplet implements ActionListener {
 // Declaración de variables globales para la GUI
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblMinutosTar, lblNumeroObs;
 JTextField txtMinutosTar, txtNumeroObs;
 JScrollPane scpScroll;
 // Declaración de variables globales para el algoritmo
 int minutosTar, numeroObs, puntajePun, puntajeRen, puntajeTot;
 double bonificacion;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  lblMinutosTar = new JLabel("Minutos de tardanza");
  lblMinutosTar.setBounds(15, 15, 160, 23);
  getContentPane().add(lblMinutosTar);
 
  lblNumeroObs = new JLabel("Numero de observaciones");
  lblNumeroObs.setBounds(15, 39, 160, 23);
  getContentPane().add(lblNumeroObs);
 
  txtMinutosTar = new JTextField();
  txtMinutosTar.setBounds(175, 15, 120, 23);
  getContentPane().add(txtMinutosTar);
 
  txtNumeroObs = new JTextField();
  txtNumeroObs.setBounds(175, 39, 120, 23);
  getContentPane().add(txtNumeroObs);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(365, 15, 100, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(365, 39, 100, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 77, 450, 100);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtMinutosTar.setText("");
  txtNumeroObs.setText("");
  txtS.setText("");
  txtMinutosTar.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  ingresarDatos();
  determinarPuntajePuntualidad();
  determinarPuntajeRendimiento();
  determinarPuntajeTotal();
  determinarBonificacion();
  mostrarResultados();
 }
 
 // -----------------------------------------------------------------------
 // Efectúa la entrada de datos
 void ingresarDatos() {
  minutosTar = Integer.parseInt(txtMinutosTar.getText());
  numeroObs = Integer.parseInt(txtNumeroObs.getText());
 }
 
 // -----------------------------------------------------------------------
 // Determina el puntaje por puntualidad
 void determinarPuntajePuntualidad() {
  if (minutosTar == 0)
   puntajePun = 10;
  else if (minutosTar <= 2)
   puntajePun = 8;
  else if (minutosTar <= 5)
   puntajePun = 6;
  else if (minutosTar <= 9)
   puntajePun = 4;
  else
   puntajePun = 0;
 }
 
 // -----------------------------------------------------------------------
 // Determina el puntaje por rendimiento
 void determinarPuntajeRendimiento() {
  if (numeroObs == 0)
   puntajeRen = 10;
  else if (numeroObs == 1)
   puntajeRen = 8;
  else if (numeroObs == 2)
   puntajeRen = 5;
  else if (numeroObs == 3)
   puntajeRen = 1;
  else
   puntajeRen = 0;
 }
 
 // -----------------------------------------------------------------------
 // Determina el puntaje total
 void determinarPuntajeTotal() {
  puntajeTot = puntajePun + puntajeRen;
 }
 
 // -----------------------------------------------------------------------
 // Determina la bonificación
 void determinarBonificacion() {
  if (puntajeTot < 11)
   bonificacion = 2.5 * puntajeTot;
  else if (puntajeTot <= 13)
   bonificacion = 5.0 * puntajeTot;
  else if (puntajeTot <= 16)
   bonificacion = 7.5 * puntajeTot;
  else if (puntajeTot <= 19)
   bonificacion = 10.0 * puntajeTot;
  else
   bonificacion = 12.5 * puntajeTot;
 }
 
 // -----------------------------------------------------------------------
 // Muestra los resultados
 void mostrarResultados() {
  txtS.setText("");
  imprimir("Puntaje por puntualidad : " + puntajePun);
  imprimir("Puntaje por rendimiento : " + puntajeRen);
  imprimir("Puntaje total : " + puntajeTot);
  imprimir("Bonificación : " + bonificacion);
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena de texto incluyendo un salto de línea al final
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
}

Problema 3

Diseñe un programa que permita convertir un monto de dinero dado en euros a sus equivalentes en yenes, francos y rublos. Considere que:

1 dólar = 0.6750 euros
1 dólar = 108.44 yenes
1 dólar = 24.493 francos
1 dólar = 5.4984 rublos

Use métodos tipo void y considere todas las variables como globales.

Programa


Código Fuente

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema03 extends JApplet implements ActionListener {
 // Declaración de variables globales para la GUI
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblEuros;
 JTextField txtEuros;
 JScrollPane scpScroll;
 // Declaración de variables globales para el algoritmo
 double meuros, myenes, mfrancos, mrublos;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  lblEuros = new JLabel("Euros");
  lblEuros.setBounds(15, 15, 90, 23);
  getContentPane().add(lblEuros);
 
  txtEuros = new JTextField();
  txtEuros.setBounds(105, 15, 100, 23);
  getContentPane().add(txtEuros);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(365, 15, 100, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(265, 15, 100, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 450, 100);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtEuros.setText("");
  txtS.setText("");
  txtEuros.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  ingresarDatos();
  convertirAYenes();
  convertirAFrancos();
  convertirARublos();
  mostrarResultados();
 }
 
 // -----------------------------------------------------------------------
 // Ingresa datos
 void ingresarDatos() {
  meuros = Double.parseDouble(txtEuros.getText());
 }
 
 // -----------------------------------------------------------------------
 // Convierte a yenes
 void convertirAYenes() {
  myenes = (meuros / 0.6750) * 108.44;
 }
 
 // -----------------------------------------------------------------------
 // Convierte a francos
 void convertirAFrancos() {
  mfrancos = (meuros / 0.6750) * 24.493;
 }
 
 // -----------------------------------------------------------------------
 // Convierte a rublos
 void convertirARublos() {
  mrublos = (meuros / 0.6750) * 5.4984;
 }
 
 // -----------------------------------------------------------------------
 // Muestra resultados
 void mostrarResultados() {
  txtS.setText("");
  imprimir("Yenes : " + myenes);
  imprimir("Francos : " + mfrancos);
  imprimir("Rublos : " + mrublos);
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena de texto incluyendo un salto de línea al final
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
}

Problema 4

Diseñe un programa que permita convertir un monto de dinero dado en euros a sus equivalentes en yenes, francos y rublos. Considere que:

1 dólar = 0.6750 euros
1 dólar = 108.44 yenes
1 dólar = 24.493 francos
1 dólar = 5.4984 rublos

Use métodos tipo void y considere todas las variables como locales.

Programa


Código Fuente

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema04 extends JApplet implements ActionListener {
 // Declaración de variables globales
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblEuros;
 JTextField txtEuros;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  lblEuros = new JLabel("Euros");
  lblEuros.setBounds(15, 15, 90, 23);
  getContentPane().add(lblEuros);
 
  txtEuros = new JTextField();
  txtEuros.setBounds(105, 15, 100, 23);
  getContentPane().add(txtEuros);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(365, 15, 100, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(265, 15, 100, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 450, 100);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración de variables locales
  double meuros;
  // Entrada de datos
  meuros = Double.parseDouble(txtEuros.getText());
  // Invocación de métodos
  txtS.setText("");
  convertirAYenes(meuros);
  convertirAFrancos(meuros);
  convertirARublos(meuros);
 }
 
 // -----------------------------------------------------------------------
 // Convierte a yenes
 void convertirAYenes(double xeuros) {
  double myenes;
  myenes = (xeuros / 0.6750) * 108.44;
  imprimir("Yenes : " + myenes);
 }
 
 // -----------------------------------------------------------------------
 // Convierte a francos
 void convertirAFrancos(double xeuros) {
  double mfrancos;
  mfrancos = (xeuros / 0.6750) * 24.493;
  imprimir("Francos : " + mfrancos);
 }
 
 // -----------------------------------------------------------------------
 // Convierte a rublos
 void convertirARublos(double xeuros) {
  double mrublos;
  mrublos = (xeuros / 0.6750) * 5.4984;
  imprimir("Rublos : " + mrublos);
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtEuros.setText("");
  txtS.setText("");
  txtEuros.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena de texto incluyendo un salto de línea al final
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
}

Problema 5

Diseñe un programa que determine el área lateral, el área total y el área de la base de un cilindro. Considere que:

areabase =π r 2
arealateral = 2π r h
areatotal = 2π r (r + h)

Donde r es el radio y h la altura.

Declare todas las variables como globales y use métodos tipo void.

Programa


Código Fuente

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema05 extends JApplet implements ActionListener {
 // Declaración de variables globales para la GUI
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblRadio, lblAltura;
 JTextField txtRadio, txtAltura;
 JScrollPane scpScroll;
 // Declaración de variables globales para el algoritmo
 double radio, altura, arealat, areabas, areatot;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  lblRadio = new JLabel("Radio");
  lblRadio.setBounds(15, 15, 90, 23);
  getContentPane().add(lblRadio);
 
  lblAltura = new JLabel("Altura");
  lblAltura.setBounds(15, 39, 90, 23);
  getContentPane().add(lblAltura);
 
  txtRadio = new JTextField();
  txtRadio.setBounds(105, 15, 120, 23);
  getContentPane().add(txtRadio);
 
  txtAltura = new JTextField();
  txtAltura.setBounds(105, 39, 120, 23);
  getContentPane().add(txtAltura);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(365, 15, 100, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(365, 39, 100, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 77, 450, 100);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método para el botón Borrar
 void borrar() {
  txtRadio.setText("");
  txtAltura.setText("");
  txtS.setText("");
  txtRadio.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método para el botón Procesar
 void procesar() {
  ingresarDatos();
  calcularAreaBase();
  calcularAreaLateral();
  mostrarResultados();
 }
 
 // -----------------------------------------------------------------------
 // Ingresa datos
 void ingresarDatos() {
  radio = Double.parseDouble(txtRadio.getText());
  altura = Double.parseDouble(txtAltura.getText());
 }
 
 // -----------------------------------------------------------------------
 // Calcula el área de la base
 void calcularAreaBase() {
  areabas = Math.PI * radio * radio;
 }
 
 // -----------------------------------------------------------------------
 // Calcula el área lateral
 void calcularAreaLateral() {
  arealat = 2 * Math.PI * radio * altura;
 }
 
 // -----------------------------------------------------------------------
 // Calcula el área total
 void calcularAreaTotal() {
  areatot = 2 * Math.PI * radio * (radio + altura);
 }
 
 // -----------------------------------------------------------------------
 // Muestra resultados
 void mostrarResultados() {
  txtS.setText("");
  imprimir("Area lateral : " + arealat);
  imprimir("Area base : " + areabas);
  imprimir("Area total : " + areatot);
 }
 
 // -----------------------------------------------------------------------
 // Imprime una línea de texto con un salto de línea al final
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
}


Problema 6

Diseñe un programa que determine el área lateral, el área total y el área de la base de un cilindro. Considere que:

areabase =π r 2
arealateral = 2π r h
areatotal = 2π r (r + h)

Donde r es el radio y h la altura.

Declare todas las variables como locales y use métodos tipo void.

Programa


Código Fuente

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema06 extends JApplet implements ActionListener {
 // Declaración de variables globales para la GUI
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblRadio, lblAltura;
 JTextField txtRadio, txtAltura;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  lblRadio = new JLabel("Radio");
  lblRadio.setBounds(15, 15, 90, 23);
  getContentPane().add(lblRadio);
 
  lblAltura = new JLabel("Altura");
  lblAltura.setBounds(15, 39, 90, 23);
  getContentPane().add(lblAltura);
 
  txtRadio = new JTextField();
  txtRadio.setBounds(105, 15, 120, 23);
  getContentPane().add(txtRadio);
 
  txtAltura = new JTextField();
  txtAltura.setBounds(105, 39, 120, 23);
  getContentPane().add(txtAltura);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(365, 15, 100, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(365, 39, 100, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 77, 450, 100);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método para el botón Borrar
 void borrar() {
  txtRadio.setText("");
  txtAltura.setText("");
  txtS.setText("");
  txtRadio.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método para el botón Procesar
 void procesar() {
  // Declaración de variables locales
  double radio, altura;
  // Entrada de datos
  radio = Double.parseDouble(txtRadio.getText());
  altura = Double.parseDouble(txtAltura.getText());
  // Invocación de métodos
  txtS.setText("");
  calcularAreaBase(radio);
  calcularAreaLateral(radio, altura);
  calcularAreaTotal(radio, altura);
 }
 
 // -----------------------------------------------------------------------
 // Calcula el área de la base
 void calcularAreaBase(double radio) {
  double areabas;
  areabas = Math.PI * radio * radio;
  imprimir("Area base : " + areabas);
 }
 
 // -----------------------------------------------------------------------
 // Calcula el área lateral
 void calcularAreaLateral(double radio, double altura) {
  double arealat;
  arealat = 2 * Math.PI * radio * altura;
  imprimir("Area lateral : " + arealat);
 }
 
 // -----------------------------------------------------------------------
 // Calcula el área total
 void calcularAreaTotal(double radio, double altura) {
  double areatot;
  areatot = 2 * Math.PI * radio * (radio + altura);
  imprimir("Area total : " + areatot);
 }
 
 // -----------------------------------------------------------------------
 // Imprime una línea de texto con un salto de línea al final
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
}

Problema 7

Diseñe un programa que determine la cantidad de días y el nombre de un mes conociendo los valores numéricos del mes y del año.

Declare todas las variables como locales y use métodos tipo void.

Programa


Código Fuente

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema07 extends JApplet implements ActionListener {
 // Declaración de variables globales para la GUI
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblAño, lblMes;
 JTextField txtAño, txtMes;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  txtMes = new JTextField();
  txtMes.setBounds(61, 15, 107, 23);
  getContentPane().add(txtMes);
 
  txtAño = new JTextField();
  txtAño.setBounds(61, 39, 107, 23);
  getContentPane().add(txtAño);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(305, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(305, 39, 101, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  lblAño = new JLabel("Año");
  lblAño.setBounds(15, 39, 42, 23);
  getContentPane().add(lblAño);
 
  lblMes = new JLabel("Mes");
  lblMes.setBounds(15, 15, 42, 23);
  getContentPane().add(lblMes);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 75, 394, 87);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtS.setText("");
  txtMes.setText("");
  txtAño.setText("");
  txtMes.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración de variables locales
  int mes, año;
  // Entrada de datos
  mes = Integer.parseInt(txtMes.getText());
  año = Integer.parseInt(txtAño.getText());
  // Invocación de métodos
  txtS.setText("");
  determinaNombreMes(mes);
  determinaNumeroDiasMes(mes, año);
 }
 
 // -----------------------------------------------------------------------
 // Determina el nombre del mes
 void determinaNombreMes(int mes) {
  // Declaración de variables locales
  String nombre;
  // Determina el nombre del mes
  switch (mes) {
  case 1:
   nombre = "Enero";
   break;
  case 2:
   nombre = "Febrero";
   break;
  case 3:
   nombre = "Marzo";
   break;
  case 4:
   nombre = "Abril";
   break;
  case 5:
   nombre = "Mayo";
   break;
  case 6:
   nombre = "Junio";
   break;
  case 7:
   nombre = "Julio";
   break;
  case 8:
   nombre = "Agosto";
   break;
  case 9:
   nombre = "Setiembre";
   break;
  case 10:
   nombre = "Octubre";
   break;
  case 11:
   nombre = "Noviembre";
   break;
  default:
   nombre = "Diciembre";
  }
  // Muestra el nombre del mes
  imprimir("Nombre del mes : " + nombre);
 }
 
 // -----------------------------------------------------------------------
 // Determina el número de días del mes
 void determinaNumeroDiasMes(int mes, int año) {
  // Declaración de variables locales
  int dias;
  // Determina el número de días del mes
  switch (mes) {
  case 1:
  case 3:
  case 5:
  case 7:
  case 8:
  case 10:
  case 12:
   dias = 31;
   break;
  case 4:
  case 6:
  case 9:
  case 11:
   dias = 30;
   break;
  default:
   if ((año % 4 == 0) && ((año % 100 != 0) || (año % 400 == 0)))
    dias = 29;
   else
    dias = 28;
  }
  // Muestra el número de días del mes
  imprimir("Número de días : " + dias);
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena de texto incluyendo un salto de línea al final
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
}

Para recordar


Un método con valor de retorno es un método que puede recibir datos de entrada a través de variables locales al método conocidas como parámetros y que retorna un valor al punto donde es invocado.

Descargar ejercicios resueltos


 Descargar archivo

Puedes completar lo aprendido asistiendo el material en video.

   Clic aquí

¡Acabas de ver el tema número 21 del curso de Introducción a la Algoritmia y a la programación en Java! ¡Fácil verdad! Ir al índice

¡Qué pases un buen día!

Corre la voz

No hay comentarios, ¡cuéntame algo!

Me gustaría saber tu opinión. ¡Saludos!

Suscribirse a: Comentarios de la entrada (Atom)
joseltoro© 2019 Todos los derechos reservados