JTagua

Inicio » Swing » Objetos » JFrame » Swing 02: JFrame.

Swing 02: JFrame.

Licencia

Creative Commons License

Visitas:

  • 813.331 hits

Toda aplicación Swing tiene que tener un contenedor que contenga la aplicación.

Una opción válida sería el componente JFrame, éste proporciona la ventana principal de la interfaz de la aplicación. Por otro lado, desde el lanzamiento o creación de este componente y su posterior visualización, podremos crear y visualizar otros controles Swing que permitan a la interfaz interaccionar con el usuario, tales como cajas de texto, botones, marcos, cajas de comprobación, botones radiales, etc…

Vamos a retomar el ejemplo que iniciamos en la lección anterior, es decir ejava0, Con el botón derecho en el paquete ejava0 hacemos click en añadir “Formulario JFrame” y aparecerá el siguiente cuadro de diálogo:

En el cuadro de diálogo anterior sólo hemos introducido el nombre que recibirá el componente JFrame, le hemos llamado ventanappal. Si hacemos ahora “Terminar” veremos dos cosas:

1) Que se crea dentro del paquete del proyecto un nuevo archivo java denominado ventanappal.java

2) Que el IDE cambia de forma y en área de edición aparece un rectángulo que por defecto será la ventana que representa al componente JFrame. Las características gráficas de esta ventana pueden cambiarse sin mas que pulsar con el botón derecho y localizar la opción “Propiedades”. Por ejemplo le sugiero que cambie la propiedad “title” y la asocie a la cadena “Calculadora”.

Nuestra aplicación inicial ya tiene una ventana. La cuestión ahora es, ¿podremos ver esa ventana?. Si ejecutamos el proyecto veremos que aún no es posible. Y esto es así porque el método main de nuestro proyecto, tiene que crear un nuevo objeto a partir de la clase ventanappal al que llamaremos ventana y además permitir que sea visible.

Para poder hacer esto nos situamos en el archivo Main.java y justo en el método main colocamos, las siguientes dos instrucciones

ventanappal ventana = new ventanappal();
ventana.setVisible(true);

En la primera instrucción creamos un nuevo objeto llamado ventana desde la instanciación de la clase ventanappal() y en la segunda instrucción ejecutamos el método setVisible con el parámetro True al objeto reciencreado.

Si ahora mandamos ejecutar el proyecto, aparece una ventana tal como la siguiente:

Ya tenemos pues una ventana donde colocar otros objetos y construir gráficamente la interfaz de nuestro proyecto.!!

Sencillo ¿verdad?.

Esto es una de las ventajas de la Programación Orientada a Objetos construida de forma gráfica.

La cuestión que se nos plantea ahora es averiguar dónde se encuentra el código que describe a la ventana (JFrame) con todas sus características/variables que determinan tanto su aspecto gráfico como su comportamiento frente a determinados eventos.

La respuesta es que todo el código que caracteriza el aspecto gráfico de la ventana está en el archivo ventanaprincipal.java. Y ahí mismo tendrá que estar también su comportamiento o los eventos a los que reacciona.

Es obvio que algunos de los aspectos gráficos sencillos de interpretar son: el tamaño, el color del fondo, el título, la posición, etc…

Menos obvio es interpretar los eventos. Un evento de un objeto es un método que se ejecuta cuando salta/dispara dicho evento. Por ejemplo, para un componente JFrame  existen eventos para circunstancias tales como la creación de la ventana, la activación de la ventana, el ocultamiento de la ventana, el movimiento de la ventana por la pantalla, cuando se abre, cuando se cierra, etc…

Cada uno de estos eventos pudiera llevar asociado un código que se ejecutaría tan pronto cómo se dispare. Obviamente, este código viene indicado por el análisis funcional del problema que pretende resolver la aplicación o proyecto. Esto es lo que se conoce como “Programación Orientada a Objetos y Conducida por eventos”.

De igual manera que existen estos eventos (y muchos otros) para el componente JFrame, también existen estos mismos u otros diferentes para otros componentes de la librería Swing.

En resumen, los eventos de producen, por ejemplo0, cada vez que el usuario escribe un carácter, oprime un botón del mouse, hace un movimiento con el cursor del mouse, presiona una combinación de teclas, etc. El objeto que recibe el evento (un botón, un área de texto, un panel, una lista, entre otros), es notificado en tiempo de ejecución de que recibió el evento. Finalmente, Todo lo que se debe hacer es implementar la interfaz apropiada (event handler) y registrarla como un escucha (event listener) en el componente  (event source u objeto que va a recibir el evento) apropiado. Veremos mas adelante esta técnica.

FUNDAMENTOS

El archivo ventanappal.java describe:

1) Una clase denominada ventanappal. Esta clase es pública, pues de otra manera no podría llamarse desde el método main de la clase Main. Es necesario que esta clase sea pública para poder ser invocada desde otras clases. Por otro lado, esta clase deriva o es hija de otra clase definida en javax.swing.JFrame , es decir del componente JFrame de la librería de componente Swing que se incorpora automáticamente. Y esto es así debido a la palabra reservada extends. Como es natural, la librería Swing de momento es algo que no nos preocupa, esta librería describe componentes “al uso” en una programación convencional de ventanas y que usamos para resolver nuestra aplicación o proyecto.

2) La clase anterior tiene un método constructor denominado ventanappal que llama al método initComponents() que permitirá construir una instancia u objeto de la clase y por tanto asignar ciertas propiedades y métodos, en este caso al componente JFrame. Para poder ver las instrucciones de este método, despliegue con el ratón (en ventanappal.java) el código haciendo click en el signo +, es decir, si observa el código de la figura siguiente

comprobará que en la línea 31 existe un signo + (mas) . Haga click en dicho signo y se desplegará el código que buscamos.

Explicaciones de  initComponents():

1) Este código es auto gestionado por el IDE conforme añadimos componentes u objetos al JFrame contenedor. Genera instrucciones automáticas que establecen las propiedades y métodos de los objetos se acuerdo a manipulación gráfica cuando estamos “Diseñando” el proyecto con los controles y componentes Swing.

2) No es aconsejable manipular este código, salvo que se tengan las ideas muy claras de cómo funciona el IDE para los componentes Swing.

3) En nuestro problema sólo existe un componente que es el contenedor de componentes JFrame, por esa razón initComponents() contiene muy poca información, y evidentemente, toda esta información está referida a dicho componente. En concreto esta rutina contiene:

  • setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); Con esta instrucción se establece el comportamiento por defecto del cierre de la aplicación, que ocurrirá cuando el usuario cierre la ventana en el botón X.Este comportamiento puede alterarse e incluso implementarse con otras acciones.
  • setTitle(“Calculadora”); Con esta instrucción se asigna un texto a la barra de titulo de la ventana del objeto JFrame.
  • javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());. Aquí se define el objeto layout, el cual deriva de la clase GroupLayout. Esta clase proporciona la forma de gestionar los componentes que contiene un contenedor, es lo que se llama como un LayoutManager. GroupLayout se usa por el constructor de la clase de los distintos contenedores, en este caso, JFrame, de forma automática con la programación visual, aunque también puede codificarse manualmente. El LayoutManager es el encargado de decidir en que posiciones se renderizarán/dibujarán los componentes, que tamaño tendrán, que porción del contenedor abarcarán, etc… Todo esto se realiza de una manera transparente al programador que por lo tanto se ahorra el tener que
    escribir una gran cantidad de líneas de control del programa.

Ventajas de LayoutManager.

• Encapsulan parte de la lógica de presentación de nuestro interfaz gráfico de modo que evitan al programador tener que escribir una gran cantidad de líneas de código. Además hacen este código mucho más sencillo de leer y por lo tanto más manejable.
• Reorganizan automáticamente los componentes del interfaz de modo que siempre se ajuste a las directivas que hemos establecido previamente. Si el usuario en un momento dado decide maximizar el interfaz gráfico éste mantendrá su aspecto original en la medida de lo posible. De este modo no limitamos al usuario a un formato de pantalla determinado.
• Hacen más sencillo la labor de añadir, modificar y eliminar componentes. En un diseño tradicional cuando nos vemos obligados a añadir un componente en un lugar físico de la interfaz que ya tiene otros componentes, seguramente tengamos que mover el resto de componentes del interfaz gráfico para acomodar a nuestro nuevo componente. Utilizando layout manager lo único que tenemos que hacer es agregar el componente y el layout manager se encarga automáticamente de reorganizar todo el interfaz.
• Hacen nuestro interfaz mucho más portable. Esto se debe a que los componentes gráficos no tienen las mismas propiedades en todos los sistemas operativos. Un botón que muestre la cadena “Hola Mundo” en Mac no tendrá las mismas dimensiones que su homónimo en Linux o Windows. Al realizar nuestro programa con layout managers, éstos ya se encargan de ajustar los componentes adecuadamente y nos evitamos problemas inesperados.

Desventajas de LayoutManager.

• Requieren una buena dosis de aprendizaje y práctica.  De todos modos, una vez dominados, son pocos los programadores que dejan de utilizarlos.
• Pueden generar interfaces muy pesadas, pues a veces, una interfaz acaba con muchos paneles anidados y estos paneles son objetos bastante pesados por lo que hay que tener cuidado de no sobrecargar innecesariamente nuestra interfaz gráfica.

El LayoutManager asociado a un componente JFrame, se denomina BorderLayout y básicamente describe los bordes de la ventana

  • getContentPane().setLayout(layout);
    layout.setHorizontalGroup(
    layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
    .addGap(0, 400, Short.MAX_VALUE)
    );
    Esta instrucción establece el tamaño y posición en dirección horizontal medida en pixel de la ventana.
  • layout.setVerticalGroup(
    layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
    .addGap(0, 300, Short.MAX_VALUE)
    );
    Esta instrucción establece el tamaño y posición en dirección vertical medida en pixel de la ventana.
  • pack(); El método pack() hace que la ventana coja el tamaño más pequeño posible que permita ver todos los componentes.

Por otro lado,  en la clase ventanappal se ha generado un método público y estático denominado main, que hace referencia a Runnable() es una interfaz (clase que sólo tiene enunciado sus variables y métodos miembros) y que como mínimo tiene que tener un método “run” e inicia un hilo de ejecución del programa. Se llama a través del método invokeLater de la  clase EventQueue. “Esta clase representa a la cola de eventos que esperan ser procesados y permite capturar y ejecutar los eventos que se produzcan en el hilo creado”.

Tal como puede verse dentro del método run de la interface Runnable se crea (con el operador new) y visualiza el objeto ventanappal, a través del método setVisible(true);

Ejercicios:

1)Se recomienda al lector que se acostumbre a trabajar en forma gráfica cambiando las propiedades o comportamientos mas sencillos del componente JFrame, por ejemplo actúe sobre la propiedad resizable, para hacer que la ventana no pueda cambiar de tamaño. Aveces, interesa que nuestro usuario no tenga esta posibilidad.

Para ver las propiedades de un componente, sitúese  el editor en modo “Diseño”, haga click en el componente JFrame y seguidamente pulse el botón derecho para que aparezca el menú contextual. Finalmente haga click en “Propiedades”.

2) A nivel de código, en la clase ventanappal

2.a) Podría intentar situar al componente JFrame en un lugar fijo de la pantalla, como por ejemplo en 50 (x,anchura), 50 (y,altura) (ancho y alto medido en pixel desde un sistema de ejes cartesiano situado en el margen izquierdo y superior de la pantalla). Para ello, escriba el método  setLocation(50, 50) justo detrás de la llamada a initComponents() en el constructor de ventanappal.

2.b) Podría intentar situar al componente JFrame exactamente en el centro de la pantalla. Para ello, escriba el método setLocationRelativeTo(null) justo detrás de la llamada a initComponents() en el constructor de ventanappal.

2.c) El componente JFrame, tiene por defecto asociado un contenedor, el cual se obtiene a través del método getContentPane(). Compruebe que con el método getContentPane().setBackground(Color.blue) cambia a azul el color del background de la ventana o marco.

En la siguiente entrada vamos a añadir un componente JPanel a nuestra interfaz …


Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google photo

Estás comentando usando tu cuenta de Google. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

Conectando a %s

A %d blogueros les gusta esto: