Beruflich Dokumente
Kultur Dokumente
método mas idóneo para muchos novatos y estudiantes de java para aprender a crear las
ventanas, por que permite que se conozcas mas profundamente como funciona la librería
swing y que opciones tenemos a mano, sin tener que recurrir a la ayuda del wizard. En mi
opinión es mas limpio y fácil de documentar que usar el diseñador del IDE que estemos
utilizando, ya sea NetBeans o Eclipse los mas utilizados por programadores de Java.
Vamos a ponernos a escribir código desde el principio, empezando por crear el proyecto.
Si ya sabes crear un proyecto, simplemente sigue adelante con el tutorial. Si no, pulsa sobr
el este link para ir al tutorial de creación de proyectos en NetBeans.
Una vez creado el proyecto, vamos a dar el siguiente paso que es crear los paquetes y las
clases que necesitemos, y luego escribir el código que se requiera en la clase inicio que
será nuestra clase principal y desde la cual correremos el programa.
En este tutorial crearemos dos ventanas. Una será un menú, y otra será un formulario.
Creamos un paquete en el cual se guardaran todas las ventanas a crear, para ello nos
colocamos dentro de nuestro proyecto sobre el icono Source Packages y pulsamos el
botón derecho del ratón.
Esto abrirá una menú contextual y en el cual nos colocaremos con el ratón sobre la
opción New, lo cual hará que se muestra un nuevo menú contextual donde pulsaremos
sobr ela opción Java Package...
Lo primero que podemos notar son esos puntos amarillos con un punto mas pequeño rojo
a la izquierda de las lineas. Esto señala que tenemos un error de escritura o que falta
algún elemento o librería.
Nos colocamos encima del primer punto, y hacemos click sobre él. Inmediatamente nos
sale una ventana de ayuda, con diferentes opciones para subsanar el error, explicaciones
del posible motivo que los genera, o sugerencias para corregirlo. Veamos la imagen para
entenderlo.
Como vemos la ventana de ayuda nos dice que podemos añadir la librería
javax.swing.JFrame o crear una clase JFrame. Evidentemente lo que vamos hacer es
importar la librería. Así que si hacemos click sobre la opción resaltada, NetBeans nos
añade automáticamente la librería como vemos en la imagen:
Los puntos restantes son causados por la misma razón, es decir, que debemos añadir las
librerías. Pero cuidado!, algunas veces se nos presentan otras librerías relacionadas, pero
que tienen un efecto distinto al deseado. En este caso el paquete javax.swing es el
correcto, y ademas los otros errores son generados por paquetes que están contenidos en
el mismo, es decir forman parte del paquete, con lo que se colocamos un asterisco, o
sea, javax.swign.*, resolvemos todos. Vamos a verlo en la imagen:
Todos los puntos de error desaparecen. Yo prefiero añadir cada librería individualmente. A
continuación vamos a escribir el constructor por defecto, la definición de la ventana, y la
definición del metodo componentes, que estará vació y que luego desarrollaremos.
Con lo anterior ya tenemos la ventana contenedora del menú que vamos a definir. Ahora
vamos a probarlo, vamos a escribir lo siguiente new Menu(); en la clase inicio, que es la
principal y desde donde vamos a correr la aplicación. Lo colocamos dentro del
método main. Asi que ahora vamos a editar inicio que esta en la pestaña que tenemos al
lado izquierdo en la imagen, identificada como inicio.java
Vemos que nos sale un error y su pulsamos sobre el punto y veremos que es que
debemos importar, la clase Menu que esta dentro del paquete ventanas. pero OJO, aquí
sale una opción adicional y es lo que decía yo antes cuando escribí cuidado!. Veamos la
imagen:
Nosotros hemos escrito nuestra propia clase Menu, que es la que hemos definido antes,
porque si escogemos cualquiera de las otras opciones que tiene una clase Menu, lo más
seguro es que los resultados no sean los deseados. Por lo tanto aqui escogemos nuestra
clase que es la primera opción. Fijate que esta también en el paquete que hemos creado
llamado ventanas. Escogemos entonces la opción Add import for ventanas.Menu.
Si ahora probamos el código escrito por nosotros que sucederá?
Vamos averiguarlo colocando nuestro ratón dentro de cualquier sitio dentro del código de
la clase inicio y pulsamos el botón derecho del ratón. Se nos abre el submenú contextual y
escogemos la opción Run File pulsando sobre ella.
Con esto corremos nuestra aplicación y debemos obtener un resultado igual o similar al
siguiente:
Como podemos ver parece ser que la ventana es un poco larga, para ser un menú normal.
Puede que necesitemos menos. Para ajustar nuestras medidas de la ventana,
simplemente accedemos de nuevo la clase Menu, y modificamos el setSize(x,y); donde "x"
es el ancho e "y" el alto. Vamos hacerlo como práctica si lo deseas, sino continua mas
adelante después de esta parte. Dentro de la clase Menu, vamos a setSize(400,600) y lo
cambiamos a setSize(400,450). Con esto veremos el nuevo aspecto. Volvemos a la clase
menú y volvemos a correr la aplicación. Abajo podemos ver ahora la diferencia.
Podemos apreciar que ahora nuestra ventana Menu es mas corta. Otra cosa que deben
apreciar los estudiantes noveles es que NetBeans nos indica cuando el programa esta
corriendo, y lo hace en la parte de abajo indicando que proyecto esta corriendo. Si ahora
volvemos a correr el programa desde la clase inicio, se ejecutaría otra instancia, con lo que
tendríamos dos ventanas Menu abiertas.
Ahora continuemos construyendo nuestro menú a nuestro gusto. Para ello volvemos a la
clase Menu y vamos a incluir los componentes necesarios para crear la opciones del menú
en forma de botones (button). Igualmente pondremos una etiqueta (label), que la usaremos
como un subtitulo.
Vamos hacer unos cambios al principio de la clase Menu, vamos a cambiar los JLabel,
eliminar los JTextFiled y cambiar los JButton. Debido a que vamos a destinar esta ventana
a un menú, lo que necesitamos básicamente son botones.
Solo se escribieron para enseñar los errores generados por la falta de librerías y la forma
de como solucionarlos.
Ahora vamos a la clase inicio, boton derecho y Run File, para volver a correr nuestro
programa. El siguiente debe ser el resultado o similar.
Como vemos ya tenemos armado algo del menú, pero falta la funcionalidad. Pero es que
antes de ponernos a escribir los demás botones de opciones que falta, es preferible
completar el funcionamiento, para un botón y luego de que este funcione, simplemente
copiar, pegar y sustituir nombre y textos.
Para añadirle funcionalidad al menú falta que el programa haga algo cuando pulsamos
sobre los botones Registro y Salir. Lo conseguimos añadiendo la librería ActionListener.
Vamos a ver el codigo, empezamos por implementar la interface ActionListener en
nuestra clase Menu:
Vemos el punto rojo que nos marca que hay error o falta algo, pulsamos sobre el para ver
que es lo que necesitamos, y veremos en primera instancia que es importar la libreria.
Pulsamos para que la importe y obtenemos lo siguiente:
Pulsamos y Add import para que NetBeans importe la librería escribiendo el código por
nosotros y vemos ahora que aunque ya ha importado la librería, nos sigue marcando un
error.
Como vemos NetBeans nos indica que hay que implementar los métodos abstractos de la
interface que se acaba de importar. Pulsamos sobre Implement all abstract methods y
NetBeans nos escribirá automáticamente los métodos, pero OJO, los mismos no estarán
definidos y veremos como hacerlo luego, por ahora vamos a dejar que NetBeans los cree
por nosotros.
Ya el código a tomado un tamaño que hace imposible, que podamos tomar desde la
pantalla una captura de la imagen y que contenga los cambios. Por ello vamos a copiar y
pegar el código a continuación.
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public Menu(){
componentes();
// Al cerrar la ventana
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// se detiene prog
setSize(400,450); // Tamaño de la Ventana Ancho y Largo
setLocationRelativeTo(null); // Centra la ventana en el monitor
setLayout(null); // elimina toda plantilla.
setResizable(false); // evita se pueda modificar el tamaño de ventana
setVisible(true); // hace visible la ventana
setTitle(" ** Menú Principal **"); // Le pone un titulo a la ventana
labelSubtitulo=new JLabel();
labelSubtitulo.setBounds(110, 25, 180, 20);
labelSubtitulo.setText("Seleccione una opción");
add(labelSubtitulo);
btnRegistro=new JButton();
btnRegistro.setBounds(120, 50, 150, 20);
btnRegistro.setText("Registrar");
add(btnRegistro);
btnRegistro.addActionListener(this);
btnSalir=new JButton();
btnSalir.setBounds(120,400, 150, 20);
btnSalir.setText("Salir");
add(btnSalir);
@Override
public void actionPerformed(ActionEvent e) {
throw new UnsupportedOperationException("Not supported yet."); //To change
body of generated methods, choose Tools | Templates.
}
Esta última parte es la que ha añadido el NetBeans por nosotros y también añadió la
librería java.awt.event.ActionEvent;
No hemos puesto ningún ActionListener en el botón Salir, para dejar que Uds. completen
esos detalles que simplemente es fijarse como está en los demás.
Ahora vamos a definir que debe hacer el programa según sea el botón que pulsemos en el
menú. Vamos a fijar nuestra atención en la ultima parte de la clase Menu y vamos a
modificarla de la siguiente forma.
if(e.getSource().equals(btnRegistro)){
Si algo no ha ido como se esperaba y tiene un resultado negativo, es hora de volver atrás
y repasar todo.
Yo soy de los que piensa, que mientras mas simplificado trabajemos, mas rápido y limpio
escribiremos el código para obtener lo que se desea al final. Para ello les sugiero que
hagamos los siguientes cambios en la clase Inicio, eliminemos los comentarios y vamos a
comentar la sentencia // new Menu(); y agregamos la siguiente sentencia new
Registro(); con esto podemos ir probando la programación que vayamos escribiendo
mientras definimos en nueva ventana. Una vez que nuestra nueva ventana tenga el
aspecto que deseamos, pondremos los controles necesarios y restituimos este cambio
anterior que hemos realizado.
Ahora vamos a escribir el código para la nueva pantalla que será algo parecido a los
siguiente:
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public Registro(){
componentes();
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
setSize(400,450); // Tamaño de la Ventana Ancho y Largo
setLocationRelativeTo(null); // Centra la ventana en el monitor
setLayout(null); // elimina toda plantilla.
setResizable(false); // evita modificar el tamaño de ventana
setVisible(true); // hace visible la ventana
setTitle(" ** Módulo de Registros **"); // Pone titulo a la ventana
@Override
public void actionPerformed(ActionEvent e) {
if(e.getSource().equals(btnGuardar)){
System.out.println("Lanzamos una rutina para grabar los datos");
}
}
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
Vamos a correr ahora el programa y ver como va quedando. Recuerda que hemos hecho
un cambio en Inicio para que solo muestre la ventana Registro
Vemos en la imagen que todo ha ido bien. Si pulsamos sobre Guardar varias veces,
simplemente se repetirá el mensaje "Lanzamos una rutina para grabar los datos". El botón
cancelar no funciona porque no le hemos asignado ninguna acción. En este punto nos
encontramos que que no podemos ni salir ni cerrar la ventana, así que para solucionar
este problema y terminar con el programa debemos pulsar en la parte inferior de NetBeans
en la "x" que está al lado derecho del indicador del programa que se está corriendo, como
se ve en la imagen inferior.
Ahora vamos añadir algunas cosas al código anterior de la clase Registro, a la
clase Menu y modificar nuevamente la clase Inicio. Vamos a empezar con la
clase Menuya que estamos con ese código.
En la clase Registro iremos hasta está sección que vemos abajo en la imagen que es el
método que se añade al implementar ActionListener y que captura las acciones de pulsar
con el ratón el botón Guardar en este caso, para añadir dos sentencias: this.dispose(); y
luego new Menu();
Continuamos con la clase Menu, e igualmente vamos a dirigirnos a este mismo método y
vamos a eliminar dos lineas y añadir dos lineas que serán this.dispose() y new
Registro().
Recuerda que las dos clase tiene el mismo método definido en cada caso según su
funcionalidad con respecto al botón pulsado.
/* Clase Inicio */
import ventanas.*;
new Menu();
}
}
/*Clase Menu*/
/** @author José Miguel Guimerá Padrón. */
package ventanas;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public Menu(){
componentes();
// Al cerrar la ventana
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// se detiene el programa
setSize(400,450); // Tamaño de la Ventana Ancho y Largo
setLocationRelativeTo(null); // Centra la ventana en el monitor
setLayout(null); // elimina toda plantilla.
setResizable(false); // eviata que se pueda modificar el tamaño de ventana
setVisible(true); // hace visible la ventana
setTitle(" ** Menú Principal **"); // Le pone un titulo a la ventana
labelSubtitulo=new JLabel();
labelSubtitulo.setBounds(110, 25, 180, 20);
labelSubtitulo.setText("Seleccione una opción");
add(labelSubtitulo);
btnRegistro=new JButton();
btnRegistro.setBounds(120, 50, 150, 20);
btnRegistro.setText("Registrar");
add(btnRegistro);
btnRegistro.addActionListener(this);
btnSalir=new JButton();
btnSalir.setBounds(120,400, 150, 20);
btnSalir.setText("Salir");
add(btnSalir);
@Override
public void actionPerformed(ActionEvent e) {
if(e.getSource().equals(btnRegistro)){
/*Clase Registro*/
/** @author José Miguel Guimerá Padrón. */
package ventanas;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public Registro(){
componentes();
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
setSize(400,450); // Tamaño de la Ventana Ancho y Largo
setLocationRelativeTo(null); // Centra la ventana en el monitor
setLayout(null); // elimina toda plantilla.
setResizable(false); // eviata que se pueda modificar el tamaño de ventana
setVisible(true); // hace visible la ventana
setTitle(" ** Módulo de Registros **"); // Le pone un titulo a la ventana
}
@Override
public void actionPerformed(ActionEvent e) {
if(e.getSource().equals(btnGuardar)){
System.out.println("Lanzamos una rutina para grabar los datos");
this.dispose();
new Menu();
}
En un nuevo tutorial haremos una continuación de este programa, usando una base de
datos y añadiendo otros campos y nuevas clases. Pondré un link al mismo una vez lo
tenga terminado
Hasta aquí dejo el tutorial. Espero sus comentarios, para aclarar conceptos, como añadir
opciones en caso de que no puedan hacerlo con lo que ya esta explicado, etc... por favor
haganlo en los comentarios.
Asi mismo tu opinión es muy valiosa, asi que si tienes alguna observacion sobre el código
y formas distinta o alternativas de hacelro por favor comentalo para publicarlas y
enriquecer el texto.
Como siempre si detectas algún error u omisión, o hacer una observación importante, por
favor deja un comentario, para corregir, cambiar los conceptos que sean necesarios.
Muchas Gracias por visitar mi blog.