Hasta ahora los ejemplos fueron en consola, la idea es empezar con algo básico en Swing (las librerías gráficas de Java) para hacer una ventana con entrada de datos y que realice alguna acción.
Primero vamos a crear el proyecto "EjemploSwingUno":
1- Archivo -> Nuevo Proyecto
2- Java -> Aplicación Java -> Siguiente
3- Nombre del proyecto -> EjemploSwingUno
Con el proyecto creado, agregamos un paquete llamado "Ventanas", por último haciendo click derecho sobre el paquete seleccionamos "New (nuevo)" -> "JFrame (Form)" y lo llamamos "Principal". Como resultado de esto, nuestro proyecto debería quedar así:
A la izquierda se pueden ver los archivos que posee el proyecto y a la derecha se observa el editor gráfico del Netbeans (esta es la magia del IDE), en otras palabras vamos a poder editar en forma gráfica el aspecto de la ventana "Principal". La diferencia entre un JFrame y un Jdialog, es que el frame será la ventana principal de todo programa (solo debe haber uno) y los diálogos serán llamados desde ese frame único, que tomarán al Jframe como argumento a la hora de ser llamados.
Como primera medida vamos hacer que el programa al ejecutarse muestre la ventana, para hacer eso agregamos las siguientes líneas en el main que se encuentra en el archivo "EjemploSwingUno.java", recuerden el programa inicia desde ahí:
PHP:
package ejemploswinguno;
import Ventanas.Principal;
public class EjemploSwingUno {
public static void main(String[] args) {
Principal ventana=new Principal();
ventana.setVisible(true);
}
}
En el main se:
- Importó la clase Principal.
- Creó un objeto de la clase Principal llamado ventana.
- Llamó al método "setVisible" para hacer visible la ventana, con ese método también se puede ocultar una ventana.
Al ejecutar, vamos a ver que se abre una ventana arriba en el margen izquierdo que no tiene contenido.
Ahora vamos a investigar un poco el código de la ventana, para eso vamos a "Principal.java" y presionamos sobre el botón "source" para ver el código, vamos a ver una cosa así:
PHP:
package Ventanas;
public class Principal extends javax.swing.JFrame {
public Principal() {
initComponents();
}
private void initComponents() {
....
}
public static void main(String args[]) {
....
}
}
Nos encontramos con tres métodos:
- main =>
NO SE TOCA (el editor gráfico se encarga de modificarlo).
- initComponents =>
NO SE TOCA (el editor gráfico se encarga de modificarlo a medida que agregamos controles gráficos).
- Principal => es el constructor y por donde inicia nuestra ventana desde el main "EjemploSwingUno.java" cuando creamos el objeto "ventana".
Ya tenemos la ventana, lo primero que vamos hacer es centrarla en pantalla, para hacer eso debemos averiguar la resolución de pantalla que tiene el equipo usando las siguientes líneas:
PHP:
private final int ancho_pantalla = java.awt.Toolkit.getDefaultToolkit().getScreenSize().width;
private final int alto_pantalla = java.awt.Toolkit.getDefaultToolkit().getScreenSize().height;
Que las variables sean del tipo final, sirve para indicar que esas variables no serán modificables. Con la resolución en pantalla, ya podemos centrar la ventana usando un poco de matemáticas en el constructor
confused
:
PHP:
package Ventanas;
public class Principal extends javax.swing.JFrame {
private final int ancho_pantalla = java.awt.Toolkit.getDefaultToolkit().getScreenSize().width;
private final int alto_pantalla = java.awt.Toolkit.getDefaultToolkit().getScreenSize().height;
public Principal() {
initComponents();
this.setLocation((ancho_pantalla-this.getWidth())/2,(alto_pantalla-this.getHeight())/2); // Acomodo la ventana en la mitad de la pantalla
}
private void initComponents() {
....
}
public static void main(String args[]) {
....
}
}
Si vemos el código:
- "this" hace referencia al propio objeto, es decir ventana.
- "setLocation(x, y)" es un método para fijar la posición de la ventana.
- "getWidth()" es un método para obtener el ancho de la ventana.
- "getHeight()" es un método para obtener la altura de la ventana.
Con esto, conseguimos que la ventana inicie en el medio de la pantalla.
Ahora agreguemos un botón que nos permita salir de la ventana (además del uso de la x), para lo cual volvemos a modo de diseño (design) y elegimos el control "button" en la zona de "Palette":
Una vez elegido el botón, lo ubicamos en cualquier lugar de la ventana, por ej. abajo a la derecha. Si hacemos un click izquierdo sobre el botón y a la derecha del IDE nos aparecerán ls propiedades de ese botón (como alternativa se puede presionar botón derecho sobre el botón y elegir propiedades).
De las propiedades del botón vamos a modificar:
- text => Salir (el texto dentro del botón).
- mnemonic => S (sirve para agregar un acceso directo con el teclado, es decir ALT+S).
Luego tenemos otra viñeta que se llama "events" (eventos), que nos servirá para crear uno o varios métodos cuando suceda "algo" con ese botón, por ej. cuando se efectúa una acción sobre el mismo "actionPerformed":
Haciendo click sobre la flecha de abajo, nos agregará "jButton1ActionPerformed" y nos creará un método en la clase "Principal":
PHP:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
Como verán es bastante simple el asunto, ese método si lo vemos con ojos de programado de uC, será un "especie" de rutina de interrupción cuando se produzca alguna acción sobre el botón. Hasta este punto, no tuvimos que agregar muchos conocimientos a nuestro limitado JAVA para trabajar con botones, todo lo hizo el editor gráfico del Netbeans.
Con el método agregado, vamos a cerrar la ventana usando el método "dispose" que sirve para "destruir" (literalmente) el objeto ventana, quedando la clase "Principal" de esta forma:
PHP:
package Ventanas;
public class Principal extends javax.swing.JFrame {
private final int ancho_pantalla = java.awt.Toolkit.getDefaultToolkit().getScreenSize().width;
private final int alto_pantalla = java.awt.Toolkit.getDefaultToolkit().getScreenSize().height;
public Principal() {
initComponents();
this.setLocation((ancho_pantalla-this.getWidth())/2,(alto_pantalla-this.getHeight())/2); // Acomodo la ventana en la mitad de la pantalla
}
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
this.dispose();
}
private void initComponents() {
....
}
public static void main(String args[]) {
....
}
}
En este punto, si se presiona sobre el botón salir, la ventana se cerrará. Para darle un poco más de orden al código a futuro, sería bueno que en vez de llamarse el botón de salir "jButton1", se llame "BotonSalir", para identificarlo más rápidamente. Esta modificación la podemos hacer desde el editor gráfico, en las propiedades del botón veremos la viñeta "Code", en "variable name" podremos modificar su nombre y el IDE automáticamente renombrará la variable en el código (si... automágico
). Ahora el método de "actionPerformed" se verá así:
PHP:
private void BotonSalirActionPerformed(java.awt.event.ActionEvent evt) {
this.dispose();
}
Otra característica importante del botón, se encuentra en el tipo de variables, si privada o pública, lo ideal es que se mantenga privada y si es necesario acceder a ella desde afuera que se lo haga mediante un método como vimos en los mensajes anteriores.
Por último a ese botón, sería bueno agregar una pregunta de si realmente se desea salir o no, esto lo podemos hacer agregando una ventana de diálogos mediante el editor gráfico o más sencillo (y es lo que vamos hacer) usar los cuadros de diálogos por default que tiene java:
PHP:
private void BotonSalirActionPerformed(java.awt.event.ActionEvent evt) {
int confirmado = JOptionPane.showConfirmDialog(this,"¿Confirma que desea salir?");
if(JOptionPane.OK_OPTION == confirmado)
this.dispose();
}
El editor nos pedirá que importemos ciertas librerías (javax.swing.JOptionPane). Si vemos el código, simplemente tenemos que pasar por argumento el Frame principal ("this") y el mensaje que aparecerá en el cuadro, como resultado devolverá un "int" según nuestro accionar, si ese "int" es igual a "JOptionPane.OK_OPTION", significa que presionamos sobre el botón "Si". Si ejecutamos, veremos el siguiente cuadro de diálogos al presionar sobre el botón Salir:
Bueno, hasta acá se consiguió algo bien básico:
- Crear un Frame y centrarlo.
- Agregar un botón de salida.
- Agregar eventos sobre el botón de salida.
- Agregar un cuadro de diálogo que confirme la salida.
En el próximo mensaje veremos como ingresar datos en la ventana.
