Josel Toro: Métodos con valor de retorno

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 con valor de retorno y las estructuras básicas y de selección, diseñaremos programas en Java que resuelvan problemas planteados.

En el tema anterior habíamos visto el uso del método tipo void o sin valor de retorno.

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é son los métodos con valor de retorno?

Un método con valor de retorno es un módulo de programa que puede recibir datos de entrada a través de variables locales denominadas parámetros y que retorna un resultado al punto donde es invocado. Este tipo de método se utiliza para efectuar cualquier tipo de proceso que produzca un resultado

Estos métodos pueden dividirse a su vez en dos tipos:

. Métodos con valor de retorno sin parámetros.
. Métodos con valor de retorno con parámetros.

Métodos con valor de retorno, sin parámetros

Este tipo de métodos no reciben datos de entrada; pero, retornan un resultado al punto donde son invocados.

Método con valor de retorno sin parámetros

Definición

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

tipo nombre(){
 
      // Declaración de variables locales
 
      // Cuerpo del método
 
      return valor;
 
}

Donde:

nombre: es el nombre del método.
valor: es el valor a ser retornado por el método.
tipo: es el tipo de dato del valor de retorno.

Llamada

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

1	`variable = nombre();`

Donde1:

variable: es la variable que recibe el valor retornado por el método- nombre: es el nombre del método invocado.

Métodos con valor de retorno con parámetros

Estos métodos reciben datos de entrada a través de parámetros y retornan un resultado al punto de su invocación.

Definición

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

tipo nombre( tipo1 p1, tipo2 p2, tipo3 p3, . . .){
 
       // Declaración de variables locales
 
       // Cuerpo del método
 
       return valor;
 
}

Donde:

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

Llamada

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

1	`variable = nombre(v1, v2, v3, . . . );`

Donde:

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

Problemas

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 locales y use métodos con valor de retorno para cada una de las entradas y para cada uno de los cálculos.

Programa

Código Fuente Modo 1

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema01a extends JApplet implements ActionListener{
  
 // Declaración de variables globales
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JComboBox choCategoria;
 JLabel lblCategoria, lblPromedio;
 JTextField txtPromedio;
 JScrollPane scpScroll;
  
 // -----------------------------------------------------------------------
 // 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 ){
  if( e.getSource() == btnProcesar )
   procesar();
  if( e.getSource() == btnBorrar )
   borrar();
 }
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar(){
  // Declaración de variables locales
  int categoria;
  double actualpen, nuevapen, descuento, promedio;
  // 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(){
  int categoria;
  categoria = choCategoria.getSelectedIndex();
  return categoria;
 }
 // -----------------------------------------------------------------------
 // Lee y retorna el promedio
 double getPromedio(){
  double promedio;
  promedio = Double.parseDouble(txtPromedio.getText());
  return promedio;
 }
 // -----------------------------------------------------------------------
 // Calcula y retorna la pensión actual
 double calcularPensionActual(int categoria){
  double actualpen;
  switch(categoria){
   case 0:
    actualpen = 550;
    break;
   case 1:
    actualpen = 500;
    break;
   case 2:
    actualpen = 460;
    break;
   default:
    actualpen = 400;
  }
  return actualpen;
 }
 // -----------------------------------------------------------------------
 // Cálcula el descuento
 double calcularDescuento(double promedio, double actualpen){
  double descuento;
  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;
  return descuento;
 }
 // -----------------------------------------------------------------------
 // Calcula la nueva pensión
 double calcularNuevaPension(double actualpen, double descuento){
  double nuevapen;
  nuevapen = actualpen - descuento;
  return 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

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema01b extends JApplet implements ActionListener {
  
 // Declaración de variables globales
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JComboBox choCategoria;
 JLabel lblCategoria, lblPromedio;
 JTextField txtPromedio;
 JScrollPane scpScroll;
  
 // -----------------------------------------------------------------------
 // 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 ){
  if( e.getSource() == btnProcesar )
   procesar();
  if( e.getSource() == btnBorrar )
   borrar();
 }
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar(){
  // Declaración de variables locales
  int categoria;
  double actualpen, nuevapen, descuento, promedio;
  // 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

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema02 extends JApplet implements ActionListener{
  
 // Declaración de variables globales
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblMinutosTar, lblNumeroObs;
 JTextField txtMinutosTar, txtNumeroObs;
 JScrollPane scpScroll;
  
 // -----------------------------------------------------------------------
 // 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 Procesar
 void procesar(){
  // Declaración de variables locales
  int minutosTar, numeroObs, puntajePun, puntajeRen, puntajeTot;
  double bonificacion;
  // Entrada de datos
  minutosTar = getMinutos();
  numeroObs = getObservaciones();
  // Proceso de cálculo
  puntajePun = determinarPuntajePuntualidad(minutosTar);
  puntajeRen = determinarPuntajeRendimiento(numeroObs);
  puntajeTot = determinarPuntajeTotal(puntajePun, puntajeRen);
  bonificacion = determinarBonificacion(puntajeTot);
  // Salida de resultados
  txtS.setText("");
  imprimir("Puntaje por puntualidad : " + puntajePun);
  imprimir("Puntaje por rendimiento : " + puntajeRen);
  imprimir("Puntaje total : " + puntajeTot);
  imprimir("Bonificación : " + bonificacion);
 }
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar(){
  txtMinutosTar.setText("");
  txtNumeroObs.setText("");
  txtS.setText("");
  txtMinutosTar.requestFocus();
 }
 // -----------------------------------------------------------------------
 // Lee y retorna los minutos de tardanza
 int getMinutos(){
  return Integer.parseInt(txtMinutosTar.getText());
 }
 // -----------------------------------------------------------------------
 // Lee y retorna el número de observaciones
 int getObservaciones(){
  return Integer.parseInt(txtNumeroObs.getText());
 }
 // -----------------------------------------------------------------------
 // Determina y retorna el puntaje por puntualidad
 int determinarPuntajePuntualidad(int minutosTar){
  if(minutosTar == 0)
   return 10;
  else if(minutosTar <= 2)
   return 8;
  else if(minutosTar <= 5)
   return 6;
  else if(minutosTar <= 9)
   return 4;
  else
   return 0;
 }
 // -----------------------------------------------------------------------
 // Determina y retorna el puntaje por rendimiento
 int determinarPuntajeRendimiento(int numeroObs){
  if(numeroObs == 0)
   return 10;
  else if(numeroObs == 1)
   return 8;
  else if(numeroObs == 2)
   return 5;
  else if(numeroObs == 3)
   return 1;
  else
   return 0;
 }
 // -----------------------------------------------------------------------
 // Determina y retorna el puntaje total
 int determinarPuntajeTotal(int puntajePun, int puntajeRen){
  return puntajePun + puntajeRen;
 }
 // -----------------------------------------------------------------------
 // Determina y retorna la bonificación
 double determinarBonificacion(int puntajeTot){
  if(puntajeTot < 11)
   return 2.5*puntajeTot;
  else if(puntajeTot <= 13)
   return 5.0*puntajeTot;
  else if(puntajeTot <= 16)
   return 7.5*puntajeTot;
  else if(puntajeTot <= 19)
   return 10.0*puntajeTot;
  else
   return 12.5*puntajeTot;
 }
 // -----------------------------------------------------------------------
 // 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

Declare todas las variables como locales y use métodos con valor de retorno para cada una de las entradas y para cada uno de los cálculos.

Programa

Código Fuente

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema03 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, myenes, mfrancos, mrublos;
  // Entrada de datos
  meuros = getEuros();
  // Proceso de cálculo
  myenes = convertirAYenes(meuros);
  mfrancos = convertirAFrancos(meuros);
  mrublos = convertirARublos(meuros);
  // Salida de resultados
  txtS.setText("");
  imprimir("Yenes : " + myenes);
  imprimir("Francos : " + mfrancos);
  imprimir("Rublos : " + mrublos);
 }
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar(){
  txtEuros.setText("");
  txtS.setText("");
  txtEuros.requestFocus();
 }
 // -----------------------------------------------------------------------
 // Lee y retorna la cantidad de euros
 double getEuros(){
  return Double.parseDouble(txtEuros.getText());
 }
 // -----------------------------------------------------------------------
 // Convierte a yenes
 double convertirAYenes(double xeuros){
  return (xeuros/0.6750)*108.44;
 }
 // -----------------------------------------------------------------------
 // Convierte a francos
 double convertirAFrancos(double xeuros){
  return (xeuros/0.6750)*24.493;
 }
 // -----------------------------------------------------------------------
 // Convierte a rublos
 double convertirARublos(double xeuros){
  return (xeuros/0.6750)*5.4984;
 }
 // -----------------------------------------------------------------------
 // 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 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 con valor de retorno para cada una de las entradas y para cada uno de los cálculos.

Programa

Código Fuente

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 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 del botón Procesar
 void procesar(){
  // Declaración de variables locales
  double radio, altura, areabas, arealat, areatot;
  // Entrada de datos
  radio = getRadio();
  altura = getAltura();
  // Proceso de cálculo
  areabas = calcularAreaBase(radio);
  arealat = calcularAreaLateral(radio,altura);
  areatot = calcularAreaTotal(radio, altura);
  // Salida de resultados
  txtS.setText("");
  imprimir("Area base : " + areabas);
  imprimir("Area lateral : " + arealat);
  imprimir("Area total : " + areatot);
 }
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar(){
  txtRadio.setText("");
  txtAltura.setText("");
  txtS.setText("");
  txtRadio.requestFocus();
 }
 // -----------------------------------------------------------------------
 // Lee y retorna el radio
 double getRadio(){
  return Double.parseDouble(txtRadio.getText());
 }
 // -----------------------------------------------------------------------
 // Lee y retorna la altura
 double getAltura(){
  return Double.parseDouble(txtAltura.getText());
 }
 // -----------------------------------------------------------------------
 // Calcula el área de la base
 double calcularAreaBase(double radio){
  return Math.PI*radio*radio;
 }
 // -----------------------------------------------------------------------
 // Calcula el área lateral
 double calcularAreaLateral(double radio, double altura){
  return 2*Math.PI*radio*altura;
 }
 // -----------------------------------------------------------------------
 // Calcula y retorna el área total
 double calcularAreaTotal(double radio, double altura){
  return 2*Math.PI*radio*(radio+ altura);
 }
 // -----------------------------------------------------------------------
 // Imprime una línea de texto con un salto de línea al final
 void imprimir( String cad ) {
  txtS.append(cad + "\n");
 }
}

Problema 5

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 con valor de retorno

Programa

Código Fuente

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema05 extends JApplet implements ActionListener{
 // Declaración de variables globales
 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 Procesar
 void procesar(){
  // Declaración de variables locales
  int mes, año, dias;
  String nombre;
  // Entrada de datos
  mes = Integer.parseInt(txtMes.getText());
  año = Integer.parseInt(txtAño.getText());
  // Proceso
  nombre = determinaNombreMes(mes);
  dias = determinaNumeroDiasMes(mes, año);
  // Salida de resultados
  txtS.setText("");
  imprimir("Nombre del mes : " + nombre);
  imprimir("Número de días : " + dias);
 }
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar(){
  txtS.setText("");
  txtMes.setText("");
  txtAño.setText("");
  txtMes.requestFocus();
 }
 // -----------------------------------------------------------------------
 // Determina el nombre del mes
 String determinaNombreMes(int mes){
 String nombre;
 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";
  }
  return nombre;
 }
 // -----------------------------------------------------------------------
 // Determina el número de días del mes
 int determinaNumeroDiasMes(int mes, int año){
  int dias;
  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;
  }
  return 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.