Los frames son ventanas que existen por si mismas, es decir, que no dependen de ninguna otra ventana (aunque otra ventana las puede hacer aparecer). Un ejemplo de frame es la ventana principal de Word, podemos tener tantas ventanas abiertas como sea necesario y podemos trabajar en todas las ventanas de manera simultanea.

Primero vamos a crear un programa nuevo y vamos a seleccionar el paquete principal (muchas veces se recomienda crear un paquete independiente para guardar ahí todo lo de la interfaz, pero como este es un ejemplo sencillo vamos a utilizar un solo paquete) como se ve en la siguiente imagen:

A nuestra ventana principal vamos a ponerle el nombre MainFrame (este nombre es porque es la ventana principal, no todas las ventanas tienen que llamarse así). Regularmente el nombre de la ventana es algo que nos explique su función y la palabra Frame (AddUserFrame, ViewScoresFrame, DeleteTryFrame).

Ahora ya tenemos una clase, que es como un molde que nos dice cómo crear una ventana. Todas las ventanas de tipo MainFrame que queremos crear las vamos a crear utilizando este molde, sin embargo, aunque sabemos cómo crear la ventana todavía no hemos creado una.

Para hacer esto vamos a regresar al punto de inicio de la aplicación que es el método main() de la clase Main (para la mayoría de los proyectos de NetBeans, otros proyectos podrían iniciar en algún lugar diferente). En este método vamos a agregar la siguiente sentencia:

    public static void main(String[] args) {
        new MainFrame();
    }

Este último código está creando nuestra ventana, es decir que la ventana ya existe, sin embargo, cuando corramos el programa vamos a notar que todavía no podemos ver nada. Esto es porque la ventana todavía no es visible.

Para poder hacer una ventana visible vamos a utilizar el método setVisible() que recibe un valor booleano diciendo si se debe hacer visible o no la ventana. Como en este momento sí queremos que la ventana sea visible vamos a utilizar el siguiente código:

    public static void main(String[] args) {
        new MainFrame().setVisible(true);
    }

Con esto aparece la ventana MainFrame que creamos (y que en este momento está vacía). Para entenderlo mejor imaginemos la creación del aire. Al principio no había aire, después se creó la atmósfera terreste con el Big Bang (o la creó un monstruo de spaghetti, si eso prefieren creer) y por último se hizo visible en la Ciudad de México, la única ciudad de la república donde el aire también se ve.

Ahora vamos a agregar un nuevo botón a la ventana que se llame btnShowFrame y que tenga como texto “Mostrar Frame”. Además vamos a agregar otro frame al proyecto como lo vimos en la sección de agregar ventanas. Esta nueva ventana va a llamarse PopupFrame (porque va a ser el frame que aparece).

En el método actionPerformed() del botón vamos a agregar el siguiente código:

    private void btnShowFrameActionPerformed(java.awt.event.ActionEvent evt) {
        new PopupFrame().setVisible(true);
    }

Con este código aparecerá la segunda ventana cada vez que hagamos click en el botón. Puedes notar que a pesar de que se están creando varias ventanas la ventana principal MainFrame sigue respondiendo a las acciones, porque todas las ventanas son independientes. Una cosa que podemos notar es que cuando cierras cualquier ventana el proyecto termina, esto es porque todas las ventanas tienen como acción predeterminada al cerrar el terminar el programa.

El programa no debe terminar cuando cerremos la ventana PopupFrame, ya que esta ventana sólo está ayudando a la ventana principal. Para lograr esto selecciona la ventana PopupFrame, en el modo de diseño y en la sección de propiedades cambia la propiedad defaultCloseOperation() a DISPOSE_ON_CLOSE, que quiere decir que la ventana va a ser descargada de memoria, pero no va a cerrar todo el proyecto.

Ahora cuando corras el programa podrás ver todas las ventanas, y las ventanas hijas no cerrarán el programa. Recuerda que la ventana principal siempre debe de terminar el programa al cerrarse, porque si no el programa continuaría corriendo en memoria y nunca liberaría sus recursos (lo que se considera una de las peores prácticas de programación).

La diferencia entre los frames y los diálogos es que un diálogo siempre bloquea a la ventana padre hasta que se oculta.

Para agregar un diálogo haz click derecho sobre el paquete principal y ahí selecciona la opción para crear un nuevo diálogo como se ve en la imagen siguiente.

Si la opción no aparece puedes seleccionar la primera opción del menú File/Folder y ahí buscar en la carpeta que se llama GUI Forms donde estará la opción de JDialog. El JDialog que creemos se llamará PopupDialog porque será un diálogo que aparezca. De la misma manera que los frames, los diálogos se nombran con unas palabras que describan su función y terminan con la palabra Dialog.

Crear un diálogo es muy similar a crear una ventana, agrega otro botón a la ventana MainFrame que tenga como nombre btnShowDialog y que tenga como texto “Mostrar diálogo”, en este botón agrega el siguiente código:

    private void btnShowDialogActionPerformed(java.awt.event.ActionEvent evt) {
        new PopupDialog(this, true).setVisible(true);
    }

Como podrás ver, la principal diferencia entre un diálgo y un frame, a la hora de su construcción, es que el diálogo recibe dos parámetros. El primer parámetro es el padre de la ventana, que regularmente vamos a agregar como this que quiere decir que es la misma ventana que lo mandó llamar. El segundo parámetro es un booleano que nos indica si el diálogo es modal, es decir, si va a bloquear al padre.

Corre la aplicación y presiona el botón para mostrar diálogos, ahora intenta mostrar un diálogo nuevo. Como la ejecución está bloqueada por el diálogo ahora la ventana padre no puede continuar ejecutándose. Los diálogos nos permiten solicitar información del usuario y bloquear la ejecución hasta que el usuario la haya proporcionado.