Capítulo 86: Elementos al azar en Java

Diario de un programador. Día 188

Elementos al azar en Java

La clase Random, del paquete java.util, a diferencia del método static de la clase Math(que solamente produce valore de tipo double), es capaz de producir valores de tipo boolean, float, byte, double, int, long y gaussianos.

Para usar esta clase, primer se debe importar. Esto se logra de la siguiente manera:

import java.util.Random;

Luego, la forma de crear el objeto es similar al utilizado para crear un objeto Scanner. Esto se logra de la siguiente manera:

Random azar = new Random();

Ya con esto creado podemos generar todos los tipos de números aleatorios que se mencionaron anteriormente, pero en este caso para simplificar las cosas, vamos a probar con números enteros. Por ejemplo, si hacemos lo siguiente:

int numeroAzar = azar.nextInt();

la variable numeroAzar podría tener un número entre  –2.147.483.648 y 2.147.483.647. Si quisiéramos que nuestro número se encuentre en un rango menor, digamos entre los primeros 10 números, entonces se puede hacer de esta otra manera:

int numeroAzar = azar.nextInt(10);

Al agregar un argumento a nextInt, estamos diciendo que nuestro número sea escogido entre el cero y el nueve. No se incluye el número ingresado en el argumento.

Vamos a ver un pequeño ejemplo:

import java.util.Random;

public class azar{

  public static void main(String[]args){

 

  Random azar = new Random();

  int numeroAzar = azar.nextInt(10);

  System.out.println("El numero escogido es: " + numeroAzar);

  }

}

¿Cómo crearíamos un arreglo con números al azar? Se me ocurre la siguiente alternativa:

Creo un arreglo de 10 elementos y una variable de tipo entero llamada numAzar, en esta última variable se irán generando los números al azar.

Para lograr esto lo que hice fue crear un ciclo for y dentro de él puse numAzar, la cual por cada ciclo irá generando un número al azar. Este número generado es ingresado al arreglo mientras el ciclo continua con su trabajo.

Al finalizar, se crea otro ciclo for, el cual se encarga de mostrar el contenido del arreglo.

import java.util.Random;

public class azar{

  public static void main(String[]args){

 

  //Se crea un objeto random, un arreglo y variables   

  Random azar = new Random();

  int arreglo[] = new int[10];

  int numAzar, i;

 

  //Se crean 10 numeros al azar y se guardan

  //en un arreglo

  for(i = 0;i < 10; i++){

      numAzar = azar.nextInt(10);

      arreglo[i] = numAzar;

  }

  //se muestran los numeros del arreglo

  for(i = 0;i < 10; i++){

      System.out.println("[" + arreglo[i] + "]");

  }

  System.out.println("");

  }

}

Luego de  ejecutar, este es el resultado:

Los elementos al azar se pueden utilizar en múltiples tareas, como por ejemplo, el reproductor de música lo utiliza para poder escoger una canción al azar y así evitar estar escuchando siempre las canciones en el mismo orden.

A continuación pondré un pequeño programa que escoge un número al azar y nosotros trataremos de encontrar ese número. Al final nos dirá cuántos intentos nos tomó.

Este programa consta de dos clases.

//clase pricipal

import javax.swing.JOptionPane;

public class Inicio{

  public static void main(String []args){

     

    String numero;

    int numeroConvertido, intentos = 0;

    Metodos datos = new Metodos();

   

    do{

        //solicitamos un numero en formato String, para que pueda

        //ser aceptado por JOptionPane

        numero = JOptionPane.showInputDialog("Ingresa un numero:");

        //el numero es convertido a int para poder pasarlo como

        //argumento al metodo comparaResultado

        numeroConvertido = Integer.parseInt(numero);

    

        //Se envian los datos al metodo comparaResultado y se recupera

        //un resultado

        JOptionPane.showMessageDialog(null, datos.comparaResultado(numeroConvertido));

        //por cada ciclo agregamos un intento

        intentos++;

       

    //se repetira el ciclo hasta que encontremos el numero   

    }while(numeroConvertido != datos.azar());

   

    //saliendo del ciclo se muestra el numero de intentos

    JOptionPane.showMessageDialog(null, "Nro. de intentos: " + intentos);

  }//fin main

}//fin class

//clase metodos

import java.util.Random;

public class Metodos{

   

  Random azar = new Random();

  private int numeroIngresado;

  private int numAzar;

 

  //constructor

  public Metodos(){

    numeroIngresado = 0; 

    numAzar = azar.nextInt(10);

  }

  //metodo que compara el numero ingresado

  //con el numero al azar

  public String comparaResultado(int num){

    numeroIngresado = num;

    if (numeroIngresado == numAzar){

        return "Son iguales";   

    }//fin if   

    else if(numeroIngresado > numAzar){

        return "El numero ingresado es mayor";   

    }//fin if

    else{

        return "El numero ingresado es menor";

    }//fin if

  }//fin metodo

 

  //para recuperar el numero al azar

  public int azar(){

      return numAzar;

  }

}//fin class

Esto es todo por ahora. Saludos

Gustavo J. Cerda Nilo

Diciembre 2016

Capítulo 82. Creando figuras en Java

Diario de un programador. Día 184

Creando figuras en Java.

Al igual que en su tiempo hicimos esto en Small Basic y luego en Python. Llegó el momento de ver estas operaciones en Java. En esta ocasión, lo primero que se hará será crear un círculo y un cuadrado.

Para crear un crear un círculo, se utiliza el método drawOval y para crear un cuadrado se utiliza el método drawRect. Ambos métodos requieren de cuatro argumentos, siendo los dos primeros los que indiquen la posición desde donde se empezará a dibujar la figura y los otros dos sirven para dimensionar la figura en su ancho y alto.

Como ambos métodos son muy parecidos en su forma de programarse, vamos a mostrarlos al mismo tiempo.

Al igual que en el tutorial pasado, vamos a utilizar dos clases. La clase principal se llamará Inicio y la otra se llamará Ventana. Estas clases contendrán los mismos elementos que fueron utilizados  en el tutorial anterior exceptuando los que son utilizados para crear las líneas ya que en esta ocasión no las utilizaremos (nos centraremos solamente en los círculos y cuadrados por el momento). La clase Inicio, se mantendrá igual, sin cambios, pero de todas formas la voy a escribir a continuación.

import javax.swing.JFrame;

public class Inicio{

  public static void main(String []args){

   

    Ventana panel = new Ventana();

    JFrame marco = new JFrame();

   

    marco.add(panel);

    marco.setSize(250,250);

    marco.setVisible(true);

    marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

  }

}

En la clase ventana voy a poner los métodos correspondientes para crear un cuadrado y un círculo.

import javax.swing.JPanel;

import java.awt.Graphics;

public class Ventana extends JPanel{

  public void paintComponent(Graphics g){

   super.paintComponent(g);

  

   g.drawRect(10,10,150,150);

   g.drawOval(10,10,150,150);

  }

}

Esto creará un cuadrado y un círculo con las mismas coordenadas. Al ejecutar el programa, esto se vería así:

Entonces, para variar la forma y ubicación de las figuras, solamente habría que modificar sus atributos.

Hay muchas más figuras que se pueden crear, pero eso lo dejaremos para otro tutorial. Antes de seguir avanzando quiero mencionar un tema que se mencionó hace algún tiempo y que quedé con la deuda de explicar con un poco más de detalle. Me refiero a los métodos static.

METODOS STATIC

Un método static, también conocido como método de clase, es un método que no depende del contenido de un objeto, sino más bien, es un método que depende de su clase. Esto quiere decir que no hay que crear objetos para estos métodos para poder usarlos, como cuando creamos un objeto con la palabra new.  Por lo general, los métodos static se utilizan para realizar tareas comunes que representan a sus clases. Al declarar un método como static en una clase, se permite acceder de una forma "casi" directa a ese método, pero solamente para realizar la función que tiene ese método y no para manipular  sus atributos (variables). Esta es una de las diferencias que tienen los métodos static de los no static.

Un método static sólo puede llamar directamente a otros métodos static de la misma clase
(es decir, usando el nombre del método por sí solo). Para acceder a los miembros no static de la clase, un método static debe usar una referencia a un objeto de esa clase. Los métodos no static se asocian con una instancia específica de la clase y pueden manipular las variables de instancia de ese objeto. Java no permite que un método static acceda directamente a los miembros no static de la misma clase.

Para utilizar o llamar a un método static, hay que escribir el nombre de la clase seguido de un punto y el nombre del método. De esta forma:

nombreClase.nombreMetodo();

Por ejemplo, la clase Math, posee muchos métodos static y para utilizarlos no es necesario crear un objeto como dijimos antes, a diferencia de la clase Scanner en la cual tenemos que crear un objeto con la palabra new. Volviendo a la clase Math, el método Math.pow() permite calcular la potencia de un número, o el método Math.sqrt(), permite calcular la raíz cuadrada. Por cierto, la clase Math, es parte del paquete java.lang que se importa de manera implícita (o automática), lo que significa que no hay necesidad de importarla para utilizar sus métodos.

En el siguiente ejemplo, se implementó un método static que calcula una potencia sin utilizar el método Math, esto se logró con un método recursivo (que se llama a sí mismo). En este caso el método al encontrarse en la misma clase, no es necesario (aunque es posible) escribirlo mediante el nombre de la clase seguido de un punto. Simplemente se llama por el nombre del método.

import java.util.Scanner;

public class Ejercicios{

  public static void main(String []args){

    Scanner ingreso = new Scanner(System.in);

    int a,b;

        System.out.print("Base: ");

        a = ingreso.nextInt();

        System.out.print("Exponente: ");

        b = ingreso.nextInt();

//método potencia(a,b) se llamo sin el nombre de su clase por encontrase

//dentro de la misma. Ejercicios.potencia(a,b) produce el mismo resultado

        System.out.println("Resultado: "+ potencia(a,b));

    }//fin main

    //Metodo static se implementa fuera del método main

    public static int potencia(int base, int exp){

      if (exp == 0)

         return 1;

      else

         return base * potencia(base,exp - 1);

  }//fin metodo

}//fin class

Si implementamos este mismo ejemplo en una clase distinta, entonces en esa ocasión sí que hay que llamar al método por el nombre de su clase seguido de un punto y el nombre del método.

Ejemplo de esa situación a continuación:

//clase main

public class Ejercicios{

  public static void main(String []args){

    Scanner ingreso = new Scanner(System.in);

    int a,b;

        System.out.print("Base: ");

        a = ingreso.nextInt();

        System.out.print("Exponente: ");

        b = ingreso.nextInt();

//Se llama al método static mediante el nombre de su clase seguido de un punto

//y luego el nombre del método

        System.out.println("Resultado: "+ Metodos.potencia(a,b));

    }//fin main

}//fin class

//Clase creada en un archivo diferente

public class Metodos{

  public static int potencia(int base, int exp){

    if (exp == 0)

      return 1;

    else

      return base * potencia(base,exp - 1);

  }//fin metodo

}//fin class

Como se mencionó antes, la clase Math, proporciona varios métodos static, entre los cuales podemos destacar los siguientes:

abs( x ) valor absoluto de x

ceil( x ) redondea x al entero más pequeño que no sea menor de x

cos( x ) coseno trigonométrico de
exp( x ) método exponencial e
floor( x ) redondea x al entero más grande que no sea mayor de x

log( x ) logaritmo natural de x

max( x, y ) el valor más grande de x y

min( x, y ) el valor más pequeño de x y

pow( x, y ) x elevado a la potencia

sin( x ) seno trigonométrico de x

sqrt( x ) raíz cuadrada de x

tan( x ) tangente trigonométrica de x

Lo siguiente es un extracto que saqué textual de la web.

¿Por qué el método main se declara como static?

Al declarar a main como static, la Máquina Virtual de Java (JVM) puede invocar a main sin tener que crear una instancia de la clase.

Esto es todo por ahora. Saludos

Gustavo J. Cerda Nilo

Septiembre 2016, Octubre 2016

Capítulo 78: Creando líneas en Java

Diario de un programador. Día 180

Dibujando líneas en Java

Para dibujar líneas en Java hay que utilizar un sistema de coordenadas, el mismo que se ha visto en oportunidades anteriores, donde la ubicación 0,0 corresponde a la esquina superior izquierda.

En este tutorial, se van a ver varias instrucciones nuevas así que trataré de explicarlas poco a poco.

Lo primero que vamos a hacer es dibujar una simple línea diagonal en una ventana gráfica, donde posteriormente iremos agregando más líneas.

Lo primero que haremos será crear un proyecto nuevo. En mi caso el proyecto se llama Grafico01. Este proyecto tiene dos clases, una que llamé Inicio y la otra que llamé Ventana

En primer lugar voy a escribir en la clase Ventana.

En esta clase, lo primero que voy a hacer es importar dos clases. La clase Graphics, que se encuentra en el paquete java.awt y la clase JPanel, que se encuentra en el paquete javax.swing

La clase Graphics proporciona varios métodos que permiten dibujar texto y figuras en la pantalla, mientras la clase JPanel, proporciona un área en la cual podemos dibujar.

Para importar ambas clases hacemos lo siguiente en la clase Ventana:

import java.awt.Graphics;

import javax.swing.JPanel;

Una vez escrito lo anterior, lo siguiente es crear la clase, la cual creamos de la siguiente forma:

import java.awt.Graphics;

import javax.swing.JPanel;

public class Ventana extends JPanel{

}

Esta clase incluye algo que no habíamos visto hasta ahora, la palabra extends, significa que la clase Ventana hereda las características y atributos de la clase JPanel. En resumidas cuentas, esto significa que la clase Ventana podrá ocupar los métodos de la clase JPanel. El tema de la herencia es otra de las características de la programación orientada a objetos. La herencia la estudiaremos con más detalle en futuros tutoriales.

Lo siguiente que debemos crear, es un método que el sistema llama automáticamente cada vez que necesita llamar a JPanel. Todo JPanel debe tener este método, el cual se escribe de la siguiente forma:

import java.awt.Graphics;

import javax.swing.JPanel;

public class Ventana extends JPanel{

    public void paintComponent(Graphics g){

    }

}

Este método se llama cuando se muestra un objeto JPanel por primera vez en la pantalla, cuando una ventana en la pantalla lo cubre y después lo descubre, y cuando la ventana en la que aparece cambia su tamaño.

La primera instrucción que debe tener todo método paintComponent es la siguiente:

import java.awt.Graphics;

import javax.swing.JPanel;

public class Ventana extends JPanel{

    public void paintComponent(Graphics g){

        super.paintComponent(g);

    }

}

Esta instrucción asegura que el panel se despliegue apropiadamente en la pantalla antes de empezar a dibujar en él.

Lo siguiente que vamos a ocupar, aunque no es obligatorio es interesante. Son los métodos getHeight() y getWidth(), los cuales en este caso devolverán el alto y el ancho del objeto JPanel. Estos valores los almacenaremos en unas variables llamadas "alto" y "ancho", de la siguiente manera:

import java.awt.Graphics;

import javax.swing.JPanel;

public class Ventana extends JPanel{

    public void paintComponent(Graphics g){

        super.paintComponent(g);

        int alto = getHeight();

        int ancho = getWidth();

    }

}

Por último, vamos a utilizar la referencia g de la clase Graphics para llamar al método drawLine, el cual nos permitirá dibujar líneas. El método drawLine requiere de cuatro argumentos, x1,y1 para indicar el comienzo de la línea y x2,y2 para indicar el final de la línea.

import java.awt.Graphics;

import javax.swing.JPanel;

public class Ventana extends JPanel{

    public void paintComponent(Graphics g){

        super.paintComponent(g);

        int alto = getHeight();

        int ancho = getWidth();

       

        g.drawLine(0,0,ancho,alto);

    }

}

Las primeras dos coordenadas se establecieron en la coordenada 0,0 lo que significa que el inicio de la línea se encuentra en la equina superior izquierda. Las últimas dos coordenadas se establecieron según el ancho y el alto del panel. Esto significa que el final de la línea se encuentra en la esquina inferior derecha. Estas coordenadas dibujan una línea diagonal. Si se cambia el tamaño de la ventana, las líneas se escalarán de manera uniforme ya que los argumentos se basan en el alto y ancho del panel. Al cambiar el tamaño de la ventana, el sistema llama a paintComponent para volver a dibujar el contenido.

Ya con esto, damos por finalizado el código de la clase Ventana. Pasemos ahora a escribir el código de la clase Inicio.

Para poder colocar el panel necesitamos de un marco, (por esta razón a la otra clase le di el nombre ventana. Imaginé que la ventana es el vidrio y que el vidrio debe ser puesto en un marco). Para esto, vamos a importar la clase JFrame, la cual se encuentra en el paquete javax.swing. Esto quedará de la siguiente manera:

import javax.swing.JFrame;

Lo siguiente es crear la clase y su método main:

import javax.swing.JFrame;

public class Inicio {

  public static void main(String[]args){

}

Lo siguiente que vamos a hacer es crear una instancia de la clase Ventana, de la siguiente manera:

Ventana panel = new Ventana();

Esto  es algo que ya se sabe hacer así que no hay nada nuevo que explicar.

Lo siguiente, es crear un objeto de la clase JFrame que permita contener y mostrar el panel. Esto quedará de la siguiente manera:

import javax.swing.JFrame;

public class Inicio {

  public static void main(String[]args){

   

    Ventana panel = new Ventana();

    JFrame marco = new JFrame();

}

Lo siguiente es utilizar un método que permite adjuntar el objeto que contiene el dibujo al objeto JFrame.  Este es el método add de JFrame. Se utiliza de la siguiente forma:

import javax.swing.JFrame;

public class Inicio {

  public static void main(String[]args){

   

    Ventana panel = new Ventana();

    JFrame marco = new JFrame();

    marco.add(panel);

}

Lo siguiente es dar un tamaño a nuestro marco. Para esto, se utiliza el método setSize, el cual recibe como parámetros el ancho y el alto del objeto JFrame.

import javax.swing.JFrame;

public class Inicio {

  public static void main(String[]args){

   

    Ventana panel = new Ventana();

    JFrame marco = new JFrame();

    marco.add(panel);

    marco.setSize(250,250);

}

El siguiente método, nos permite mostrar el objeto JFrame, cuando se muestra este objeto, se hace una llamada al método paintComponent. El método a utilizar es setVisible y se utiliza de la siguiente manera:

import javax.swing.JFrame;

public class Inicio {

  public static void main(String[]args){

   

    Ventana panel = new Ventana();

    JFrame marco = new JFrame();

    marco.add(panel);

    marco.setSize(250,250);

    marco.setVisible(true);

}

Ya por último, nos queda implementar un método que permita que el programa finalice si el usuario cierra la ventana (presionando la X de la esquina superior derecha). Sin este método, el programa continuará corriendo si el usuario cierra la ventana. Este método es setDefaultCloseOperation y utiliza como argumento JFrame.EXIT_ON_CLOSE, para indicar que el programa debe finalizar si se cierra la ventana. Este método se vería de la siguiente forma:

import javax.swing.JFrame;

public class Inicio {

  public static void main(String[]args){

   

    Ventana panel = new Ventana();

    JFrame marco = new JFrame();

    marco.add(panel);

    marco.setSize(250,250);

    marco.setVisible(true);

    marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

Ya está listo. Al ejecutar el programa esto es lo que debería salir:

Además, si con el ratón cambias el tamaño de la ventana, la línea se ajusta al tamaño de esta

Esto es todo por ahora. Saludos

Gustavo J. Cerda Nilo

Agosto 2016, Octubre 2016

Capítulo 73. Java: Introducción a los gráficos

Diario de un programador. Día 175

Java

Introducción a los gráficos.

Es hora de hacer una pequeña introducción a los gráficos que son tan comunes hoy en día. En esta ocasión, se presentarán los cuadros de dialogo, para lo cual se utilizará la clase JOptionPane que se encuentra en el paquete javax.swing, en otras palabras, para poder utilizar la classe JOptionPane, se debe importar el paquete javax.swing.

El primer método que se utilizará será el método showMessageDialog, el cual permite mostrar un mensaje de dialogo. Veamos un ejemplo.

Lo siguiente es crear una clase, en mi caso se llamará Dialogo. Una vez creada la clase y el método main, lo siguiente que se hará será importar la clase JOptionPane del paquete javax.swing.

import javax.swing.JOptionPane;

public class Dialogo {

  public static void main(String[] args){

   

  }//fin main

}//fin class

Lo siguiente es agregar el método showMessageDialog. Se hace de la siguiente manera:

import javax.swing.JOptionPane;

public class Dialogo {

  public static void main(String[] args){

   

    JOptionPane.showMessageDialog(null,"Bienvenido joven programador");

   

  }//fin main

}//fin class

Eso es todo. Ahora solo falta ejecutar el programa y si todo salió bien, entonces un mensaje debería de mostrarse en pantalla.

La clase JOptionPane, contiene cuadros de diálogos previamente empaquetados, los cuales permiten que los programas muestren ventanas con mensajes.

El método showMessageDialog, requiere de dos argumentos, el primero sirve para indicar la ubicación del cuadro de dialogo, al ser null, el cuadro de dialogo aparece en el centro de la pantalla. El segundo argumento corresponde al mensaje del cuadro.

El método showMessageDialog, es un método static. A menudo los métodos static realizan operaciones que son utilizadas con frecuencia, como en este caso el mostrar un mensaje y no requieren que se cree explícitamente un objeto. Más adelante se darán mayores detalles de los métodos static.

El siguiente método que se presentará, es el que permite mostrar un cuadro de texto para solicitar datos al usuario. El método es showInputDialog, este método requiere solo un argumento y es el mensaje que mostrará en el cuadro. Ejemplo:

import javax.swing.JOptionPane;

public class Dialogo {

  public static void main(String[] args){

   

    JOptionPane.showInputDialog("Ingresa tu nombre:");

   

  }//fin main

}//fin class

Al ejecutar el programa, aparece el siguiente cuadro de dialogo:

Al ingresar algún dato y presionar el botón "Aceptar", nada sucede debido a que no hay nada asociado a este cuadro de dialogo. Entonces, lo que se hará a continuación será guardar lo ingresado por el usuario en una variable para que luego esta información sea mostrada en un cuadro de mensaje. Se modificará el programa anterior de la siguiente manera:

import javax.swing.JOptionPane;

public class Dialogo {

  public static void main(String[] args){

    String nombre;

   

    nombre = JOptionPane.showInputDialog("Ingresa tu nombre:");

    JOptionPane.showMessageDialog(null,"Saludos "+ nombre);

   

  }//fin main

}//fin class

Como se puede ver, se creó una variable de tipo String, a la cual llamé "nombre". Esta variable es la encargada de almacenar lo ingresado por el usuario. Posteriormente esta variable es utilizada en MessageDialog.

Ahora, si se ejecuta nuevamente el programa y se escribe por ejemplo la palabra "alumno", esto es lo que debería suceder:

Algo que no he mencionado hasta el momento es que el método showInputDialog, solamente acepta cadenas para sus ingresos. Entonces, si quiero por ejemplo realizar alguna operación con números ¿cómo lo hago?. Para casos como estos, se puede convertir la cadena ingresada en un entero, con el método Integer.parseInt(cadena). Mostraré este método con un ejemplo simple, el cual verificará si el número ingresado es par o impar. Este método lo que hace es convertir la cadena ingresada como argumento a un número entero. En el ejemplo que se muestra a continuación, se solicitó un número el cual fue guardado en la variable "cadena", luego se utilizó el método Integer.parseInt para convertir la cadena ingresada en un número entero. El número conseguido fue almacenado en la variable "entero", con la cual se procedió a realizar las demás operaciones que consisten en verificar si lo ingresado es un número par o no.

import javax.swing.JOptionPane;

public class Pares {

  public static void main(String[] args){

    int entero;

    String cadena;

   

    cadena = JOptionPane.showInputDialog("Ingresa un número");

    entero = Integer.parseInt(cadena);

    

    if(entero % 2 == 0){

     JOptionPane.showMessageDialog(null,"El número es par");

    }

    else{

     JOptionPane.showMessageDialog(null,"El número es impar");

    }

     

  }//fin main

}//fin class

Con estos nuevos conocimientos, es posible retomar "antiguos" programas que se hicieron en capítulos anteriores y reprogramarlos utilizando estos métodos con la finalidad de practicar. A modo de ejemplo, voy a reprogramar aquel programa que servía para calcular el promedio de 5 números.

import javax.swing.JOptionPane;

public class Ejercicios {

  public static void main(String[] args){

    int i, numero, suma = 0;

    double promedio;

    String ingreso;

   

    JOptionPane.showMessageDialog(null, "Ingresa 5 números");

   

    for(i = 1; i <= 5; i++){

      ingreso = JOptionPane.showInputDialog("Ingreso Nro." + i);

      numero = Integer.parseInt(ingreso);

      suma = suma + numero;

    } 

    promedio = suma / 5;

   

    JOptionPane.showMessageDialog(null,"El promedio es "+ promedio);

   

  }//fin main

}//fin class

Actualización Septiembre 2016

Para utilizar esto de los cuadro de texto y mensajes en archivos distintos utilizando un constructor y un método get y set. Mostraré un pequeño programa que solicita que ingrese un nombre:

//Clase principal

import javax.swing.JOptionPane;

public class Inicio{

  public static void main(String []args){

    String nombre;

    Metodos datos = new Metodos();

    nombre = JOptionPane.showInputDialog("Ingresa tu nombre:");

    datos.setNombre(nombre);

    JOptionPane.showMessageDialog(null, "Bienvenido "+ datos.getNombre());

  }//fin main

}//fin class

//Clase de métodos

public class Metodos{

  private String nombre;

  public Metodos(){

    nombre = ""; 

  }

  public void setNombre(String nom){

    nombre = nom;

  }

  public String getNombre(){

    return nombre;

  }

}//fin class

Esto es todo por ahora. Para practicar, se pueden reprogramar algunos de los ejercicios planteados en el capítulo 56, hasta dominar estos nuevos métodos. Hasta la próxima.

Gustavo J. Cerda Nilo

Mayo 2016, Septiembre 2016