VENTANAS DE DIALOGO

Que Es?

JOptionPane es una Clase que nos provee una serie de ventanas de dialogo predefinidas con el fin de facilitarnos algunos procesos de interacción con el usuario.

Esta clase la encontramos en el paquete javax.swing, por eso para poder utilizarla debemos asegurarnos de tener el import correspondiente (import javax.swing.JOptionPane;)

Para que sirve? 

Supongamos que queremos mostrar algún tipo de mensaje al usuario (Información, Advertencia, Error, Confirmación), pedir un dato o mejor aún, ¿que podríamos hacer para que nuestro usuario seleccione una o mas opciones para ejecutar algún proceso de nuestra aplicación?.

Una buena opción es crear un Scanner y allí poner lo que necesitemos, pero seria mas simple aún si utilizamos alguno de los métodos de JOptionPane, pues esta clase ya nos provee una ventana que hace eso por nosotros.

Los JOptionPane.

A continuación veremos los tipos y algunos usos básicos que podemos darle a las ventanas de dialogo creadas a partir de esta clase.

JOptionPane.showMessageDialog.

Tal vez el mas básico y conocido de todos, el método showMessageDialog() nos genera una ventana de dialogo, con la cual podemos presentar al usuario un mensaje simple.

JOptionPane.showMessageDialog(null,"Es un mensaje Simple de Información");

Lo básico es utilizarlo con 2 parámetros, el primero representa la ventana Padre a la que pertenece (para entender esto los invito a leer JFrame y JDialog) o simplemente dejarlo en "Null" para que sea común en toda la aplicación, el segundo parámetro es el mensaje que queremos presentar.

El método también tiene algunas variantes, podemos adicional a lo anterior agregarle un titulo a nuestra ventana como también definir cual es el icono o tipo de mensaje que queremos presentar, si es de información, error, advertencia o confirmación, esto lo hacemos gracias a las constantes ERROR_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE, QUESTION_MESSAGE, o PLAIN_MESSAGE...

por ejemplo para la ventana de advertencia tan solo debemos escribir el siguiente código (la diferencia con el anterior es que le adicionamos 2 parámetros mas...) 

JOptionPane.showMessageDialog(null, "Este es un mensaje de Advertencia",

  "WARNING_MESSAGE", JOptionPane.WARNING_MESSAGE);

JOptionPane.showInputDialog.

Este método también es muy conocido y útil cuando lo que queremos es solicitar el ingreso de datos, por defecto presenta una ventana simple similar a las anteriores pero con un campo de texto para ingresar información. Por defecto podemos obtener el dato ingresado mediante un String, sin embargo podemos recibir datos numéricos y posteriormente hacer la conversión.

int numero=Integer.parseInt(JOptionPane.showInputDialog("Ingrese un" +

  " numero para multiplicarlo por 2"));

Adicionalmente podemos definir que tipo de opciones mostrar.

El codigo es:

Object color = JOptionPane.showInputDialog(null,"Seleccione Un Color",

   "COLORES", JOptionPane.QUESTION_MESSAGE, null,

  new Object[] { "Seleccione","Amarillo", "Azul", "Rojo" },"Seleccione");

Como vemos el método también nos brinda la posibilidad de vincular un combo de selección donde definimos el arreglo de opciones y el valor seleccionado por defecto.

JOptionPane.showConfirmDialog.

Este método nos brinda una ventana de confirmación donde por defecto se cargan 3 botones "Si", "No", "Cancelar", es muy útil cuando realizamos operaciones delicadas donde siempre es importante que el usuario confirme, también es muy común encontrarla cuando queremos cerrar sesión o salir de nuestra aplicación por medio de un evento determinado.

int resp=JOptionPane.showConfirmDialog(null,"Usas mucho el JOptionPane?");

      if (JOptionPane.OK_OPTION == resp){

   System.out.println("Selecciona opción Afirmativa");

 }

      else{

    System.out.println("No selecciona una opción afirmativa");

   }

El método retorna un valor entero que corresponde a la opción definida por el usuario, igual que en los ejemplos anteriores, existen variantes que podemos vincular para personalizar nuestro JOptionPane, además de los tipos de iconos o mensajes, también podemos usar las constantes YES_OPTION, NO_OPTION, OK_OPTION, CANCEL_OPTION, CLOSED_OPTION que definen cuales opciones mostrar.

JOptionPane.showOptionDialog.

Este es el ultimo de los métodos que trabajaremos pero el que nos brinda mas opciones de configuración, los métodos anteriores son sobreCargados (Mas adelante se explicará este termino en otra entrada), esto quiere decir que tenemos varios métodos con el mismo nombre pero que reciben distintos parámetros...............el showOptionDialog es un único método que posee todos los parámetros requeridos para su configuración.

JCheckBox chec=new JCheckBox("Prueba");

       

int seleccion = JOptionPane.showOptionDialog( null,"Seleccione una opcion",

  "Selector de opciones",JOptionPane.YES_NO_CANCEL_OPTION,

   JOptionPane.QUESTION_MESSAGE,null,// null para icono por defecto.

  new Object[] { "opcion 1", "opcion 2", "opcion 3",chec },"opcion 1");

      

 if (seleccion != -1){

           System.out.println("seleccionada opcion " + (seleccion + 1));

 }

 if (chec.isSelected()){

    System.out.println("Selecciona el Chec");

 }

Con este podemos crear una ventana de dialogo con diferentes opciones definidas en un array de objetos, podemos pasarle diferentes componentes gráficos y el los mostrará sin inconveniente.

Y Listo, básicamente estos son los principales métodos y componentes JOptionPane, con ellos podremos brindar facilidades y ahorrar tiempo en nuestra aplicación, a pesar de estar catalogado como un componente complejo, vemos que su uso es muy pero muy simple.

MATRICES

Una matriz es una estructura de datos que permite almacenar un CONJUNTO de datos del MISMO tipo. Con un único nombre se define la matriz y por medio de DOS subíndices hacemos referencia a cada elemento de la misma (componente).

Hemos graficado una matriz de 3 filas y 5 columnas. Para hacer referencia a cada elemento debemos indicar primero la fila y luego la columna, por ejemplo en la componente 1,4 se almacena el valor 97.
En este ejemplo almacenamos valores enteros. Todos los elementos de la matriz deben ser del mismo tipo (int, float, String etc.).

Las filas y columnas comienzan a numerarse a partir de cero, similar a los vectores.

Una matriz se la puede representar por un conjunto de vectores.


Problema 1:

Crear una matriz de 3 filas por 5 columnas con elementos de tipo int, cargar sus componentes y luego imprimirlas.

CÓDIGO FUENTE

import java.util.Scanner;
public class Matriz1 {
    private Scanner teclado;
    private int[][] mat;
 
    public void cargar() {
        teclado=new Scanner(System.in);
        mat=new int[3][5];
        for(int f=0;f<3;f++) {
            for(int c=0;c<5;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }
        }
    }
 
    public void imprimir() {
        for(int f=0;f<3;f++) {
            for(int c=0;c<5;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }
    }
 
    public static void main(String[] ar) {
        Matriz1 ma=new Matriz1();
        ma.cargar();
        ma.imprimir();
    } 
}

EXPLICACIÓN

Para definir una matriz debemos antecederle los corchetes abiertos y cerrados dos veces:

    private int[][] mat;

De esta forma el compilador de Java puede diferenciar los vectores de las matrices.

Para crear la matriz, es decir hacer la reserva de espacio de todas sus componentes debemos utilizar el operador new y mediante dos subíndices indicamos la cantidad de filas y columnas que tendrá la matriz:

        mat=new int[3][5];

Luego debemos pasar a cargar sus 15 componentes (cada fila almacena 5 componentes y tenemos 3 filas).

Lo más cómodo es utilizar un for anidado, el primer for que incrementa el contador f lo utilizamos para recorrer las filas y el contador interno llamado c lo utilizamos para recorrer las columnas.
Cada vez que se repite en forma completa el for interno se carga una fila completa, primero se carga la fila cero en forma completa, luego la fila uno y finalmente la fila 2. Siempre que accedemos a una posición de la matriz debemos disponer dos subíndices que hagan referencia a la fila y columna

mat[f][c]):

        for(int f=0;f<3;f++) {
            for(int c=0;c<5;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }
        }

Para imprimir la matriz de forma similar utilizamos dos for para acceder a cada elemento de la matriz:

        for(int f=0;f<3;f++) {
            for(int c=0;c<5;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }
    }

Cada vez que se ejecuta todas las vueltas del for interno tenemos en pantalla una fila completa de la matriz, por eso pasamos a ejecutar un salto de línea (con esto logramos que en pantalla los datos aparezcan en forma matricial):

            System.out.println();

VECTORES O ARREGLOS

Java posee la capacidad de definir un conjunto de variables del mismo tipo agrupadas todas ellas bajo un mismo nombre, y distinguiéndolas mediante un índice numérico.

Para definir un array en java es como definir una variable o atributo, pero al especificar el tipo lo que hacemos es colocar un par de corchetes [] para indicar que lo que estamos definiendo es un array.

Por ejemplo:

         public int [] losValores;         

en la cuál definimos un array de enteros llamado losValores. 

Vectores

Hemos empleado variables de distinto tipo para el almacenamiento de datos (variables int, float, String) En esta sección veremos otros tipos de variables que permiten almacenar un conjunto de datos en una única variable.

Un vector es una estructura de datos que permite almacenar un CONJUNTO de datos del MISMO tipo.

Con un único nombre se define un vector y por medio de un subíndice hacemos referencia a cada elemento del mismo (componente).

Problema 1:

Se desea guardar los sueldos de 5 operarios.

Según lo conocido deberíamos definir 5 variables si queremos tener en un cierto momento los 5 sueldos almacenados en memoria. Empleando un vector solo se requiere definir un único nombre y accedemos a cada elemento por medio del subíndice.

CÓDIGO FUENTE

import java.util.Scanner;

public class PruebaVector1 {

    private Scanner teclado;

    private int[] sueldos;

    public void cargar()

    {

        teclado=new Scanner(System.in);

        sueldos=new int[5];

        for(int f=0;f<5;f++) {

            System.out.print("Ingrese valor de la componente:");

            sueldos[f]=teclado.nextInt();

        }

    }

    public void imprimir() {

        for(int f=0;f<5;f++) {

            System.out.println(sueldos[f]);

        }

    }

    public static void main(String[] ar) {

        PruebaVector1 pv=new PruebaVector1();

        pv.cargar();

        pv.imprimir();

    }

}

EXPLICACIÓN

Para la declaración de un vector le antecedemos al nombre los corchetes abiertos y cerrados:

    private int[] sueldos;

Lo definimos como atributo de la clase ya que lo utilizaremos en los dos métodos.

En el método de cargar lo primero que hacemos es crear el vector (en java los vectores son objetos por lo que es necesario proceder a su creación mediante el operador new):

        sueldos=new int[5];

Cuando creamos el vector indicamos entre corchetes la cantidad de elementos que se pueden almacenar posteriormente en el mismo.

Para cargar cada componente debemos indicar entre corchetes que elemento del vector estamos accediendo:

        for(int f=0;f<5;f++) {

            System.out.print("Ingrese valor de la componente:");

            sueldos[f]=teclado.nextInt();

        }

La estructura de programación que más se adapta para cargar en forma completa las componentes de un vector es un for, ya que sabemos de antemano la cantidad de valores a cargar.

Cuando f vale cero estamos accediendo a la primer componente del vector (en nuestro caso sería):

            sueldos[0]=teclado.nextInt();

Lo mas común es utilizar una estructura repetitiva for para recorrer cada componente del vector.

Utilizar el for nos reduce la cantidad de código, si no utilizo un for debería en forma secuencial implementar el siguiente código:

            System.out.print("Ingrese valor de la componente:");

            sueldos[0]=teclado.nextInt();

            System.out.print("Ingrese valor de la componente:");

            sueldos[1]=teclado.nextInt();

            System.out.print("Ingrese valor de la componente:");

            sueldos[2]=teclado.nextInt();

            System.out.print("Ingrese valor de la componente:");

            sueldos[3]=teclado.nextInt();

            System.out.print("Ingrese valor de la componente:");

            sueldos[4]=teclado.nextInt();

La impresión de las componentes del vector lo hacemos en el otro método:

    public void imprimir() {

        for(int f=0;f<5;f++) {

            System.out.println(sueldos[f]);

        }

    }

Siempre que queremos acceder a una componente del vector debemos indicar entre corchetes la componente, dicho valor comienza a numerarse en cero y continua hasta un número menos del tamaño del vector, en nuestro caso creamos el vector con 5 elementos:

        sueldos=new int[5];

Por último en este programa creamos un objeto en la main y llamamos a lo métodos de cargar e imprimir el vector:

    public static void main(String[] ar) {

        PruebaVector1 pv=new PruebaVector1();

        pv.cargar();

        pv.imprimir();

    }

EJERCICIO 2

1.       Dado el siguiente código  donde captura 2 listas de números luego suma cada lista y las compara y dice cual es la mayor: SE DEBE ORGANIZAR EL EJERCICIO DE MANERA TAL QUE CAPTURE 2 LISTAS DE ARREGLO (Arreglos unidimensionales)  , los cuales los suma y luego

 Hace la comparación de los dos arreglos diciendo cual es el mayor de los arreglos.

CÓDIGO FUENTE 

package manu;

import javax.swing.JOptionPane; 

/**

 *

 * @author Admin

 */

public class Discretas {   

    public static void main(String[] args) {      

            int suma=0, suma1=0;

            String[] vec=JOptionPane.showInputDialog("INGRESE LOS COMPONENTES DE LA LISTA 1 DE LA FORMA\n 1,2,3,4,5,6,7,8,9,,,N").split(",");

            String[] vec1=JOptionPane.showInputDialog("INGRESE LOS COMPONENTES DE LA LISTA 2 DE LA FORMA\n 1,2,3,4,5,6,7,8,9,,,N").split(",");           

            int[] vec2 = new int[vec.length];     

            int[] vec2x = new int[vec1.length];           

            for (int i=0; i<vec.length; i++) {

                vec2[i] = Integer.parseInt(vec[i]);

                suma=vec2[i]+suma;

            }

            for (int i=0; i<vec1.length; i++) {

                vec2x[i] = Integer.parseInt(vec1[i]);

                 suma1=vec2x[i]+suma1;

            }

            System.out.println("lista 1: "+suma+"\n"+ "lista 2: "+suma1);

            if (suma>suma1) {

                System.out.print("LA LISTA 1 ES MAYOR");           

            } else if (suma<suma1){

            System.out.print("LA LISTA 2 ES MAYOR");

            }else{

            System.out.print("LAS LISTAS SON IGUALES");

        }         

      }

    }    

SALIDA

EJERCICIO 3

1.    
Hacer un programa con matrices que muestre únicamente los valores de la diagonal por ejemplo si la matriz es de 3 x 3 solo deberá imprimir. [3 8 3]

CÓDIGO FUENTE

package manu;

import javax.swing.JOptionPane;

/**

 *         

 * @author Admin

 */

public class LeerArreglo{

 public static void main(String arg[])

    {    

    int v[] ={774, 647, 192, 754, 515, 578, 861, 947, 253};   

    int n= (int)Math.sqrt(v.length);

   

    int m[][] = new int[n][n];

    int cont = 0;

    for (int x = 0; x < n; x++)

        {

      for (int y = 0; y < n; y++)

            {

                m[y][x] = v[cont];

                cont++;

            }

        } 

        System.out.println("Matriz:");

    String str = " ";

    for (int i = 0; i < n; i++)

        {

      for (int j = 0; j < n; j++)

            {

                str += m[j][i]+" ";

            }

            System.out.println(str);

            str = " ";

        }

    System.out.print("La diagonal principal es:\n ");

        for (int i=0; i<n; i++)

            for (int j=0; j<n; j++){

                if (i == j){

                    System.out.print(m[i][j]+"\t");

                 } else if(i != j) {

                    System.out.print(" ");

                } 

            }

  }}

SALIDA

EJERCICIO 4

1.       Diseñar un programa que capture N números por teclado  con el JOPTIONE y muestre el vector únicamente con los números impares.

CÓDIGO FUENTE

package manu;

import javax.swing.JOptionPane;

/**

 *

 * @author Admin

 */

public class Discretas {   

    public static void main(String[] args) {      

            String v = JOptionPane.showInputDialog("INGRESE LOS COMPONENTES DEL VECTOR DE LA FORMA\n 1,2,3,4,5,6,7,8,9,,,N");

            String[] vec=v.split(",");

            int[] vec2 = new int[vec.length];

            for (int i=0; i<vec.length; i++) {

                vec2[i] = Integer.parseInt(vec[i]);

            }

            for (int i=0; i<vec.length; i++) {

                if (vec2[i]%2!=0) {

                    System.out.print (vec2[i]);

                }  else{

                    System.out.print(",");

                }

            }     }

    } 

SALIDA

EJERCICIO 5

1.   Diseñar una matriz de [4,5] 4 filas y 5 columnas únicamente con las letras del alfabeto de manera descendente es decir la matriz debe llenarse desde la z hasta la a guardando el tamaño [4,5]

CÓDIGO FUENTE

package manu;

/**

 *

 * @author Admin

 */

public class Discretas {

    public static void main(String[] args) {    

        char[][] matrizAlfabeto=new char[4][5];

        char[] alfabet={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};

        for (int i = 0; i < 4; i++) {

            for (int j = 0; j < 5; j++) {

                matrizAlfabeto[i][j]= alfabet[(int)(Math.random()*26)];

            }

        }       

        for (int i = 0; i < 4; i++) {

            for (int j = 0; j < 5; j++) {

                System.out.print(matrizAlfabeto[i][j]+ " ");              

            }

            System.out.println();

        }

    }   

}

SALIDA

EJERCICIO 6

1.  Llenar un arreglo con la palabra bienvenidos a programación i.

CÓDIGO FUENTE

package manu;

/**

 *

 * @author Admin

 */

public class Discretas {   

    public static void main(String[] args) {      

            

       

char[]alfabet={'B','I','E','N','V','E','N','I','D','O','S',' ','A',' ','P','R','O','G','R','A','M','A','C','I','O','N',' ' ,'I'};

        int a=alfabet.length;

        char[]vector=new char[a];       

            for (int j = 0; j < a; j++) {

                vector[j]= alfabet[j];

            }               

        for (int i = 0; i < a; i++) {           

                System.out.print(vector[i]);          

          

        }

        System.out.println();

    }   

}

SALIDA

EJERCICIO 7

Llenar una matriz donde capture por teclado el tamaño de la misma y esta solo acepte números pares.  Los resultados por teclado.

CÓDIGO FUENTE

package manu;

import javax.swing.JOptionPane;

/**

 *

 * @author Admin

 */

public class Discretas {

    public static void main(String[] args) {      

        int n=Integer.parseInt(JOptionPane.showInputDialog("ingrese las finas de la matriz "));

        int m=Integer.parseInt(JOptionPane.showInputDialog("ingrese las columnas de la matriz "));        

        int mat[][]= new int[n][m];

        int nro;

        for (int i = 0; i < n; i++) {

            for (int j = 0; j < m; j++) {

                 nro=Integer.parseInt(JOptionPane.showInputDialog("ingrese un numero "));

                if (nro%2==0) {

                    mat[i][j]=nro;

                } else {

                    JOptionPane.showInputDialog("ingrese otro numero diferente");

                }

            }           

        }

        for (int i = 0; i < n; i++) {

            for (int j = 0; j < m; j++) {

                System.out.print(mat[i][j]+" ");

            }

            System.out.println();

        } 

           }  

}

SALIDA