JOptionPane - Cuadros de Diálogos

Un cuadro de diálogo no es más que una ventana que nos permite mostrar mensajes, por ejemplo de error, de advertencia o de información, o para pedir el ingreso de un valor, además nos permite solicitar al usuario su intervención para decidir si se realizará o no una acción, como ser los mensajes de confirmación.

JOptionPane es una clase de la biblioteca Swing (que contiene las librerías de interfaz gráfica de usuario), para poder usar sus métodos es necesario importarla: import javax.swing.JOptionPane;

Podemos mencionar que JOptionPane tiene básicamente 4 métodos, que definen la manera y la funcionalidad con la que se mostrará un cuadro de diálogo:

showMessageDialog(): muestra un cuadro de diálogo al usuario, normalmente de carácter informativo, como mínimo recibe 2 parámetros: el componente padre (que puede ser null) y una cadena de caracteres que corresponde al mensaje a ser mostrado. También puede recibir como parámetro una cadena que irá como título del cuadro y el tipo de mensaje a mostrarse (determinado por una constante de la clase JOptionPane).

Parámetros:
                * Component componentePadre: el componente al que pertenece.
                * Object mensaje = es el objeto que corresponde al mensaje (texto) a mostrarse.
                * String titulo = texto que será el título del cuadro de diálogo.
                * int tipoDeMensaje = definido por una constante de la clase JOptionPane  
Sintaxis:
  JOptionPane.showMessageDialog(this, "Este es un mensaje simple");

Aquí se le envía como componente padre el objecto actual; es interesante esta práctica ya que de esta manera el formulario se bloqueará mientras esté abierto el cuadro de mensaje, impidiendo que se efectúen otras acciones, en cambio si se le pasa null en vez de un objeto el formulario (padre) al que pertenece estará disponible para otras acciones (lo que estaría incorrecto).

Resultado:

Sintaxis:
JOptionPane.showMessageDialog(this, "Este es un mensaje detallado", "éxito!", JOptionPane.INFORMATION_MESSAGE);
Como se puede ver, lo diferente está en que se le pasan dos argumentos más a parte del componente padre y del mensaje a mostrarse, el tercer parámetro es lo que se situará como título del cuadro de diálogo y el último parámetro es la constante que define el tipo de mensaje a ser mostrado.
Resultado:

Constantes de JOptionPane: los mensajes pueden ser de tipo  informativo (INFORMATION_MESSAGE), de error  (ERROR_MESSAGE), de advertencia (WARNING_MESSAGE), mensaje plano (PLAIN_MESSAGE) o mensaje interrogativo (QUESTION_MESSAGE) aunque el uso de este último tipo de mensaje no tiene mucho sentido para este caso.
Ejemplos

showOptionDialog(): podríamos decir que gracias a este método podemos obtener un cuadro de diálogo ajustado a nuestra necesidad, ya que es totalmente configurable.

Parámetros:

           * componentePadre = el objeto que indica de qué componente es hijo.
           * objetoMensaje = un String que corresponde al texto a mostrarse como mensaje.
           * Titulo = String que se establecerá como titulo de la ventana.
           * TipoDeOpcion = es un entero, representado por unas constantes que definen qué opciones tendrá el cuadro de diálogo. Puede ser: DEFAULT_OPTION, YES_NO_OPTION, YES_NO_CANCEL_OPTION, YES_CANCEL_OPTION.
        * TipoDeMensaje: entero que determina el tipo de mensaje (ERROR_MESSAGE, por ejemplo).
          * Icono = la imagen que acompañará al mensaje, si no se especifica (es decir, se pasa null) se establecerá uno por defecto de acuerdo al tipoDeMensaje.
           * Opciones = un array tipo Object que indica las opciones posibles, normalmente debe ser coherente con el tipoDeOpcion elejido.
            * ValorInicial = es la opción predeterminada, deberá ser una de las opciones introducidas en el array de opciones. Puede ser null.
Ejemplo:
   - Sintaxis:

int seleccion = JOptionPane.showOptionDialog(btn_Option, "Este es un cuadro de dialogo Option", "showOptionDialog", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[] {"Si", "No","Cancelar"}, "Si");

Retorna un entero que corresponde a la opción seleccionada por el usuario, como sabrán, el valor del entero corresponde a la posición que ocupa la opción en el array es decir si se selecciona "No" devolverá 1 (uno) , ya que la primera posición de un array es 0 (cero).

   - Resultado:

showInputDialog(): sirve para mostrar una ventana que permita ingresar datos (una cadena, texto, números, etc.). Los parámetros que puede recibir son los mismos que los del MessagaDialog. 
Ejemplo:
   - Sintaxis:
String texto = JOptionPane.showInputDialog (this, "Ingrese un texto: ", "showInputDialog",JOptionPane.INFORMATION_MESSAGE);
  - Resultado:     

Nota: Cuando lo que se va a ingresar es un número, se debe realizar una conversión para poder utilizarlo como tal. Por ejemplo: int numero = Integer.parseInt(JOptionPane.showInputDialog (this, "Ingrese un número: ", "showInputDialog",JOptionPane.INFORMATION_MESSAGE)); Pero ésto debemos controlar que se escriban sólo número para que no arroje errores en la conversión, podríamos solucionar tan sólo encerrándolo en un try-catch

showCofirmDialog(): método que nos sirve para solicitar al usuario la confirmación de una determinada acción. Puede establecerse los distintos parámetros antes mencionados, como por ejemplo el componente padre, mensaje, titulo y tipo de mensaje. Para el tipo de mensaje las constantes posibles son: YES_NO_OPTION, YES_NO_CANCEL_OPCION, YES_OPTION, NO_OPTION, CANCEL_OPTION
Ejemplo:
   - Sintaxis:
int opcion = JOptionPane.showConfirmDialog(this, "Desea seguir ejecutando la aplicación?", "Seleccione una opción", JOptionPane.YES_NO_OPTION);
  - Resultado:

Retorna un entero que corresponde a la opción seleccionada por el usuario.

Hasta aquí, se puede hacer uso de todas las funcionalidades que nos facilita la clase JOptionPane, además de darle un toque más elegante a nuestro programa.

        

Tipos de Clases y Objetos en Java

Una clase, bien se había dicho, no es más que la definición (o estructuración) de un objeto o de un conjunto de objetos con las mismas características y funcionalidades comunes.
Tipos de Clases:
- Clases públicas (public): una clase declarada como pública (public) es accesible  desde cualquier otra clase del mismo paquete, también se puede acceder desde otra clase que pertenezca a otro paquete importando la clase [import.NombreDelPaquete.NombreDeClase;]. Pueden ser heredadas.
Sintaxis: public class cuentaBancaria
                  { 
                           long numero;
                           String titular;
                           long saldo;
                           
                           void  ingresar (long cantidad)
                           {
                                   saldo += cantidad;
                           }

                           void retirar (long cantidad)
                           {
                                    if (saldo < cantidad)
                                               System.out.println ("Saldo insuficiente!");
                                    else 
                                             saldo - = cantidad;
                            }
                  }

- Clases Abstractas (abstract): son clases que sirven de base para la herencia. Particularidades: no pueden ser instanciadas, es decir no se pueden crear objetos a partir de ellas. Además, pueden contener métodos con o sin implementación y no pueden definirse como final. También los métodos son definidos como abstractos.

Generalmente una clase abstracta es del tipo public a la vez.

Cuando una clase hereda de una clase abstracta, la primera está obligada a definir o implementar todos los métodos definidos en la clase base. Si algún método está implementado en la clase base, al derivar éste puede ser sobre-escrito (a conveniencia) en la clase que lo hereda.

Si en una clase contiene un método abstracto, dicha clase debe declararse también como abstracta. 

Una clase declarada como abstracta no puede contener métodos privados, ya que si se hereda la clase no sería posible la implementación de los métodos privados.

Sintaxis:

     public abstract class Personas

     {

                 public abstract void registrarDatos (int dni, String nombre, String apellido);

     }

     public class Alumnos extends Pesonas

    {

               public void registrarDatos (int dni, String nombre, String apellido)

               {

                    .............

               }

     }

Si una clase definida como public hereda de una clase abstracta, y que ambos estén definidos en un mismo documento o archivo, el nombre de dicho archivo debe ser igual al de la sub-clase publica.

- Clases Finales (final): son clases que no se pueden heredar. El motivo principal por el que una clase se declara como final obedece a la seguridad, ya que no permite que se modifique las definiciones creadas. También la declaración de las clases como final otorga una mayor eficiencia, puesto que como no son heredables se trabaja sólo con las instancias de la propia clase. Una gran cantidad de de las librerías de java están declaradas como final.

- Clases Sincronizables (Synchronizable): se usan a fin de poder (como su nombre indica) sincronizar los procesos que una clase o clases esté(n) realizando. Bien se sabe que una computadora puede realizar varios procesos o trabajos a la vez, ésto es posible gracias a los hilos (o Threads). Un thread no es más que un flujo que permite controlar la ejecución de un determinado proceso. Esto le da solidez y seguridad a un programa, ya que a un elemento determinado no se puede acceder al mismo tiempo desde distintos threads.

Cuando una clase se declara como synchronizable, se indica que todos sus métodos serán o estarán sincronizados.

Objetos.

* Crear un objeto significa reservar espacio en memoria para sus variables, para el fin se utiliza la palabra clave new, a la acción de crear un objeto se denomina instanciar un objeto, o dicho de otra manera un objeto es una instancia de la clase. Ejemplo:

      Persona p =  new Persona();

Mediante la nueva instancia del objeto se puede acceder a las variables y a los métodos que se encuentran definidos en la clase.

Ejemplos:

p.nombre = "XXXxxx Xxx";

p.verDatos();      

En el primer caso se modifica el valor de la variable "nombre" por el valor especificado entre comillas. En el segundo, se llama al método "verDatos()".

Primera Aplicación Java

En esta oportunidad, haremos una primera aplicación en java, que consistirá en escribir un nombre y mostrar un mensaje de bienvenida con ese nombre.

Como es súper sencillo, iré citando los pasos, pero también dando una breve explicación de las librería que vamos a utilizar.

Haremos de dos maneras: 
1.) Con Scanner, una librería para manejar entradas/salidas, tipo por consola.
2.) Utilizando java Swing, la interfaz gráfica de java.

Para comenzar entonces creamos un nuevo proyecto: Archivo > Proyecto Nuevo > Java > Aplicación Java, lo ponen un nombre y Terminar.

Importante: Cuando estamos creando un nuevo proyecto, al final están dos casillas ( Crear clase principal y Configurar como proyecto principal )  que normalmente aparecen seleccionadas, yo aconsejo que se desmarque la casilla Crear clase principal, esto es para que no nos agregue la clase por default, de lo contrario nos la creará.

Agregamos un nuevo paquete (o carpeta) dentro del paquete predeterminado. Clic derecho en Paquetes de fuentes. Lo nombran como deseen.

Una vez creado el paquete, le damos click derecho > Nuevo > Clase Java. Nos saldrá una ventana como la siguiente imagen, le indicamos un nombre, Terminar.

Nos crea y abre la clase "practica1", en el código fuente por lo general, aparecen las siguientes líneas:
                package practicas;

                public class practica1
                {

                }

El "package practicas" indica que pertenece al paquete "practicas". En su caso sería el nombre que lo han puesto al paquete cuando lo crearon. Y luego ya viene la definición de la clase, con el modificador public seguido de la palabra clave class.

Como mencioné al inicio utilizaremos un objeto tipo Scanner, que nos permitirá leer lo que se llegue a escribir en el teclado. Definimos el objeto dentro de nuestra clase:

              Scanner sc = new Scanner (System.in);
El System.in indica que se registrará una entrada por teclado.

y debajo de "package practicas" escribimos:
              import java.util.Scanner;
esto es para agregar o importar (que es el término que iremos usando) la librería Scanner.
Hasta ahora el código queda así:
              package practicas;
              import java.util.Scanner;

              public class practica1
              {
                         Scanner sc = new Scanner (System.in);
              }
A nuestra clase agregaremos dos métodos, una para utilizar el Scanner y el otro para el JSwing. A seguir, los métodos:

En este método hacemos uso del objecto sc. Mostramos un mensaje pidiendo que se escriba un nombre mediante el System.out.println y guardamos lo que se escriba en la variable nombre lo que se capture con el sc.next(). Por ahora basta saber que el next() se utiliza para capturar cadenas (o caracteres). Luego Mostramos un mensaje de bienvenida acompañado del nombre que se ha escrito antes.

            public void msgScanner ()
            {
                    System.out.println ("Escriba su nombre: ");
                    String nombre = sc.next();
                    System.out.println ("Bienvenido al mundo de Java... "+nombre+"!!");
            }

En este otro método haremos exactamente igual a lo que hicimos en el anterior, la diferencia va a estar en la interfaz o presentación que le daremos. 
Primero importamos el paquete swing: import javax.swing.JOptionPane;
Después confeccionamos el método correspondiente:
          public void msgSwing ()
          {
                 String nombre = JOptionPane.showInputDialog (null, "Escriba su nombre: ");
                 JOptionPane.showMessageDialog (null, "Bienvenido al mundo de java... "+ 
                          nombre+"!!");
          }

Aquí lo que hacemos es guardar en la variable nombre  lo que se capture con el método showInputDialog de JOptionPane (Input es para la entrada de datos). Como se puede ver, este método recibe como mínimo dos argumentos o parámetros: el primero es un componente padre, de acuerdo a este componente establecerá su posición en la pantalla del escritorio, si no se le envía nada, es decir si es escribe null se posicionará en el centro respecto al escritorio; el segundo argumento es el mensaje que aparecerá en el cuadro.

Por último, mostramos el mensaje y el nombre ingresado con el showMessageDialog que tiene la misma estructura que el showInputDialog.

Una vez terminado los métodos, agregamos a nuestra clase el método main, que es el punto de partida de todo programa. Su estructura es como sigue:

    public static void main (String args[])
    {
        practica1 pract = new practica1();
        pract.msgScanner();
        pract.msgSwing();
    }

dentro del método instanciamos (creamos) un objeto de nuestra clase, en mi caso el objeto es pract, mediante este objeto podremos acceder a los dos métodos creados anteriormente. 
Todo el código quedaría de esta manera:

package practicas;

import java.util.Scanner;

import javax.swing.JOptionPane;

/**

 *

 * @author Rodney

 */

public class practica1 {

    Scanner sc = new Scanner (System.in);

    

    public void msgScanner ()

    {

        System.out.println ("Escriba su nombre: ");

        String nombre = sc.next();

        System.out.println ("Bienvenido al mundo de Java... "+nombre+"!!");

    }

    

    public void msgSwing ()

    {

        String nombre = JOptionPane.showInputDialog(null, "Ecriba su nombre: ");

        JOptionPane.showMessageDialog(null, "Bienvenido al mundo de Java... "+ 

            nombre+"!!");

    }

    

    public static void main (String args[])

    {

        practica1 pract = new practica1();

        pract.msgScanner();

        pract.msgSwing();

    }

}

*****************************************************************************************

Puesto en ejecución....

Escribimos un nombre... le damos entrar y nos muestra el mensaje....

Luego aparece el cuadro de mensaje de JOptionPane que nos pide que escribamos un nombre... lo hacemos y le damos click en Aceptar...

Seguido nos muestra el mensaje de bienvenida... con nuestro nombre...

Éxito!!

Modificadores de Visibilidad

Paquetes.

Antes de impartir los conceptos que en realidad son interés de esta nota, vale la pena mencionar unos pre-conceptos. Por ejemplo, los paquetes. ¿Qué son? Podríamos hacer una  sutil analogía con lo que son las carpetas.  Los paquetes permiten establecer un nombre único para las clases y ayudan a la organización de dichas clases.

Palabras claves: import  java.util.*; y package py.com.miPaquete.miClase;
Cada vez que creamos un paquete, lo que sucede por detrás es generarse una estructura de directorios, correspondientes al paquete. 
Ejemplo: 
             Paquete: py.com.miPaquete
             Directorio: py/com/miPaquete

Modificadores de Visibilidad

En lo que concierne a los modificadores de visibilidad o de acceso, el objetivo principal el lograr el encapsulamiento, controlando  o prohibiendo el acceso a los atributos o elementos de una clase.

Pueden usarse para establecer la visibilidad de: clases, métodos y variables.

En java podemos mencionar 4 tipos de modificadores, éstos, como su nombre lo indica, "modifican" o determinan la "visibilidad" o el acceso a un cierto elemento, son:

   1.) public: visible dentro y fuera del paquete. Los métodos y las variables, son heredados por todas las subclases o hijas de la clase. Accesibles desde cualquier lugar.

Ejemplo:

                   public class persona 

                   {

                            public int dni;

                            public void registrar ()

                            {

                                  .........

                            }

                   }

    2.) private: visible sólo desde el interior de la clase. No son heredados por ninguna sub-clase. No son accesibles desde ninguna otra clases, por más que estén en el mismo paquete.

                   public class persona 
                   {
                            private int dni;
                            privete void registrar ()
                            {
                                  .........
                            }
                   }

    3.) protected: visible desde el interior de la clase y desde las clases heredadas (sub-clases o hijas). 

                   public class persona 
                   {
                            protected int dni;
                            protected void registrar ()
                            {
                                  .........
                            }
                   }
   4.) friendly o default: (sin palabra clave) visible desde cualquier clase en el mismo paquete. 

                   public class persona 
                   {
                            int dni;
                            void registrar ()
                            {
                                  .........
                            }
                   }


Todos estos modificadores se pueden combinar a gusto y necesidad, dependiendo de lo que desea lograr.  Ejemplo:


     public class personas
     {
           public String nombre;
           public String apellido;
           private int dni;
           
           private void registrar ()
           {
                 ...............
           }

           public void verDatos ()
           {
                   ................
           }
     }

Tipos de Datos (o Tipos Primitivos de Variables)

Partamos del concepto anterior referente al atributo de una clase, que corresponde a una característica en particular de dicho objeto. La manera de poder almacenar un atributos es mediante una variable.
Una variable es un "nombre" que contiene un valor que puede cambiar a lo largo de la ejecución de un programa.
En java existen básicamente dos tipos de variables:
1. ) Variables de Tipos Primitivos: son las que se definen mediante un único valor. Por ejemplo: un entero, punto flotante, carácter, boleano, etc., y distintos rangos de valores (char, byte, short, int, long, float, double, boolean).
2. ) Variables de Tipo Referencia:  No almacenan los datos, propiamente dicho, sino una referencia o dirección de memoria en donde se encuentra almacenado el dato.


Podemos distinguir dos niveles o alcance de las variables:
 - Variables a nivel clase o miembro de una clase: se definen al comienzo de la definición de la clase, pueden ser de tipo primitivos o de referencias.
 - Variables locales: se definen dentro de un método o dentro de cualquier bloque entre llaves { }. Se destruyen al finalizar la ejecución del método o bloque. Pueden ser tipo primitivos o de referencias.


A continuación se nuestra un cuadro que contiene los tipos Primitivos y su descripción o rango de valores:

Tipo de Variable	Descripción
Boolean	1 byte. Valores true o false
Char	2 bytes. Unicode. Comprende el código ASCII
Byte	1 byte. Valor entero entre -128 y 127
Short	2 bytes. Valor entero entre -32768 y 32767
Int	4 bytes. Valor entero entre -2.147.483.648 y 2.147.483.647
Long	4 bytes. Valor entero entre -2.147.483.648 y 2.147.483.647
Float	4 bytes (entre 6 y 7 cifras decimales equivalentes). De -3.402823E38 a -1.401298E-45 y de 1.401298E-45 a 3.402823E38
Double	8 bytes (unas 15 cifras decimales equivalentes). De -1.79769313486232E308 a -4.94065645841247E-324 y de 4.94065645841247E-324 a 1.79769313486232E308

Declaración e Inicialización de las variables
Una variable se define especificando el tipo de dato y el nombre de dicha variable. Estas variables pueden ser tanto de tipos primitivos como referencias.
Ejemplos (la doble barra se usa para agregar comentarios):


public class persona
{
        String nombre; // variable de clase, tipo cadena, por defecto se inicializa a null (nulo)
        int edad=10; // variable de clase, tipo entero (números enteros), valor inicial=10
   
       public void pers () // esto es un método, que retorna vacio (o nada)
       {
              boolean registrado; //variable local, tipo boolean, se inicializa en false...
       }
}

JAVA - Conceptos - Características

Java es un lenguaje de programación, que fue desarrollado por un equipo de ingenieros de Sun. Su uso se destaca principalmente en el entorno web, aunque también se utiliza para crear todo tipo de aplicaciones.
Características:
- Robusto.
- Gestiona la Memoria Automáticamente.
- Multi-Threading.
- Cliente-Servidor.
- Mecanismos de Seguridad Incorporados.
- Herramientas de Documentación Incorporados.
POO (Programación Orientada a Objetos).
A diferencia de otros lenguajes de programación , Java puede considerarse como un lenguaje "de" objetos, porque ha sido creado para trabajar con objetos desde cero. Todo lo que hay o existe en Java son objetos.
Un objeto, haciendo una analogía con lo cotidiano, es un objeto, "una cosa" que puede ser una silla, una mesa, una casa, un auto... etc. Todos y cada uno de estos objetos tienen características o atributos propios, además de las acciones que podemos realizar sobre cada objeto, es decir, una silla usamos para sentarnos, un auto para nuestra movilidad... En programación, un objeto viene a ser una pieza de software, que debe cumplir unas características, consideradas como fundamentos de la POO, que son: el encapsulamiento, la herencia y el polimorfismo (Las definiciones de éstas características veremos más adelante).
     - Ventajas de la POO
 - * Desarrollo más rápido.
 - * Modularidad.
 - * Reutilización de Software.
 - * Extensibilidad
 > Clases: una clase puede definirse como la estructura de un objeto. Un objeto se crea o se instancia a partir de la definición de la clase, es decir es el resultado de una clase. Todos los objetos que se instancien a partir de una clase tienen el mismo comportamiento y las mismas características.
Podemos dividir a la clase en dos partes:
1. Los Atributos o Campos: definen o contienen las propiedades del objeto. Por ejemplo, de un objeto "persona" un atributo sería su nombre.
2. Los Métodos: definen el comportamiento del objeto. Son funciones que están asociadas al objeto.
Definición de una Clase:
Sintaxis:
            public class nombre_clase
            {
                       String un_atributo;
                     
                       public void un_metodo()
                      {
                               ...........
                       }
            }
Una clase se define indicando el modificador de visibilidad (más adelante explicaré más), en este caso se usa el public que indica que la clase puede ser usada por cualquier clase en cualquier paquete, seguida de la palabra clave class, que significa que lo que se está definiendo es una clase. Dentro de las dos llaves van todos los atributos y métodos de la clase.
Un atributo se define especificando el tipo de dato que va a contener, aquí decimos que será del tipo String (los tipos de datos estudiaremos más adelante) seguido del nombre del atributo, por último el punto y coma. Es importante, a la hora de definir un atributo, darle un nombre que guarde relación con el dato que va a almacenar, Por ejemplo, si la clase fuera "persona" un primer atributo sería su nombre, es decir "String nombre;".
Un método se define escribiendo el modificador de visibilidad= public, que indica que el método podrá ser llamado desde otras clases, seguido del tipo de retorno (que puede ser cualquier tipo de dato), en este caso, el void indica que el método devolverá "vacío" (o, no retornará nada), luego los paréntesis para indicar que es un método lo que se está construyendo. Dentro de los paréntesis pueden incluirse algunos atributos o argumentos que un método puede necesitar para desarrollar su función, aunque puede no especificarse!! como aquí.! Las dos llaves indican el comienzo y final, respectivamente, del método. Toda acción o función que deba desarrollar el método se escribe dentro de las dos llaves.