Swin01
Upcoming SlideShare
Loading in...5
×
 

Swin01

on

  • 78 views

 

Statistics

Views

Total Views
78
Views on SlideShare
78
Embed Views
0

Actions

Likes
0
Downloads
3
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Swin01 Swin01 Document Transcript

  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín 1 La Güeb de Joaquín Programación JAVA INTERFAZ GRÁFICO DE USUARIO 1 - Creacion de interfaces con JFC/Swing [I] Referencia Bibliográfica Autor Adolfo Aladró Garcia Publicado en la revista Solo Programadores num 117 Ejemplos copiados del libro Java 2 - Curso de Programacion Fco. Javier Ceballos. RA-MA Sumario JFC/Swing representa el API de Java orientado a diseñar interfaces de usuario multiplataforma de forma rápida. Con JFC/Swing las aplicaciones y Applets Java pueden presentar un aspecto profesional y estándar, compitiendo así con las aplicaciones tradicionales que se ejecutan en entornas gráficos. Indice de Contenidos 1 - Creacion de interfaces con JFC/Swing [I] 1.1 Introducción a JFC/SWING 1.1.1 Componentes 1.1.2 Contenedores 1.1.3 Administradores de diseño 1.1.4 Eventos 1.2 Primera aplicación completa 1.2.1 Esqueleto típico de una aplicación JFC/Swing 1.3 Segunda aplicación completa 1.4 Conclusiones 1.1 Introducción a JFC/SWING La colección de utilidades que proporciona la plataforma Java para desarrollar interfaces de usuario es lo que se conoce como Swing. El paquete javax.swing contiene clases que se corresponden con elementos de interfaz típicos tales como etiquetas, botones, barras de desplazamiento, áreas de dibujo, etc. Al mismo tiempo Swing forma parte de otro software llamado JFC (Java Foundation Classes) que está formado por los siguientes elementos:
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín2 • AWT (Abstract Window Toolkit), la colección primigenia para desarrollar interfaces de usuario. En la actualidad incluye también el API que proporciona soporte para operaciones del tipo "arrastrar y soltar". • Java 2D, el conjunto de clases para realizar dibujos de alta calidad. • Swing, la nueva colección de herramientas para desarrollar interfaces de usuario. • Accesibility, los API que garantizan que una aplicación Java es utilizable por personas con discapacidades. • Internationalization, el soporte para crear aplicaciones válidas para cualquier usuario del mundo, adaptándose a las particularidades del idioma y las convenciones culturales. Todos estos API permiten crear aplicaciones y Applets Java de forma estándar y que además pueden ejecutarse en cualquier plataforma que disponga de la máquina virtual Java (Windows, Mac, Unix, Linux, etc.). Si bien JFC/Swing es una de las partes más complicadas de Java, crear interfaces avanzadas es una tarea relativamente sencilla ya que se trabaja con componentes ya desarrollados (áreas de texto, botones, etc.). La distribución de los componentes dentro de los contenedores, así como su tamaño y colocación, es responsabilidad de los administradores de diseño. Éstos definen una estrategia de forma que garantizan que una interfaz se mostrará de forma correcta con independencia de la plataforma o incluso cuando el usuario modifique el tamaño de la ventana. 1.1.1 Componentes En Java un componente es el elemento más importante de la interfaz de usuario. Todos los elementos que aparecen en una aplicación Java son componentes. Por lo general a cada componente le corresponde una clase y todas estas clases se obtienen a partir de la clase abstracta javax.swing.JComponent. El listado 1 muestra la jerarquía de clases de la que depende la clase javax.swing.JLabel, que representa a una etiqueta, uno de los componentes más típicos y fundamentales. Listado 1 java.lang.Object I +--java.awt.Component I +--java.awt.Container I +--javax.swing.Jcomponent I +--javax.swing.Jlabel Como se puede observar si se asciende por el árbol de clases llegamos hasta los paquetes de AWT, la colección de clases originaria para desarrollar interfaces. En cierto sentido se puede afirmar que JFC/Swing no es más que una extensión de AWT Los métodos y propiedades de un componente controlan la apariencia general de un objeto (visibilidad, tamaño, ubicación, colores, etc.). En el siguiente ejemplo se define un botón y posteriormente se modifica el tipo de letra y el color de la misma con los métodos setFont y setForeground respectivamente:
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín 3 JButton btnAceptar = new JButton("Aceptar"); btnAceptar.setFont(new Font("Courrier New", Font.BOLD, 24)); btnAceptar.setForeground(new Color(255, 0, 0)); En realidad estos dos métodos, así como muchos otros, se definen en la clase javax.swing.JComponent y todos los componentes los heredan. Los componentes también cuentan con métodos y propiedades que sirven para gestionar el comportamiento del componente, o lo que es lo mismo, la interacción con el usuario. Cuando un usuario realiza una acción se genera un evento que el componente recibe. Existen objetos que se encargan de gestionar esos eventos y que se han configurado como tales gestores desde el propio componente. El fragmento de código del listado 2 define un botón, un componente de tipo JButton, y emplea el método addActionListerner de la clase javax.swing.AbstractButton para registrar un objeto que implementa la interfaz java.awt.event.ActionListener y que es en última instancia el responsable de gestionar el evento que se produce cuando un usuario hace clic en el botón. Listado 2 // Crear un botón Jbutton botón = new JButton("Haga clic aquí"); // Establecer como tecla aceleradora la C. Entonces, pulsar Alt+C // será equivalente ha hacer clic, sobre el botón. botón.setMnemonic(KeyEvent.VK_C); // Asignar al botón una descripción abreviada botón.setToolTipText("botón de pulsación"); // Permitir que el botón responda a los eventos de acción ActionListener al = new ActionListener() { // Este método se ejecutará cuando se haga clic en "botón" public void actionPerformed(ActionEvent evento) { Object obj = evento.getSource(); if (obj == botón) mostrarMensaje(); } }; botón.addActionListener(al); El objeto perteneciente a la clase java.awt.event.ActionEvent representa al evento. El método getSource, que a su vez hereda de la clase java.util.EventObject, devuelve el objeto al que le llegó el evento, o si se prefiere, que desencadenó el evento. Más adelante se estudiarán los eventos dentro de la aplicación y Applets JFC/Swing ya que se trata de un tema tan importante como confuso, al menos al principio, cuando se empiezan a desarrollar interfaces por primera vez. 1.1.2 Contenedores Un contenedor es un tipo especial de componente que sirve para agrupar a otros componentes. Todo objeto perteneciente a la clase JComponent puede ser un contenedor tal y como muestra la herencia de clases del listado 3.
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín4 Listado 3 java.lang.Object I +--java.awt.Component I +--java.awt.Container I +--javax.swing.Jcomponent Los contenedores clásicos se corresponden con las clases javax.swing.Jframe, javax.swing.JPanel y javax.swing.JApplet. Un JFrame es una ventana de alto nivel. Un JPanel es un contenedor genérico que sirve para agrupar componentes. Una interfaz puede tener varios contenedores de tipo JPanel que a su vez pueden agrupar contenedores JPanel, todo dentro de una ventana, típicamente un contenedor JFrame. Por último. un contenedor JApplet se emplea para crear Applets Java. La clase java.awt.Container contiene varios métodos add. Todo ellos sirven para añadir elementos al contenedor. De esta forma los contenedores mantienen una lista de los componentes que agrupan. En el ejemplo del listado 4 se define un contenedor de tipo JPane que agrupa una colección de botones Listado 4 // Crear un panel para colocar los controles JPanel panel = new JPanel(); // Introducimos un borde sin pintar alrededor de los controles: // createEmptyBorder(top, left, bottom, right) panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20)); // Establecer un administrador de diseño de cuadrícula panel.setLayout(new GridLayout(0, 1)); // Los controles se añaden en columna (filas = 0) // Se añaden na etiqueta y un boton definidos previamente panel.add(etiqueta); panel.add(botón); // Añadir los componentes al contenedor de la aplicación // ------------------------------------------------- // Ayuda sobre getContentPane // public Container getContentPane() // Returns the contentPane object for this frame. // ------------------------------------------------- getContentPane().add(panel, BorderLayout.CENTER); // Permitir que la ventana de la aplicación responda a los // eventos de ventana (p.e. cerrar la ventana) addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent evento) { cerrarVentana(); // funcion que se encarga de cerrar la ventana // Puedes verla en el ejmplo completo } } );
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín 5 1.1.3 Administradores de diseño Los administradores de diseño son los responsables de la presentación (tamaño y ubicación) de los componentes que se agrupan dentro de un mismo contenedor. Todos los contenedores tienen un administrador de diseño por defecto. El método getLayout definido en la clase java.awt.Container devuelve el objeto correspondiente con el administrador de diseño. Asimismo el método setLayout permite asignar un nuevo administrador de diseño. FlowLayout Por ejemplo, el administrador de diseño que emplea el componente JPanel por defecto es el que se corresponde con la clase java.awt.FlowLayout Éste intenta colocar los objetos de izquierda a derecha y de arriba abajo dentro del contenedor, tratando además de respetar para todos ellos el tamaño preferido. Por lo tanto, en el ejemplo del apartado anterior los botones se presentan uno seguido detrás de otro, de izquierda a derecha y de arriba abajo, y el tamaño de los mismos trata de ser simplemente el que ocupa el texto de su etiqueta, es decir, el preferido o el natural, si se prefiere. Ahora bien, se puede modificar el administrador de diseño tal y como se muestra a continuación: jPanel MijPanel = new JPanel(); BoxLayout MiboxLayout = new BoxLayout (MijPanel, BoxLayout.Y_AXIS); MijPanel.setLayout(MiboxLayout); BoxLayout El administrador javax.swing.BoxLayout agrupa los elementos entorno a un eje (horizontal o vertical). Como consecuencia del cambio anterior los botones aparecerían uno debajo de otro siguiendo un eje vertical. 1.1.4 Eventos Un evento es lo que sucede cuando, por ejemplo, un usuario lleva a cabo cualquier acción en la interfaz (hacer clic en un botón, seleccionar un elemento de una lista, escribir en un campo de texto, etc.). Los eventos se generan desde un componente y son enviados a uno o más gestores de evento que son los responsables últimos de su tratamiento. Las clases correspondientes a los distintos eventos que pueden darse en una interfaz extienden a la clase java.util.EventObject (véase el listado 5). Listado 5 java.lang.Object I +-- java.util.EventObject I +-- java.awt.AWTEvent I +-- java.awt.event.ActionEvent
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín6 java.lang.Object I +-- java.util.EventObject I +-- java.awt.AWTEvent I +-- java.awt.event.ComponentEvent I +-- java.awt.event.InputEvent I +-- java.awt.event.MouseEvent Las clases java.awt.eventActionEvent y java.awt.eventMouseEvent se corresponden con dos de los eventos más comunes en todas las interfaces. La primera representa una acción llevaba a cabo por el usuario, como por ejemplo pulsar un botón. La segunda clase representa a los eventos que se producen cuando el usuario emplea el ratón. Los gestores de eventos reciben los objetos correspondientes al evento producido y realizan las acciones que en cada caso se consideren oportunas. Las clases correspondientes a los gestores de eventos deben implementar una determinada interfaz dependiendo del tipo de evento. Por ejemplo, cuando un usuario pulsa un botón o hace clic en él se genera un evento del tipo ActionEvent. El gestor de este tipo de evento tiene que corresponderse necesariamente con una clase que implemente a la interfaz java.awt.eventActionListener. Todas las interfaces de gestión de eventos proceden de la interfaz java.utiI.EventListener. Algunas de las más comunes son MouseListener o FocusListerner. En el ejemplo del listado 6 se crea una etiqueta (JLabel), otro de los componentes más comunes de las interfaces. Seguidamente se emplea el método addMouseListener para indicar cuál es el objeto responsable de la gestión del evento MouseEvent. Este objeto es a su vez una instancia de una nueva clase que implementa la interfaz MouseListerner. Cuando el usuario hace clic en la etiqueta o pasa por encima se muestra el correspondiente mensaje por la consola. Listado 6 JLabel lblEtiqueta = new JLabel("Etiqueta"); lblEtiqueta.addMouseListener(new MouseListener() { public void mouseClicked(MouseEvent e) { System.out.println("mouseClicked... "); } public void mousePressed(MouseEvent e) { System.out.println("mousePressed... "); } public void mouseReleased(MouseEvent e) { System. out. println ("mouseReleased. . . ") ; }
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín 7 public void mouseEntered(MouseEvent e) { System.out.println("mouseEntered... "); } public void mouseExited(MouseEvent e) { System. out .println ("mouseExited. . .") ; } } }; En la mayor parte de las aplicaciones los gestores de eventos no necesitan gestionar todos los eventos que reciben. Siguiendo con el ejemplo anterior, con frecuencia sólo será necesario implementar algunos de los métodos de la interfaz MouseListerner. Sin embargo como se trata de una interfaz es obligatorio escribirlos todos, aunque estén vacíos. Para evitar esta situación, entre otras muchas ventajas que se irán desvelando más adelante, la gestión de eventos cuenta con lo que se denomina como adaptadores. Los adaptadores son clases de ayuda que implementan los interfaces como MouseListerner y que pueden emplearse para la gestión de eventos. El listado 7 codifica una nueva versión del ejemplo anterior y emplea la clase MouseAdapter para implementar la gestión de eventos de forma que solamente se trata el evento que se desencadena cuando el usuario hace clic en la etiqueta. Listado 7 lblEtiqueta.addMouseListener(new MouseAdapter() { public void mouseClicked(MouseEvent e) { System. out. println ("mouseClicked. . . ") ; } } }; 1.2 Primera aplicación completa Hasta el momento se han visto los fundamentos de las interfaces JFC/Swing. A lo largo de esta serie de artículos se profundizarán en cada uno de los aspectos destacados (componentes, contenedores, administradores de diseños y eventos) pero sin duda alguna la mejor manera de aprender es haciendo aplicaciones. 1.2.1 Esqueleto típico de una aplicación JFC/Swing Una aplicación JFC/Swing típica es una clase que extiende a la clase javax.swing.JFrame. Por ejemplo:
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín8 import javax.swing.*; import java.awt.*; import java.awt.event.*; public class JApplication1 extends JFrame { . . . } El constructor de la clase JApplicationl es el responsable de crear los componentes, agruparlos dentro de contenedores empleando para ello los administradores de diseño que considere oportunos, establecer las clases que gestionarán los eventos que reciben los componentes, etc. En este ejemplo la aplicación simplemente abrirá una ventana en la que mostrará una imagen. El único evento que hay que gestionar es el que se produce cuando el usuario hace clic para cerrar la aplicación. En la clase Japplication1 se han definido las siguientes propiedades o atributos: int iWidth = 640; int iHeight = 480; ImageIcon imageIcon; Los dos primeros almacenan respectivamente la anchura y la altura que se quiere dar a la ventana de la aplicación. El tercero es un objeto perteneciente a la clase javax.swing.ImageIcon que se empleará para leer la imagen una única vez al comienzo de la aplicación. El constructor comienza de la siguiente forma: public JApplication1() { super("Introducción a la creación de interfaces" + " con JFC/Swing (1 de 4)"); setSize(iWidth, iHeight); imageIcon = new ImageIcon("DSCN0055.JPG"); } En la primera línea se establece la cadena de texto que dará título a la ventana principal. Para ello se llama al constructor de la clase superior, JFrame. Seguidamente el método setSize se utiliza para determinar la anchura y la altura de la ventana. Finalmente se crea una instancia de la clase ImageIcon, lo que en última instancia es lo mismo que decir que se lee la imagen. Para presentar la imagen vamos a crear un componente específico que no será más que una pequeña modificación de la clase javax.swing.JPanel, pero antes de crearlo y añadirlo a la ventana principal de la aplicación es preciso obtener el contenedor asociado a dicha ventana. Esto se logra empleando el método getContentPane: Container contentPane = getContentPane(); El método add sirve para añadir un componente al contenedor. En este ejemplo el componente en cuestión es una modificación de un componente JPanel para el que se ha reescrito el método paintComponent (véase el listado 8).
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín 9 Listado 8 contentPane.add( new JPanel() { protected void paintComponent(Graphics g) { g.drawImage( imageIcon.getImage(), 0, 0, getSize().width, getSize().height, 0, 0, imageIcon.getIconWidth(), imageIcon.getIconHeight(), this ); } } ); El método paintComponent de un componente es llamado por el interfaz de usuario de forma automática cada vez que determina que el componente ha de ser "pintado", Esto sucede, por ejemplo, cuando la ventana de la aplicación se presenta por primera vez o cuando el usuario cambia el tamaño de la misma, En este ejemplo el componente lo único que va a hacer es mostrar la imagen que previamente se ha cargado mediante la clase ImageIcon, ocupando todo el espacio disponible. La clase java.awt.Graphics cuenta con un conjunto de métodos para dibujar todo tipo de formas básicas y entre ellos está drawImage, que sirve para presentar imágenes. El método drawImage está sobrescrito de muchas formas distintas pero en este ejemplo se emplea una definición del mismo que permite dibujar la imagen original en un área destino de manera que la ocupe por completo. El primer parámetro es el objeto de tipo java.awt.Image que representa a la imagen. Los cuatro siguientes parámetros son los puntos (dxl ,dyl) Y (dx2,dy2) que se corresponden con la esquina superior izquierda y la esquina inferior derecha del área de destino. A continuación los cuatro siguientes parámetros son los puntos (sxl.sy1) y (sx2.sy2) que se corresponden con la esquina superior izquierda y la esquina inferior derecha del fragmento de la imagen que se va a dibujar en el área destino. El último parámetro es el objeto a que el interfaz notificará los cambios. Al utilizar getSize().width y getSize().height para definir el punto (dx2,dy2) se garantiza que el área destino de dibujo siempre va a ser tan grande como el propio componente en ese momento. Del mismo modo, al emplear imageIcon.getIconWidth() y imageIcon.getIconHeight() para definir el punto (sx2,sy2) se garantiza que el fragmento que se dibuja es toda la imagen. Hasta el momento lo único que se ha escrito es la definición de la clase JApplication1. El último paso que falta para tener una aplicación completa es el método main. Este método puede verse en el listado 9.
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín10 Listado 9 public static void main(String[] args) { JFrame jFrame = new JApplication1(); jFrame.addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } } ); jFrame.setVisible(true); } En primer lugar se crea una instancia de la clase JApplication 1. Seguidamente se crea una instancia de la clase java.awt.event.WindowAdapter que será la responsable de gestionar los eventos relacionados con la ventana que reciba la aplicación. El método addWindowListemer del componente establece cuál es el gestor para dicho componente para ése tipo de evento. El método windowClosing se ejecutará cuando el usuario haga clic en el icono correspondiente de cerrar la ventana y en ese momento se ejecutará System.exit(0) con lo que la aplicación se cerrará. Por último, la llamada al método setVisible(true) hace que la ventana se muestre y con ella todos los componentes definidos en el contendor principal. A parir de la aplicación resultante se puede introducir una pequeña mejora consistente en hacer que la aplicación se cierra simplemente pulsando la tecla Esc. Para ello es preciso configurar un nuevo gestor de eventos, concretamente uno encargado de procesar para ese componente los eventos generados por las pulsaciones del teclado (véase el listado 10). Listado 10 jFrame.addKeyListener( new KeyAdapter() { public void keyPressed(KeyEvent e) { if (e.getKeyCode() == KeyEvent.VK_ESCAPE) { System.exit(0); } } } ); El método keyPressed de la clase java.awt.event.KeyAdapter se ejecutará cada vez que el usuario pulse una tecla teniendo la aplicación activa en primer plano. El objeto perteneciente a la clase java.awt.event.KeyEvent guarda toda la información concerniente al evento y el método getKeyCode, por ejemplo, devuelve el código correspondiente a la tecla pulsada. La propia clase KeyEvent define una serie de teclas estándar de manera que KeyEvent.VK_ESCAPE representa a la tecla ESC. Cuando se detecta que el usuario ha pulsado esta tecla se cierra la aplicación System.exit(0), igual que en el caso anterior.
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín 11 Listado Codigo Completo 1 import javax.swing.*; 2 3 import java.awt.*; 4 import java.awt.event.*; 5 6 class JApplication1 7 extends JFrame 8 { 9 int iWidth = 640; 10 int iHeight = 480; 11 12 ImageIcon imageIcon; 13 14 public JApplication1() 15 { 16 super("Introducción a la creación de interfaces" + " con JFC/Swing (1 de 4)"); 17 setSize(iWidth, iHeight); 18 19 imageIcon = new ImageIcon("DSCN0055.JPG"); 20 21 Container contentPane = getContentPane(); 22 contentPane.add( 23 new JPanel() 24 { 25 protected void paintComponent(Graphics g) 26 { 27 g.drawImage( 28 imageIcon.getImage(), 29 0, 30 0, 31 getSize().width, 32 getSize().height, 33 0, 34 0, 35 imageIcon.getIconWidth(), 36 imageIcon.getIconHeight(), 37 this 38 ); 39 } 40 } 41 ); 42 } 43 44 public static void main(String[] args) 45 { 46 JFrame jFrame = new JApplication1(); 47 jFrame.addWindowListener( 48 new WindowAdapter() 49 { 50 public void windowClosing(WindowEvent e) 51 { 52 System.exit(0); 53 } 54 } 55 );
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín12 56 jFrame.addKeyListener( 57 new KeyAdapter() 58 { 59 public void keyPressed(KeyEvent e) 60 { 61 if (e.getKeyCode() == KeyEvent.VK_ESCAPE) { 62 System.exit(0); 63 } 64 } 65 } 66 ); 67 jFrame.setVisible(true); 68 } 69 } 70 1.3 Segunda aplicación completa A continuacion hay otro ejemplo completo y sencillo de creacion de una aplcacion AWT Listado Codigo Ejemplo 2 1 import javax.swing.*; 2 import java.awt.*; 3 import java.awt.event.*; 4 5 public class AplicacionSwing extends JFrame 6 { 7 // Referencias a los componentes 8 private JLabel etiqueta; 9 private JButton botón; 10 11 // Otras referencias 12 private static String mensaje = "¡¡¡Hola mundo!!!"; 13 14 private AplicacionSwing(String título) // constructor 15 { 16 super(título); // título de la ventana principal 17 iniciarComponentes(); 18 // Ajustar el tamaño de la ventana al mínimo 19 pack(); 20 } 21 22 private void iniciarComponentes() 23 { 24 // Crear una etiqueta con el texto centrado 25 etiqueta = new JLabel(); 26 etiqueta.setHorizontalAlignment(JLabel.CENTER); 27 28 // Crear un botón 29 botón = new JButton("Haga clic aquí"); 30 // Establecer como tecla aceleradora la C. Entonces, pulsar 31 // Alt+C será equivalente ha hacer clic, sobre el botón. 32 botón.setMnemonic(KeyEvent.VK_C); 33 // Asignar al botón una descripción abreviada 34 botón.setToolTipText("botón de pulsación"); 35 // Permitir que el botón responda a los eventos de acción
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín 13 36 ActionListener al = 37 new ActionListener() 38 { 39 // Este método se ejecutará cuando // se haga clic en "botón" 40 public void actionPerformed(ActionEvent evento) 41 { 42 Object obj = evento.getSource(); 43 if (obj == botón) 44 mostrarMensaje(); 45 } 46 }; 47 botón.addActionListener(al); 48 49 // Crear un panel para colocar los controles 50 JPanel panel = new JPanel(); 51 // Introducimos un borde sin pintar alrededor de los controles: 52 // createEmptyBorder(top, left, bottom, right) 53 panel.setBorder(BorderFactory.createEmptyBorder( 20, 20, 20, 20)); 54 // Establecer un administrador de diseño de cuadrícula 55 panel.setLayout(new GridLayout(0, 1)); 56 // Los controles se añaden en columna (filas = 0) 57 panel.add(etiqueta); 58 panel.add(botón); 59 60 // Añadir los componentes al contenedor de la aplicación 61 getContentPane().add(panel, BorderLayout.CENTER); 62 63 // Permitir que la ventana de la aplicación responda a los 64 // eventos de ventana (p.e. cerrar la ventana) 65 addWindowListener( 66 new WindowAdapter() 67 { 68 public void windowClosing(WindowEvent evento) 69 { 70 cerrarVentana(); 71 } 72 } ); 73 } 74 75 private void mostrarMensaje() 76 { 77 // Mostrar el "mensaje" en la "etiqueta" 78 etiqueta.setText(mensaje); 79 } 80 81 private void cerrarVentana() 82 { 83 // Salir de la aplicación 84 System.exit(0); 85 } 86 87 public static void main(String[] args) 88 { 89 try 90 { 91 // Aspecto y percepción de la interfaz gráfica 92 UIManager.setLookAndFeel( 93 UIManager.getCrossPlatformLookAndFeelClassName()); 94 }
  • Java - Interfaz Gráfico de Usuario (GUI) Creación de interfaces con JFC/Swing [I] La Güeb de Joaquín14 95 catch (Exception e) 96 { 97 System.out.println("No se pudo establecer" + " el aspecto deseado: " + e); 98 } 99 AplicacionSwing vPpal = new AplicacionSwing("Aplicación Swing"); 100 vPpal.show(); 101 } 102 } 1.4 Conclusiones En este capítulo se han introducido los fundamentos de la creación de interfaces con JFCjSwing. Quedan muchos aspectos por estudiar, entre los que destacan el manejo de los distintos tipos de componentes, la gestión eficaz de los eventos y el uso de los administradores de diseño. No en vano JFCjSwing es probablemente uno de las partes más sofisticadas y complejas de la plataforma Java. Si bien al principio la creación de interfaces con JFCjSwing puede resultar una tarea compleja e incluso pesada, más adelante se comprobará que una vez adquiridos los conceptos básicos resulta muy sencillo ir desarrollando paulatinamente interfaces cada vez más sofisticados y profesionales.