Interfaces de Usuario Con Java

Contenido
INTERFACES DE USUARIO CON JAVA
Notas del Documento....................................................................................................... 3 Introduccin ..................................................................................................................... 3 Conjunto de Clases ........................................................................................................... 4 Modelo de Programacin ............................................................................................. 5 JComponent ..................................................................................................................... 5 Pintado de Componente .............................................................................................. 5 Activar/desactivar componentes ................................................................................. 5 Cuadros y Ventanas .......................................................................................................... 5 Eventos ............................................................................................................................. 8 Receptores y gestores de Eventos................................................................................ 8 Look And Feel ................................................................................................................. 11 Propiedades de Look and feel .................................................................................... 13 Establecer la configuracin Look and feel .................................................................. 14 Look and Feels disponibles en el sistema................................................................... 14 Establecer la apariencia.............................................................................................. 14 Redimensionar Componentes. ................................................................................... 15 Cambiar los colores de la apariencia Nimbus ........................................................ 16 Contenedores de alto nivel ............................................................................................ 18 Aadir componentes al Panel Contenedor ................................................................ 19 Aadir una barra de Men ......................................................................................... 19 Layouts. Posicionar Componentes. ................................................................................ 19 Establecer el Layout ................................................................................................... 19 BorderLayout .............................................................................................................. 19 BoxLayout ................................................................................................................... 21 FlowLayout ................................................................................................................. 22 CardLayout ................................................................................................................. 23 GridBagLayout ............................................................................................................ 23 GridLayout .................................................................................................................. 26 Posicionamiento Absoluto.......................................................................................... 26
Componentes Textuales ................................................................................................. 27 JTextComponent ........................................................................................................ 27 JTextField .................................................................................................................... 27 JPasswordField ........................................................................................................... 28 JFormattedTextField ................................................................................................... 29
JEditorPane y JTextPane ............................................................................................. 31 AbstractButton ............................................................................................................... 31 JButton ....................................................................................................................... 32 JToggleButton ............................................................................................................. 33 JCheckBox ................................................................................................................... 33 JRadioButton .............................................................................................................. 34 JCheckBoxMenuItem y JRadioButtonMenuItem........................................................ 35 Listas ............................................................................................................................... 35 JComboBox ................................................................................................................. 35 JList ............................................................................................................................. 37 Etiquetas. JLabel ............................................................................................................. 38 Spinners. ......................................................................................................................... 39 Uso de Mens................................................................................................................. 40 Creacin de Mens Habituales................................................................................... 41 Creacin de Mens Contextuales............................................................................... 43 Barras de Botones. JToolBar........................................................................................... 44 JPanel. GroupBox............................................................................................................ 45 Cuadros de Dilogo ........................................................................................................ 46 Dilogos Personalizados ............................................................................................. 49 File Choosers .................................................................................................................. 49 Interfaces MDI. Internal Frames..................................................................................... 52 JSplitPane ....................................................................................................................... 53 JSlider ............................................................................................................................. 55 JTabbedPane .................................................................................................................. 56 JTree ............................................................................................................................... 58 ScrollPanes ..................................................................................................................... 59 ToolTips .......................................................................................................................... 61 Barras de Progreso ......................................................................................................... 61 JProgressBar ............................................................................................................... 62 Temporizadores. Timer. ................................................................................................. 63
Interfaces de Usuario con Java Swing
Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes
Notas del Documento.
Todos los ejemplos de este documento deben incluirse en una clase que herede de un objeto JFrame.
Introduccin
Las primeras interfaces de usuario de Java se inician en AWT. AWT es el acrnimo de Abstract Window Toolkit. Posteriormente se implemento SWING, que proporciona clases que representan elementos de IU como ventanas, botones, etc. Todo ello englobado en un paquete denominado javax.swing. Forma parte de las JFC (Java Foundation Clases) que son un superconjunto de clases con cientos de interfaces de programacin. En este JFC se incluyen: AWT. SWING Accesibilidad Interfaces 2D. Drag & Drop.
Se enfocar en ese captulo el modelo de Java Swing y los elementos ms importantes que se pueden desarrollar con este conjunto de clases.
Conjunto de Clases
Son muchas las clases que componen el paquete de javax.swing, y muchas las caractersticas y acciones que se pueden realizar. Se muestran a continuacin las clases ms relevantes y utilizadas
Como se puede apreciar, tenemos un conjunto de clases superiores que heredan de una implementacin de Awt. Es importante destacar las cuatro clases superiores: JApplet. JDialog. Clase principal para crear ventanas de dilogo. JFrame: Definida comnmente como una ventana. JWindow: Se define como un contenedor que se puede mostrar en cualquier parte de la ventana del usuario, sin barra de ttulo.
El resto de clases como se puede ver heredan de una clase denominada JComponent. Con estas clases se pueden crear la gran mayora de las interfaces de usuario.
Java Swing soporta el modelo de programacin de Delegacin. Es decir utiliza un patrn Modelo-Vista-Controlador. Este patrn permite reducir el esfuerzo de programacin para la implementacin de sistemas mltiples y sincronizados. En esencia este mtodo permite separar la estructura, la presentacin y el comportamiento de un componente en diferentes piezas; es decir: separar la el objeto de su presentacin. El modelo MVC en JAVA Swing se realiza a travs de eventos. Los gestores de eventos son controladores y las fuentes de eventos son modelos. Cuando un controlador cambia o realizar una funcin, notifica dicha actividad a todos sus observables. Cada componente se encuentra en realidad formando dos piezas. Una, el delegado UI, responsable de la vista y del controlador que se encarga de responder a los eventos, y otra que constituye el propio modelo de datos.
Modelo de Programacin
JComponent
Como se puede apreciar en la jerarqua de clases, JComponent es el padre de todos los elementos visuales de Swing. Se comenta a continuacin aquellas propiedades y mtodos que se consideran importantes o de inters para trabajar con aquellos componentes hijos: Los componentes de Swing se dibujan automticamente a travs del mtodo paint de la clase JComponent. Sin embargo, se puede cambiar este comportamiento con slo sobreescribir el mtodo paint de la clase:
public class miBoton extends JButton { @Override public void paint(Graphics g) { g.setColor(Color.red); //g.fillRect(TOP, TOP, TOP, CENTER) g.fillRect(0, 0, this.getSize().width, this.getSize().height); g.setColor(Color.green); g.drawString(" El Texto ", 10, 10); }
Pintado de Componente
En el cdigo anterior, se est creando un nuevo tipo llamado miBoton que se dibuja automticamente creando un cuadrado rojo segn su tamao, y un texto en color verde. Los componentes Swing se pueden desactivar de tal forma que el usuario no pueda interactuar directamente con l, ni tampoco aquellos eventos que tienen que ver con la interaccin del usuario. La manera de hacerlo es a travs del mtodo setEnabled().
Activar/desactivar componentes
Cuadros y Ventanas
Se corresponden con los contenedores de ms alto nivel que soportan los componentes Java.
JWindow no es ms que una pantalla grfica, sin adornos. Habitualmente para hacer ventanas de bienvenida. JFrame es una subclase de JWindow con borde y sostiene una barra de mens. La manera de crearlo es ms bien sencilla. Creamos una clase main (como siempre) que dentro del mtodo main, cree un objeto de tipo JFrame, y le establecemos sus propiedades.
public static void main (String[] args) { JFrame f = new JFrame(); f.setTitle("Mi Primera Ventana"); f.setSize(new Dimension(250, 250)); f.setVisible(true); }
El aspecto que mostrara nuestra ventana en un sistema Windows sera el siguiente:
Sin embargo si lo ejecutamos en un sistema BSD, sera:
Como se puede apreciar, la implementacin que tiene cada sistema, es diferente, pero el funcionamiento es el mismo, como se va a ver a continuacin. Notar que cuando el usuario cierra la ventana, no se finaliza el proceso que ha iniciado la maquina virtual. Esto es debido a que no se estn controlando los eventos de la ventana, e
Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes 6
implementado el mtodo de cierre. En cualquier caso, un JFrame puede reaccionar de manera directa sobre la accin de cierre del Componente. Para ello se puede utilizar el mtodo setDefaultCloseOperation(int). Los posibles valores son (definidos como constantes en la interfaz WindowConstants): DO_NOTHING_ON_CLOSE= 0 HIDE_ON_CLOSE=1 DISPOSE_ON_CLOSE=2 EXIT_ON_CLOSE=3
Hagamos ahora lo mismo con un JWindow, para ver la diferencia de aspecto que presentan estas dos interfaces.
Este es el aspecto que mostrara un JWindow vaco. Otra manera de hacer el cierre de una JFrame o Ventana, es mediante la implementacin de la interfaz WindowListener. Esta interfaz la podemos implementar desde una propia clase que herede de JFrame e implemente la interfaz anteriormente dicha, o que se implemente automticamente desde la definicin del mtodo. Se muestra a continuacin la manera de hacerlo:
public class miFrame extends JFrame implements WindowListener { public void windowOpened(WindowEvent e) { throw new UnsupportedOperationException("Not } public void windowClosing(WindowEvent e) { throw new UnsupportedOperationException("Not } public void windowClosed(WindowEvent e) { throw new UnsupportedOperationException("Not } public void windowIconified(WindowEvent e) { throw new UnsupportedOperationException("Not } public void windowDeiconified(WindowEvent e) { throw new UnsupportedOperationException("Not } public void windowActivated(WindowEvent e) { throw new UnsupportedOperationException("Not } public void windowDeactivated(WindowEvent e) { throw new UnsupportedOperationException("Not } }

supported yet.");
supported yet.");
supported yet.");
supported yet.");
supported yet.");
supported yet.");
supported yet.");
El mtodo donde se debe implementar el cdigo es windowClosing. Se puede finalizar la aplicacin de la siguiente manera (siempre hay que establecer el listener del evento):
public class miFrame extends JFrame implements WindowListener { public miFrame() { this.addWindowListener(this); } public void windowClosing(WindowEvent e) { //throw new UnsupportedOperationException("Not supported yet."); this.dispose(); }
Eventos
Los objetos de Swing se comunican entre s mediante el envo de mensajes o eventos. Los objetos de SWING pueden lanzar eventos y capturarlos o manejarlos. Los eventos se envan desde un objeto a uno o ms receptores. Un receptor ejecuta los mtodos prescritos para manejar esos eventos. Un objeto de evento es una instancia de una subclase de java.util.EventObject y contiene informacin acerca de algo que le ha ocurrido a su fuente. Un evento se enva pasndolo como un argumento al mtodo controlador de eventos del objeto receptor. Por ejemplo, ActionEvent se enva siempre a un mtodo llamando actionPerformed() que se encuentra en el objeto receptor.
8
Receptores y gestores de Eventos
En esencia, nos estamos refiriendo a lo siguiente:
public class otroFrame implements ActionListener { public void actionPerformed(ActionEvent e) { } }
Cualquier objeto que reciba ActionEvent debe implementar la interfaz ActionEvent. Todas las interfaces de gestin de eventos son subinterfaces de java.util.EventListener, que es una interfaz vaca. Posteriormente debemos indicar a la fuente de eventos, cual va a ser el receptor de eventos. Para recibir eventos, un gestor de eventos se debe registrar con la fuente de eventos, lo cual permite que se capturen esos eventos. Para ello, se debe usar el mtodo addActionListener para aadirlo, o removeActionListener para quitarlo.
public class otroFrame extends JFrame implements ActionListener { JButton btn = null; public otroFrame() { btn = new JButton(); btn.addActionListener(this); this.add(btn); } public void actionPerformed(ActionEvent e) { //Mtodo que se ejecuta al producirse el evento... System.out.println(e.getSource().toString()); } }
En esencia, Java implementa el envo de eventos mediante interfaces. En realidad todos los objetos de Java envan mensajes (eventos) que otros les pueden capturar. Si desde un cdigo (una clase) queremos capturar un determinado evento, debemos registrar esa clase como capturadora de eventos. Sin embargo, la manera que tiene la mquina virtual de Java de mandarnos ese evento es llamando a un determinado mtodo que conozca su firma (nombre incluyendo los parmetros). Esto es slo posible mediante la implementacin de interfaces.

Interfaz: Mtodo N
El botn lanza un mensaje a la JVM Botn
Implementa
Clase
JVM
Almacn de clases que capturan eventos
JVM busca las clases que pueden responder a esos eventos, y mediante Polimorfismo, nos llama al mtodo correspondiente
Por tanto, no debemos olvidar: Si queremos que una clase capture los eventos o mensajes de otra, debemos implementar la interfaz correspondiente. Registrar la clase capturadora de eventos.
Normalmente, los dos apartados anteriores, se suele hacer en la misma clase como se muestra a continuacin:
public class unFrame extends JFrame implements ActionListener { private JButton btn1 = null; public unFrame() { inicializarComponentes(); } private void inicializarComponentes() { this.setLayout(new FlowLayout(FlowLayout.CENTER)); this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); btn1 = new JButton(); btn1.setText("Botn 1"); btn1.setSize(60, 20); btn1.addActionListener(this); this.add(btn1); }
public void actionPerformed(ActionEvent e) { if (e.getSource() == btn1) { } else if (e.getSource() == btn2) { } } }
Destacar del cdigo anterior la implementacin de la interfaz ActionListener y la adicin de la clase como escuchadora de ese tipo de eventos. Para ser ms concretos, esta interfaz recibe eventos de accin. Cuando el evento se produce se llama al mtodo actionPerformed.
Look And Feel

A continuacin se muestra una imagen de aquellos controles de usuario de Java, alguno de ellos junto con su apariencia en Windows.
11
12
El toolkit de swing nos permite decidir la configuracin de la apariencia de la aplicacin. Si no se especifica (look and feel), el administrador de interfaz de usuario de swing determina cual usar. Las opciones de configuracin se reducen a: Dejar al administrador de interfaces de Swing determinar la configuracin. El administrador de configuracin determina la apariencia segn las preferencias del usuario (guardadas en el sistema). El Java look and feel que trabaja en todas las plataformas se denomina Metal. Usar la apariencia nativa de la plataforma en la que se ejecuta la aplicacin. Si nos encontramos con un sistema Microsoft, usar la apariencia de la versin del sistema (XP, Vista). En Mac OS el look and feel que se utiliza se llama Aqua. En
Propiedades de Look and feel
sistema Unix (Solaris o Linux) se usa GTK o CDE/Modif segn la configuracin del usuario. Especificar el look and feel. Crear un tema especial usando el paquete Synth. Usar una apariencia externa.
Normalmente no se necesitar interactuar o cambiar la apariencia de la interfaz. Todos los componente delegan su interfaz (apariencia) a la clase JComponent. Si algn control o componente quisiera cambiar su interfaz bastara con sobreescribir aquellos mtodos de pintado del componente.
Establecer la configuracin Look and feel
Look and Feels disponibles en el sistema

JRE proporciona los siguientes Look and Feels: CrossPlatformLokAndFeel: Es el Java look and feel (Metal). Tiene la misma apariencia en todas las plataformas, y la apariencia por defecto si no se establece ninguna. SystemLookAndFeel. Apariencia nativa. Se establece en tiempo de ejecucin. Synth: paquete para crear nuestras apariencias mediante ficheros XML.
Se muestra un resumen de las apariencias con las que nos podemos encontrar al usar el SystemLookAndFeel.
Plataforma Other Solaris, Linux IBM UNIX HP UX Classic Windows Windows XP Windows Vista Macintosh
Look and Feel Motif IBM* HP* Windows Windows XP Windows Vista Macintosh
Solaris, Linux with GTK+ 2.2 or later GTK+
Las apariencias GTK, Motif y Windows se proporcionan con el SDK de Java. Cuando queramos establecer la apariencia de una aplicacin, lo haremos como primera ejecucin de la misma. En caso contrario nos podemos encontrar con que el comportamiento de la misma sea indeseado. Cuando un componente Java Swing quiere pintarse, pregunta al administrador de interfaces (UIManager) el tipo de apariencia que debe mostrar. La clase UIManager, permite adems recuperar las apariencias disponibles a aplicar as como establecer una apariencia concreta. A continuacin se muestran unos segmentos de cdigo para trabajar con esta clase.
//Nombre de la clase L&F que implementa el L&F por defecto
UIManager.getCrossPlatformLookAndFeelClassName(); //Nombre del L&F del sistema UIManager.getSystemLookAndFeelClassName(); Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes 14
Establecer la apariencia
//Establecer una apariencia en concreto UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
De manera general se puede establecer el tamao de cualquier componente a cualquier tamao mediante el mtodo setSize de JComponent. Sin embargo, algunas veces necesitamos establecer de manera general el tamao a todos los componentes en funcin de una configuracin del usuario. Por ejemplo: Mostrar todos los botones de una barra de botones a un tamao. Esto se puede hacer en algunas apariencias de Java (L&Fs) mediante el mtodo putClientProperty. Permite establecer los siguientes tamaos: regular, mini, small y large. A continuacin se muestra un ejemplo del resultado final:
Redimensionar Componentes.
Para establecer un tamao al componente haramos lo siguiente:

btn1.putClientProperty("JComponent.sizeVariant", "mini");
Una vez que tengamos establecido el tamao, se deber actualizar la interfaz:

SwingUtilities.updateComponentTreeUI(this);
Este tipo de funcionalidad slo est en algunas apariencias, como por ejemplo Nimbus . Se muestra a continuacin el aspecto que presenta. (btn1, es la instancia a la que hace referencia el botn con el texto Botn 1.
1
El cdigo de la interfaz anterior sera:

public class unFrame extends JFrame Nimbus es una apariencia introduca en Java 6, actualizacin 10 que utiliza vectorizacin Java 2D, que permite configurar la apariencia. En el siguiente enlace http://java.sun.com/docs/books/tutorial/uiswing/lookandfeel/_nimbusDefaults.html#primary se recogen todas las constantes de colores, imgenes, propiedades, etc.
1
implements ActionListener { private JButton btn1 private JButton btn2 public unFrame() { inicializarComponentes();

= null; = null;
try { UIManager.setLookAndFeel(new NimbusLookAndFeel()); }catch (Exception ex) {System.out.println(ex.toString());} btn1.putClientProperty("JComponent.sizeVariant", "mini"); SwingUtilities.updateComponentTreeUI(this); this.pack(); } private void inicializarComponentes() { //this.setLayout(new GridLayout(2,1,40,40)); this.setLayout(new FlowLayout(FlowLayout.CENTER)); this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); this.setBackground(Color.red); this.setSize(500, 300); btn1 = new JButton(); btn1.setText("Botn 1"); btn2 = new JButton(); btn2.setText("Botn 2"); btn2.setSize(60, 20); btn2.addActionListener(this); this.add(btn1); this.add(btn2); } }
La siguiente imagen muestra la interfaz con el tamao large y mini.
Cambiar los colores de la apariencia Nimbus Por defecto, el L&F Nimbus tiene establecidos una serie de colores por defecto, que se pueden cambiar. Estos parmetros se pueden encontrar en la pgina principal de Nimbus. Cuando queramos cambiar estos valores, debemos hacerlo antes de establecer el L&F de la interfaz de usuario. El cdigo para ello es el siguiente:
//Cambiar el color base de los componentes UIManager.put("nimbusBase", Color.red); //Cambiar el color del texto de los controles UIManager.put("textForeground", Color.yellow);
17
La apariencia de los componentes sera la siguiente:
Contenedores de alto nivel

Swing proporciona tres contenedores superiores: JFrame, JDialog y JApplet. Cuando se utilicen estas tres clases, se debern tener en cuenta los siguientes puntos: Un componente grfico debe ser parte de una jerarqua de contenedores. Tiene que existir un contenedor raz de alto nivel siempre. Cada componente grfico slo puede ser contenido una vez. Si se incluye un componente ya contenido en otro contenedor, este desaparece del primero Cada contenedor superior, tiene un panel que es el que contiene los componentes visuales en ese contenedor Opcionalmente, se puede aadir una barra de mens a un contenedor de alto nivel. Esta barra, por convencin se aade en la parte del contenedor, aunque algunas apariencias (L&Fs) como la de Apple (Aqua) permite posicionarla en la parte superior de la ventana.
A continuacin se muestra una imagen en la que se indica el contenedor y el panel.
public class unFrame2 extends JFrame { public unFrame2() { super("Frame Dos"); //Tambin aadimos un menu JMenuBar menu = new JMenuBar(); menu.setPreferredSize(new Dimension(this.getWidth(), 20)); this.getContentPane().setBackground(Color.yellow); this.setSize(240, 240); this.setJMenuBar(menu); } }
18
Para aadir un componente es suficiente tener una referencia al panel principal del contenedor mediante el mtodo getContentPane()
frame.getContentPane().add(new JButton());
Aadir componentes al Panel Contenedor
Para incluir componentes en el contenedor tambin se puede usar el mtodo add, remove. En este caso, cada componente contenido o hijo se incluira tambin al panel del contenedor.
Aadir una barra de Men
Para aadir una barra de mens se utilizar el mtodo setJMenuBar.

JMenuBar menu = new JMenuBar(); menu.setPreferredSize(new Dimension(this.getWidth(), 20)); this.setJMenuBar(menu);
Layouts. Posicionar Componentes.

Se denominan Layouts a aquellas clases que administran la colocacin de los controles hijos en los contenedores. Implementan la interfaz LayoutManager y determinan la posicin y el tamao de los componentes. Aunque los componentes tengan explcitamente establecido un tamao, la ltima palabra la tiene el Layout. Se establece un determinado Layout al crear el Frame o contenedor con el mtodo setLayout(). Todo panel contenedor se inicializa para usar un BorderLayout; es decir: no es necesario especificar el tipo de contenedor al crear el JFrame, automticamente ya se determina un BorderLayout). La siguiente imagen muestra el comportamiento de un BorderLayout
Establecer el Layout
BorderLayout
Un BorderLayout posee cinco reas fundamentales, que estn especificadas por las siguientes constantes 2:
Estas constantes son diferentes en el JDK 1.3 y anteriores. Las posiciones se establecan segn los puntos cardinales
19
PAGE_START PAGE_END LINE_START LINE_END CENTER
Veamos el ejemplo de posicionamiento de la ventana anterior

public class FrameBorderLayout extends JFrame { public FrameBorderLayout() { super("BorderLayout"); Container pane= getContentPane(); JButton button = new JButton("Button 1 (PAGE_START)"); pane.add(button, BorderLayout.PAGE_START); button = new JButton("Button 2 (CENTER)"); button.setPreferredSize(new Dimension(200, 100)); pane.add(button, BorderLayout.CENTER); button = new JButton("Button 3 (LINE_START)"); pane.add(button, BorderLayout.LINE_START); button = new JButton("Long-Named Button 4 (PAGE_END)"); pane.add(button, BorderLayout.PAGE_END); button = new JButton("5 (LINE_END)"); pane.add(button, BorderLayout.LINE_END); } }
Cuando la ventana anterior se maximiza, esta ocupa la mxima parte central posible. El resto de las zonas se expanden slo lo necesario para rellenar el espacio sobrante. Sin embargo habr que tener en cuenta las dimensiones preferentes que se han indicado al crear el objeto (setPreferredSize). El constructor de la clase BorderLayout nos permite especificar la distancia en pixels entre cada componente:
public BorderLayout(int hgap, int vgap)
Adicionalmente, nos permite establecer esas distancias mediantes los mtodos setHgap(int) o setVgap(int). En el siguiente segmento de cdigo se indica que posicione los controles entre s con 5 pixels de separacin.
Container pane= getContentPane(); this.setLayout(new BorderLayout(5,5)); JButton button = new JButton("Button 1 (PAGE_START)");
Siendo el resultado el siguiente:
20
Este layout permite apilar los componentes uno sobre otro, o posicionarles en una fila. Se puede pensar que es igual a un FlowLayout, pero con mayor funcionalidad. Este Layout es muy til cuando queremos disear barras de herramientas o barras verticales de botones ya que distribuye los componentes en una sola fila o columna (es decir: ubicar los componentes de manera horizontal o vertical). A continuacin se incluye un cdigo:
public MiBoxLayout() { super.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); JPanel panelVertical = new JPanel(); panelVertical.setLayout(new BoxLayout(panelVertical, BoxLayout.Y_AXIS)); for (int i=0;i<3;i++) panelVertical.add(new JButton("Boton V.: " + i)); JPanel panelhorizontal = new JPanel(); panelhorizontal.setLayout(new BoxLayout(panelhorizontal, BoxLayout.X_AXIS)); for (int i=0;i<5; i++) panelhorizontal.add(new JButton("Boton H.: " + i)); getContentPane().add(panelhorizontal, BorderLayout.EAST); getContentPane().add(panelVertical, BorderLayout.SOUTH); this.pack(); }
BoxLayout
La interfaz que genera el anterior cdigo es el siguiente:
Para simplificar las cosas, BoxLayout usa un contenedor nativo llamado Box. Este contenedor permite crear las posiciones verticales u horizontales de posicionamiento.
public MiBoxLayout() {
super.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); /* JPanel panelVertical = new JPanel(); panelVertical.setLayout(new BoxLayout(panelVertical, BoxLayout.Y_AXIS)); for (int i=0;i<3;i++) panelVertical.add(new JButton("Boton V.: " + i)); JPanel panelhorizontal = new JPanel(); panelhorizontal.setLayout(new BoxLayout(panelhorizontal, BoxLayout.X_AXIS)); for (int i=0;i<5; i++) panelhorizontal.add(new JButton("Boton H.: " + i)); getContentPane().add(panelhorizontal, BorderLayout.EAST); getContentPane().add(panelVertical, BorderLayout.SOUTH); this.pack(); */ Box bv = Box.createVerticalBox(); for (int i=0;i<5;i++) bv.add(new JButton("Botn V: " + i)); Box bh = Box.createHorizontalBox(); for (int i=0;i<3;i++) bh.add(new JButton("Boton H.:" + i)); getContentPane().add(bv, BorderLayout.EAST); getContentPane().add(bh, BorderLayout.SOUTH); this.pack(); }
El resultado generado es el siguiente:
El gestor de contenido FlowLayout permite hacer fluir los componentes del formulario de izquierda a derecha hasta que se llena el espacio superior. Una vez ocupado ese espacio, incluye una nueva fila y contina introduciendo componentes. Si el contenedor es suficientemente ancho para albergar los componentes, FlowLayout centra el contenido. Podemos incluso indicar al FlowLayout la manera de alinear los componentes (izquierda o derecha) mediante su constructor.
FlowLayout
public miFlowLayout() {
super.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); JPanel pan = new JPanel(new FlowLayout(FlowLayout.TRAILING)); pan.add(new JButton("1")); pan.add(new JButton("2")); pan.add(new JButton("Tres")); pan.add(new JButton("Cuatro")); //Posicionar los controles de Derecha a izquierda //En orden inverso a como se han ido agregando pan.setComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT); getContentPane().add(pan); this.pack(); }
Cuando se establece al panel un FlowLayout, se puede establecer la orientacin de la que se habla anteriormente. En el caso de un FlowLayout se pueden usar los siguientes: LEFT: Ancla los controles a la izquierda CENTER: Centra todos los controles RIGHT: Ancla los controles a la derecha LEADING: La que indique la orientacin de los componentes TRAILING: Contraria a la que indica la orientacin
Comentar por ltimo, que con este gestor de interfaz tambin se pueden indicar los pixeles de separacin entre cada componente, tanto de manera horizontal como de manera vertical. El administrador CardLayout se utiliza para posicionar componentes que usan el mismo espacio visual. Sin embargo, esta funcionalidad ha sido trasladada al componente TabbedPane por lo que se omite el funcionamiento de este administrador.
CardLayout
GridBagLayout es uno de los administradores de posicin ms flexibles que posee Java. Permite posiciones componentes al estilo de una celda: es decir: mediante filas y columnas, permitiendo especificar los componentes que ocupan mltiples filas y/o columnas. Las filas o columnas no tienen porque ocupar el mismo ancho o alto. La siguiente figura, muestra la celda que se ha diseado para generar la interfaz. Se puede ver como el botn de la segunda fila ocupa todas las columnas. De forma muy parecida, el botn de la tercera fila, ocupa las dos ltimas columnas.
GridBagLayout
23
Se usa un objeto GridBagConstraints para indicar el comportamiento de los componentes en el GrdBagLayout. Cada componente administrador en un GridBagLayout est asociado a una instancia de GridBagConstraints, que como se ha comentado en lneas anteriores, especifica como posicionar el componente y el rea del componente que debe localizarse en la celda. Adems considera el tamaao mnimo y preferido de muestreo del componente. Se pueden especificar las siguientes restricciones (constraints): gridx,gridy: especifican la fila y columna de la parte superior izquierda del componente. La columna de la izquierda tiene direcciones gridx=0 y la fila superior gridy=0. Se puede usar la constraint GridBagConstraints.RELATIVE para especificar que el componente debe ser posicionad justo a la derecha o debajo del componentes que fue aadido anteriormente. gridwidth, gridheight: especifican el nmero de columnas o filas en el rea de muestreo de los componentes. Es decir: especifica el nmero de celdas que el componente usar, El valor por defecto es 1. Se usa GridBagConstraints.REMAINDER para especificar que el componente sea el ltimo de la fila o columna. GridBagConstraints.RELATIVE para especificar que el componente sea el siguiente al ltimo de la fila o columna. fill: usado cuando el rea del componente es mayor que el tamao requerido por el componente para determinar cmo redimensionarse. GridBagConstraints.HORIZONTAL: hace al componente suficientemente ancho para rellenar el rea horizontal. VERTICAL, hace al componente suficientemente alto para rellenar su espacio vertical. BOTH, rellena su rea tanto en horizontal como en vertical. ipadx, ipady: especifica el relleno interno del componente. Cuando aadir al tamao del componente. Por defecto 0. insets: especifica el relleno externo, o el espacio entre componentes y los bordes de visualizacin. anchor: usado cuando el componente es ms pequeo que el rea de visualizacin para determinar donde posicionar el componente. Las posibilidades son las siguientes:
------------------------------------------------|FIRST_LINE_START PAGE_START FIRST_LINE_END| | | | | |LINE_START CENTER LINE_END| | | | | |LAST_LINE_START PAGE_END LAST_LINE_END| ------------------------------------------------24
weightx,weighty: Se usa para especificar la distribucin del espacio entre columnas y filas. Es importante a la hora de producirse cambios en el tamao del contenedor. Si no se especifica un valor, todos los componentes se agrupan en el centro de su recipiente (valor 0,0). Estos weights (pesos) se especifican mediante valores entre 0 y 1. Un nmero alto indica que la fila o columna del componente debe adquirir ms espacio.
Veamos el ejemplo anteriormente expuesto:

public miGridBagLayout() { super("GridBagLayout"); setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); GridBagConstraints c = new GridBagConstraints(); setLayout(new GridBagLayout()); Container pan = getContentPane(); JButton btn = null; btn = new JButton("Botn 1"); //Usar un GridBagLayout para el botn c.fill = GridBagConstraints.BOTH; //Colocarle en la fila:0 columna:0 c.gridx=0; c.gridy=0; pan.add(btn, c); //---------btn = new JButton("Boton 2"); c.fill = GridBagConstraints.HORIZONTAL; c.weightx=0.5; c.gridx=1; c.gridy=0; pan.add(btn, c); //-------btn = new JButton("Botn 3"); c.fill= GridBagConstraints.HORIZONTAL; c.weightx=0.5; c.gridx=2; c.gridy=0; pan.add(btn,c); //--------btn = new JButton("Botn 4"); c.fill=GridBagConstraints.HORIZONTAL; c.gridwidth=3; c.weighty=1; c.ipady=90;//Dar tamao al componente c.gridx=0; c.gridy=1; pan.add(btn,c); //------btn = new JButton("Botn 5"); c.fill = GridBagConstraints.HORIZONTAL; c.ipady=0; c.weighty=1; c.anchor = GridBagConstraints.PAGE_END; c.gridx = 1; c.gridwidth=2; c.gridy=2; pan.add(btn, c); this.pack();

GridLayout
GridLayout posiciona los componentes en una rejilla. Cada componente, se posiciona en una celda que adems son todas del mismo tamao. Cuando se llama al constructor de este objeto, se indica el nmero de filas, columnas y la distancia entre cada componente. Igualmente, se pueden utilizar los mtodos setHgap, setVgap, setRows, setColumns para establecer las propiedades de este componente, A continuacin se muestra un ejemplo sencillo:
public miGridLayout() { super.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); Container pan = getContentPane(); //Creamos una rejilla de 4 filas y 3 columnas pan.setLayout(new GridLayout(4, 3, 2, 2)); for (int i=0;i<=9;i++) { JButton btn = new JButton(String.valueOf(i)); pan.add(btn); } this.pack(); }
La interfaz que se genera es la siguiente:
Java permite realizar un posicionamiento absoluto de los componentes, aunque lo desaconseja. Para posicionar absolutamente controles en un contenedor, los haremos de la siguiente manera: Estableceremos el layout del contenedor a null. Llamaremos al mtodo setbounds del componente. Llamaremos al mtodo repaint del componente.
Posicionamiento Absoluto
Debemos tener en cuenta que si se crean posicionamientos absolutos, los controles no se redimensionarn cuando la pantalla contenedora lo haga.
26
Componentes Textuales
Existen varios componentes textuales en Swing, cada uno de ellos dedicado a una funcionalidad especfica que est agrupados en tres grupos. Estos son los siguientes:
Controles de Texto: Slo muestran una lnea, y son capaces de generar eventos. Se utiliza para mostrar una pequea cantidad de informacin al usuario. JTextArea: muestra varias lneas de texto, con el mismo formato (fuente). Se puede utilizar para permitir al usuario introducir una cantidad de texto mayor sin formato. reas Textuales Formateadas: permite mostrar texto formateado en varias lneas e incluso incrustar contenido multimedia. Pueden incluso se inicializados desde una URL.
A continuacin se ven cada uno de estos componentes en profundidad. Es la clase principal de componentes textuales. Proporciona las siguientes caractersticas a sus clases hijas: Un modelo, llamado document que administra el contenido del componente. Una view que muestra el componente en la pantalla Un controller llamado editor kit que lee y escribe texto e implementa las opciones de eventos. Soporte para hacer y deshacer (undo y redo). Listeners para navegacin y cursores de edicin.
JTextComponent
A continuacin se muestran las acciones ms comunes con un objeto JTextComponent: http://java.sun.com/docs/books/tutorial/uiswing/components/textapi.html
JTextField es un control de texto bsico que permite al usuario introducir o ver una cantidad pequea de texto en una nica lnea. Cuando el usuario presiona la tecla enter el componente lanza el evento de accin.
JTextField
27
JTextField txtnom = null; public misTextos() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new GridLayout(1, 2)); Container pan = getContentPane(); pan.add(new JLabel("Nombre")); txtnom = new JTextField("Introduce t nombre"); txtnom.addActionListener(this); pan.add(txtnom); this.pack(); }
Vamos a ver ahora un ejemplo en el que mediante un JTextField marcamos una serie de caracteres de un color. Para ello hay que usar la interfaz Highlighter y HighlighterPainter.
public void actionPerformed(ActionEvent e) { else { Highlighter h = new DefaultHighlighter(); txtnom.setHighlighter(h); try { //Seleccionar desde la posicin 2 hasta la 8 (un total de 6 caracteres) // y seleccionamelo en color gris h.addHighlight(2, 8, new DefaultHighlighter.DefaultHighlightPainter(Color.GRAY)); } catch (BadLocationException ex) { Logger.getLogger(misTextos.class.getName()).log(Level.SEVERE, null, ex); } } }
Las acciones habituales con este componente son: get|setText();get|setColumns();set|getHorizontalAlignment(); set|isEditable(); addActionListener();
Proporciona una caja de texto especializada para introducir contraseas, que adems no muestra los caracteres pulsados. Estos caracteres se almacenan en un array de caracteres, y es capaz de lanzar un evento cuando el usuario presiona la tecla enter.
public class Passwords extends JFrame implements ActionListener { JPasswordField txtpass = null; public Passwords() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new GridLayout(1, 2)); txtpass = new JPasswordField("Contrasea", 12); txtpass.setActionCommand("pass"); txtpass.addActionListener(this);
JPasswordField
getContentPane().add(txtpass); JButton btn = new JButton("OK"); btn.addActionListener(this); btn.setActionCommand("ok"); getContentPane().add(btn); pack(); }
public void actionPerformed(ActionEvent e) { JDialog d =null; if (e.getActionCommand().equals("pass")) { d= new JDialog(this, "Pass"); d.add(new JLabel("Acabaste.")); d.setLocationByPlatform(true); } else if (e.getActionCommand().equals("ok")) { d = new JDialog(this, "Contrasea"); d.getContentPane().add(new JLabel("La contrasea es: " + String.valueOf(txtpass.getPassword()))); } d.setModal(true); d.pack(); d.setVisible(true); } }
Nos permite especificar cules son los caracteres vlidos a la hora de introducir informacin por parte del usuario. JFormattedTextField aade un formateador y un objeto value. El formateador nos permite configurar el campo textual a nmeros, fechas en un formato localizable. Adems, nos va a permitir especificar una mscara para determinar el tipo y la posicin de cada carcter. El constructor usado para crear un objeto de texto con formato necesita un objeto de tipo Format. Esto objeto se usa para traducir el valor del campo a texto y viceversa. Se debe tener en cuenta que cuando trabajamos con un objeto JFormattedText, la propiedad text y value son diferentes. La propiedad text refleja lo que el campo est mostrando en ese momento (texto formateado), mientras que value representa un object. Cuando queramos recuperar recuperar el texto del componente llamaremos al mtodo getText() mientras que si queremos recuperar su valor usaremos el mtodo getValue(). Existen formateadores ya definidos que heredan directamente de la clase Format, como por ejemplo: DateFormatter: Destinado a fecha. La clase que permite obtener una instancia se llama DateFormat NumberFormatter. Nmeros. NumberFormat DecimalFormatter
JFormattedTextField
29
Igualmente, se pueden crear mscaras de entrada (una mscara obliga al usuario a introducir en una posicin concreta del componente un carcter o un grupo de caracteres. Por ejemplo: un NIF siempre son 8 dgitos y una letra). Para ello se utiliza la clase MaskFormatter. Este objeto recibe como una cadena la mscara para formatear el componente JFormattedTextField. La cadena tiene que estar formada por los siguientes caracteres:
Caracter # ' U L A ? * H Un dgito
Descripcin Caracter de escape Un caracter que se transforma a maysculas Un character que se transforma a minsculas Representa un caracter o un nmero Cualquier carcter Cualquier cosa Un valor hexadecimal(0-9, a-f o A-F).
Adicionalmente, se pueden restringir la entrada de datos a ciertos caracteres. Es decir: si usramos una mscara de entrada del tipo *podramos adems limitar los caracteres que puede introducir. Veamos un ejemplo para aclarar los conceptos introducidos
public Formatos() throws ParseException { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new GridLayout(4, 2)); JLabel lbl = new JLabel("Numero"); NumberFormat nf = NumberFormat.getInstance(); //Un slo dgito en la parte decimal nf.setMinimumFractionDigits(1); nf.setMaximumFractionDigits(1); JFormattedTextField txtnum = new JFormattedTextField(nf); getContentPane().add(lbl); getContentPane().add(txtnum); //Si no establecemos un valor inicial, cuando el usuario introduzca un valor //incorrecto ese valor permanece. txtnum.setValue(0); //------- Moneda getContentPane().add(new JLabel("Moneda")); NumberFormat formatoMoneda = NumberFormat.getCurrencyInstance(Locale.getDefault()); JFormattedTextField txtmon = new JFormattedTextField(); txtmon.setValue(0); getContentPane().add(txtmon); //------ Mascara getContentPane().add(new JLabel("Un DNI")); MaskFormatter mascaraDNI = new MaskFormatter("########-?"); JFormattedTextField txtdni = new JFormattedTextField(mascaraDNI); getContentPane().add(txtdni); //----- Fechas
getContentPane().add(new JLabel("Una Fecha")); DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT); JFormattedTextField txtfecha = new JFormattedTextField(df); getContentPane().add(txtfecha); pack(); }
Los ltimos controles que permiten mostrar informacin textual al usuario son JEditorPane y JTextPane. mbos controles permiten cargar informacin desde una URL, sin embargo, mientras JEditorPane puede recibir una cadena en HTML, JTextPane necesita un objeto que le indique el estilo del texto a mostrar. Se aconseja ampliar estos componentes en la pgina oficial de Java. Veamos un ejemplo de su uso.
public miJTextyEditor() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new GridLayout(1,2)); getContentPane().add(new JLabel("JEditorPane")); JEditorPane txte = new JEditorPane("text/html", "<HTML>Texto con formato</HTML>"); getContentPane().add(txte); pack(); }
JEditorPane y JTextPane
AbstractButton
AbstractButton representa la clase base de varios controles Swing. De esta clase heredan directamente JButton, JMenuItem y JToggleButton. Tiene diversos mtodos de gran utilidad muchos de ellos presentes tambin en otras arquitecturas muy conocidas: doClick();; doClick(int p); addActionListener(); setActionCommand(String s);getActionCommand(); setEnabled(boolean b); setSelected(boolean b); setIcon(Icon i); getIcon() setText(String l); getText() setMnemonic(char c); setPressedIcon(Icon i); setDisabledIcon(Icon); getDisabledIcon();
La jerarqua de clases es la siguiente:
31

AbstractButton
JButton
JMenuItem
JToggleButton
JCheckBoxMenuItem
JRadioButtonMenuItem
JCheckBox
JRadioButton
Como en otras ocasiones veremos el uso de cada una de estas clases. El objeto botn de Swing es capaz de mostrar tanto texto como imagen en su contenido. Incluso permite posicionar el texto o la imagen en diferente posicin. Un JButton puede ser activado por el usuario de dos formas diferentes. Una de ellas es pulsndole y otra es usar el mnemnico que tenga asociado el texto. Este mnemnico suele ser un carcter que permite activarse con el teclado. Sin embargo, debemos tener en cuenta que el botn puede estar activado o no. En caso de no estarlo, el L&F se encargar de mostrar en la interfaz esta caracterstica. El control de los eventos sobre un botn se har implementando la interfaz ActionListener, sin embargo, cuando trabajemos con un objeto JCheckBox, implementaremos ItemListener que nos permite saber si el checkox est activado o desactivado. Veamos un ejemplo para comprobar las caractersticas de JButton:
public class Botones extends JFrame { public Botones() { this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new GridLayout(2, 1)); ImageIcon imgico = new ImageIcon(Botones.class.getResource("reglas.gif")); JButton btn1 = new JButton("Boton1",imgico); btn1.setVerticalTextPosition(SwingConstants.TOP); //TOP | BOTTOM | CENTER btn1.setIconTextGap(10); //Distancia entre la imagen y el texto // LEFT | RIGHT |CENTER | LEADDING | TRAILING btn1.setHorizontalTextPosition(SwingConstants.LEFT); btn1.setMnemonic(KeyEvent.VK_B); btn1.setToolTipText("Pincha aqui"); this.getContentPane().add(btn1); JButton btn2 = new JButton("Boton2"); btn2.setMnemonic(KeyEvent.VK_O); btn2.setEnabled(false); getContentPane().add(btn2); pack(); } }
32
JButton
El anterior cdigo generara una imagen como la siguiente:
Es una clase que proporciona funcionalidad para aquellos botones que necesiten dos estados, como por ejemplo JRadioButton y JCheckBox. Esta clase se puede usar con total normalidad, cuando necesitemos mostrar botones con dos estados: Presionado o No Presionado. Se muestra un ejemplo sencillo, con el cambio de interfaz al presionar el botn:
public class Toggle extends JFrame { public Toggle() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); getContentPane().add(new JToggleButton("Hola")); pack(); } }
JToggleButton
Sus apariencias seran las siguientes: Boton sin estar presionado, y Estando Presionado respectivamente.
Proporciona utilidad para introducir botones de seleccin en un JFrame. Se diferencian de un JRadioButton en que permiten seleccionar varias opciones, mientras que JRadioButton slo permiten seleccionar una opcin. Recordemos que para controlar la pulsacin de cada uno de los elementos debemos implementar la interfaz ItemListener. Para activar un elemento usaremos el mtodo setSelected(boolean b). Si quisiramos obtener el estado del objeto, llamaramos al mtodo isSelected().
public class Checks extends JFrame implements ItemListener { public Checks() {
JCheckBox
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new GridLayout(1,1)); JCheckBox chk1 = new JCheckBox("Opcion1"); JCheckBox chk2 = new JCheckBox("Opcion2"); chk1.setMnemonic(KeyEvent.VK_O); getContentPane().add(chk1); getContentPane().add(chk2); chk1.addItemListener(this); chk2.addItemListener(this); pack(); } public void itemStateChanged(ItemEvent e) { JDialog jd = new JDialog(this, "Opciones"); jd.getContentPane().add(new JLabel(e.getItemSelectable().toString())); jd.pack(); jd.setVisible(true); } }
Los JRadioButton o tambin conocidos como OptionButton, son botones en los que por convencin slo se puede seleccionar un elemento a la vez. En Swing, esto se hace, como la clase JRadioButton, pero adems es necesario utilizar la clase ButtonGroup. Esta ltima clase permite controlar la agrupacin de varios objetos JRadioButton. Adems se puede utilizar tambin con la clase JCheckBox. (Realmente se puede utilizar con cualquier clase que herede de AbstractButton). La nica funcionalidad que aporta es que slo permite seleccionar un nico objeto de tipo CheckBox. Al igual que sucede con la clase JCheckBox, si necesitamos controlar la pulsacin de algn, podemos implementar la interfaz ItemListener. En cambio, la funcionalidad que proporciona no es suficiente, y en el caso de los RadioButton debemos implementar la interfaz ActionListener. Veamos un ejemplo sencillo muy similar a otro encontrado en la pgina de Sun, donde se implementan las dos interfaces. Sera interesante probarlas:
public class Radio extends JFrame implements ItemListener, ActionListener { JLabel lbl = null; JRadioButton rd1 = null; JRadioButton rd2 = null; public Radio() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new BorderLayout()); JPanel pan = new JPanel(new GridLayout(1, 1)); lbl = new JLabel(); ButtonGroup bg = new ButtonGroup(); rd1 = new JRadioButton("Opcion1"); rd2 = new JRadioButton("Opcion2"); pan.add(rd1); rd1.setSelected(true);
JRadioButton
pan.add(rd2); bg.add(rd1); bg.add(rd2); getContentPane().add(pan,BorderLayout.LINE_START); rd1.addItemListener(this); rd2.addItemListener(this); rd1.addActionListener(this); rd2.addActionListener(this); pack(); }
public void itemStateChanged(ItemEvent e) { //Descomentar este codigo para ver el resultado funcional if (e.getSource()==rd1) System.out.println(e.getSource().toString()); else System.out.println(e.getSource().toString());*/ } public void actionPerformed(ActionEvent e) { if (e.getSource()==rd1) System.out.println(e.getSource().toString()); else System.out.println(e.getSource().toString()); } }
JCheckBoxMenuItem y JRadioButtonMenuItem
Estas dos clases las veremos junto con las clases de creacin de mens.
Listas
Como en muchas otras arquitecturas, existen varias tipos de listas que se pueden utilizar. En Swing existen dos: JComboBox y JList. La diferencia fundamental entre ambas es la apariencia, la forma que tienen de mostrar la informacin, y la edicin o no de la informacin por parte del usuario. Con este componente de lista, permitimos al usuario elegir un elemento entre varias opciones. Este componente, posee dos tipos de apariencia No Editable.
JComboBox
Editable.
35
Los cuadros de lista, como se vio en el tema de introduccin de Interfaces de usuario son enormemente tiles a la hora de reducir los errores de los usuarios. Los mtodos ms interesantes pueden ser: addItem(Object o); insertItemAt(Object o, int i); Object getItemAt(int i); getSelectedItem(); removeAllItems(); removeItemAt(int i); getItemCount(); setEditable(Boolean b);
Como en otros componentes, veamos como agregar elementos, manejar los eventos y alguna opcin de inters.
public class Listas extends JFrame implements ActionListener, ItemListener { public Listas() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new FlowLayout(FlowLayout.CENTER)); JComboBox cmb = new JComboBox(); //Agregar opciones textuales cmb.addItem("Elemento 1"); cmb.addItem("Elemento 2"); cmb.addItem("Elemento 3"); cmb.addItem("Elemento 4"); //Seleccionar el 2 elemento. Desde 0 a n-1 cmb.setSelectedIndex(1); //Se produce el evento cuando se cambien elementos cmb.addActionListener(this); cmb.addItemListener(this); getContentPane().add(cmb); pack(); } public void actionPerformed(ActionEvent e) { JOptionPane.showMessageDialog(this,"Se ha pulsado el elemento " + ((JComboBox)e.getSource()).getSelectedItem().toString()); } public void itemStateChanged(ItemEvent e) { JOptionPane.showMessageDialog(this,"Se ha cambiado un elemento."); }
36
El ejemplo anterior, representa un JComboBox no editable. A continuacin se muestra el cdigo para generar un Combo editable
public class Listas extends JFrame implements ActionListener, ItemListener { public Listas() { JComboBox cmbe = new JComboBox(); cmbe.setEditable(true); cmbe.addItem("Opcion 1"); } }
Una lista nos permite mostrar al usuario una serie de elementos. Normalmente se mostrarn en una o varias columnas. Cuando la lista no puede mostrar todos los elementos que posee, mostrar al usuario una barra de desplazamiento para poder mostrar el resto de opciones. Para manejar los eventos en un objeto JList podemos implementar la interfazListSelectionListener. Repasemos los mtodos ms interesantes: int getSelectedIndex(); Object getSelectedValue() clearSelection(); boolean isSelectedIndex(int i)
JList
public class Listas extends JFrame implements ListSelectionListener { public Listas() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new FlowLayout(FlowLayout.CENTER)); JList lst = new JList(new Object[]{"Opcion 1","Opcion 2","Opcion 3","Opcion 4", "Opcion 5","Opcion 6", "Opcion 7", "Opcion 8", "Opcion 9"}); lst.setLayoutOrientation(JList.HORIZONTAL_WRAP); //Gestor de Eventos lst.addListSelectionListener(this); getContentPane().add(lst); pack(); } public void valueChanged(ListSelectionEvent e) {
JOptionPane.showMessageDialog(this, ((JList)e.getSource()).getSelectedValue()); } }
El resultado obtenido sera el siguiente:
Como se ve en el ejemplo anterior, la lista de opciones de una lista, se deben incluir en su constructor, y debe ser un array de Object.
Etiquetas. JLabel
Las etiquetas nos permiten mostrar al usuario informacin textual no editable. En general suelen informar al usuario sobre algn campo de texto, o simplemente informan al usuario sobre algo. En Swing usaremos la clase JLabel, el cual nos permite incluir una imagen y un texto. Este texto, puede ser un cdigo en HTML permitiendo de esta manera formatearse. Los mtodos ms usados pueden ser: String getText(); setText(String s); setIcon(Icon i), Icon getIcon();
A continuacin veamos un ejemplo simple para manejar las etiquetas.

public class Etiquetas extends JFrame { public Etiquetas() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); JLabel lbl = new JLabel(); JLabel lbl2 = new JLabel(); JLabel lbl3 = new JLabel(); setLayout(null); lbl.setBounds(10, 10, 100, 15); lbl.setText("Nombre "); lbl.setOpaque(true); lbl.setBackground(Color.red); lbl2.setText("<html>Nombre Formateado</I</html>"); lbl2.setOpaque(true); lbl2.setBounds(10, 25, 190, 15); lbl3.setText("Etiqueta con Imagen");
ImageIcon img = new ImageIcon(Etiquetas.class.getResource("reglas.gif")); lbl3.setIcon(img); lbl3.setBounds(10,40,190,15); getContentPane().add(lbl); getContentPane().add(lbl2); getContentPane().add(lbl3); this.setSize(300, 200); } }
El aspecto que obtendramos sera el siguiente:
Spinners.
Los spinners son parecidos a las listas con la diferencia de que un spinner no despliega el conjunto de opciones que posee. Un clsico spinner es la configuracin del relof de Windows, que divide la hora los minutos y los segundos y nos permite incrementar o reducir el valor. Este control en otros entornos se suele llamar NumericUpDownControl. Spinner utiliza la interfaz SpinnerModel para mostrar los elementos que va a contener. Swing ya posee varias clases que implementan esta interfaz como por ejemplo SpinnerNumberModel, SpinnerDateModel o SpinnerListModel, para mostrar nmeros, fechas o elementos de un array respectivamente. Spinner permite modificar el formato con el que se muestra la informacin mediante las clases JSpinner.NumberEditor y JSpinner.DateEditor. Con el mtodo setEditor podramos establecer el formato concreto. Evidentemente, nosotros tambin podemos crear nuestro propio formateador. Cuando usamos un modelo de tipo SpinnerNumberModel podremos establecer los valores mnimos, mximos e incremento del control. Para controlar el cambio de valor del objeto Spinner, usaremos la interfaz ChangeListener. A continuacin vemos un ejemplo de uso de este componente.
public class NumericUpDown extends JFrame implements ChangeListener { public NumericUpDown() {
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new FlowLayout(FlowLayout.CENTER)); SpinnerListModel sl = new SpinnerListModel(new Object[]{"Opcion1", "Opcion2","Opcion3","Opcion4","Opcion5"}); JSpinner js = new JSpinner(sl); SpinnerNumberModel sn = new SpinnerNumberModel(0, 0, 10, 2); JSpinner jsn = new JSpinner(sn); SpinnerDateModel sd = new SpinnerDateModel( Calendar.getInstance().getTime(),null,null,Calendar.YEAR); JSpinner jsd = new JSpinner(sd); //Cambiamos el editor para que nos muetre la informacin de diferente manera jsd.setEditor(new JSpinner.DateEditor(jsd, "dd/MM/yyyy")); getContentPane().add(js); getContentPane().add(jsn); getContentPane().add(jsd); js.addChangeListener(this); jsn.addChangeListener(this); jsd.addChangeListener(this); pack(); } public void stateChanged(ChangeEvent e) { JOptionPane.showMessageDialog(this, ((JSpinner)e.getSource()).getValue().toString()); } }
Uso de Mens
Los mens proporcionan una manera muy til de proporcionar al usuario una lista de opciones, tanto de operacin como de accin. Los mens, por convencin se sitan en una barra de mens o en un men contextual tambin conocidos como popupmenus Una barra de mens puede contener uno o ms mens o submens que inicialmente son invisibles para el usuario hasta que este realiza alguna accin. Este popupmenu generalmente aparece en la posicin del cursor. La jerarqua de clases es la siguiente:
JComponent
JMenuBar
JPopupMenu
JAbstractButton
JSeparatror
JMenuItem
JMenu
JCheckBoxMenuItem
JRadioButtonMenuItem
40
Como se puede apreciar, los elementos de mens (men tems) son meramente botones puesto que heredan directamente de JActractButton. Este comportamiento es posible porque cuando se activa un men automticamente se muestra un popup men que muestra los elementos. Debemos tener en cuenta que para crear mens es suficiente con conocer la clase JMenuBar, que representa una barra donde se van a localizar los JMenu, JMenu que representa una opcin principal de la barra de mens, y JMenuItem, que representa cada una de las opciones que posee un men. Estas opciones pueden ser JCheckBoxMenuItem y/o JRadioButonMenuItem, a las cuales se las puede agregar una imagen. Por lo tanto, cuando creemos un JMenuBar, debemos aadirle los JMenu que deseemos. A este JMenu, a su vez debemos agregarle los JMenuItem, y por ltimo la barra de mens debemos aadirla al contenedor principal mediante el mtodo setJMenuBar(). Normalmente, y por facilidad, se suelen dividir las opciones que se ofrecen al usuario con un separador. Para ello usamos el mtodo addSeparator() de la clase JMenu. Cuando necesitemos crear una opcin de men que contenga submens, en vez de crear un objeto JMenuItem, debemos crearlo del tipo JMenu, como veremos ms adelante. Con la interfaz ActionListener (el mtodo a implementar es actionPerformed) podemos capturar los eventos lanzados por un objeto JMenu, mientas que si necesitamos controlar el evento de eleccin de un objeto JRadioButtonMenuItem o JCheckBoxMenuItem debemos utilizar la interfaz ItemListener (cuyo mtodo es itemStateChanged). Al igual que sucede con otros componentes, se puede activar una opcin de men con un nemnico. Adicionalmente, los mens implementan un mtodo para incluir lo que Java demonina aceleradores. Estos aceleradores proporcionan otro mtodo de acceso rpido a las opciones de los mens, y dichas opciones aparecen junto al men. Ms adelante se ver un ejemplo completo donde se utilizan. A continuacin se incluye un cdigo que genera un JFrame con un men habitual:
public class unMenu extends JFrame implements ActionListener, ItemListener { JMenuBar barra = null; JMenu mnuArchivo = null; JMenuItem mnuiNuevo = null; JRadioButtonMenuItem mnuiUnRadio = null; JRadioButtonMenuItem mnuiOtroRadio = null; JCheckBoxMenuItem mnuiUnCheck = null; JMenu mnuiUnMenuConSubmenu = null; JMenuItem mnuiUnSubmenu = null; JMenuItem mnuiUnOtroSubmenu = null; public unMenu() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); barra = new JMenuBar(); mnuArchivo = new JMenu("Archivo"); mnuArchivo.setMnemonic(KeyEvent.VK_A); barra.add(mnuArchivo); mnuiNuevo = new JMenuItem("Nuevo");
Creacin de Mens Habituales
mnuiNuevo.addActionListener(this); mnuiNuevo.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A, InputEvent.CTRL_DOWN_MASK)); mnuArchivo.add(mnuiNuevo); mnuArchivo.addSeparator(); mnuiUnRadio = new JRadioButtonMenuItem("Un Radio Button", false); mnuiUnRadio.addItemListener(this); mnuiOtroRadio = new JRadioButtonMenuItem("Otro", new ImageIcon(unMenu.class.getResource("reglas.gif"))); mnuArchivo.add(mnuiUnRadio); mnuArchivo.add(mnuiOtroRadio); mnuiUnCheck = new JCheckBoxMenuItem("Un Check", true); mnuiUnCheck.addItemListener(this); mnuArchivo.add(mnuiUnCheck); mnuiUnMenuConSubmenu = new JMenu("Un Menu con Submenu"); mnuiUnSubmenu = new JMenuItem("Una subopcion"); mnuiUnOtroSubmenu = new JMenuItem("Otro Submenu"); mnuiUnMenuConSubmenu.add(mnuiUnSubmenu); mnuiUnMenuConSubmenu.add(mnuiUnOtroSubmenu); mnuArchivo.add(mnuiUnMenuConSubmenu); this.setJMenuBar(barra); this.setSize(500, 350); } public void actionPerformed(ActionEvent e) { if (e.getSource() == mnuiNuevo) { JOptionPane.showMessageDialog(this, "Nuevo"); } } public void itemStateChanged(ItemEvent e) { if (e.getSource() instanceof JCheckBoxMenuItem) JOptionPane.showMessageDialog(this, ((JCheckBoxMenuItem) e.getSource()).getText()); else if (e.getSource() instanceof JRadioButtonMenuItem) JOptionPane.showMessageDialog(this, ((JRadioButtonMenuItem) e.getSource()).getText()); } }
El resultado que obtenemos es el siguiente:
42
Para poder mostrar un men contextual (popup Menu) debemos registrar un escuchador de evento en aquel componente sobre el cual se debe mostrar el men. Normalmente, el evento a usar suele ser el botn derecho, y para ello implementamos la interfaz MouseListener. Sin embargo depende de la arquitectura. Es decir: si nos encontramos en un sistema Windows, normalmente se muestra el men contextual con la opcin anteriormente indicada, sin embargo, nos podemos encontrar con otro sistema en el que se puede mostrar el men contextual de una forma diferente. Veamos un ejemplo:
public class unMenuContextual extends JFrame implements MouseListener, ActionListener { JPopupMenu pop = null; public unMenuContextual() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new BorderLayout()); JTextArea txt = new JTextArea(); pop = new JPopupMenu(); txt.add(pop); JMenuItem mnui1 = new JMenuItem("Opcion 1"); JMenuItem mnui2 = new JMenuItem("Opcion 12"); pop.add(mnui1); mnui1.addActionListener(this); mnui2.addActionListener(this); pop.add(mnui2); txt.addMouseListener(this); getContentPane().add(txt,BorderLayout.CENTER); } public void mouseClicked(MouseEvent e) { if (e.isPopupTrigger()){ pop.setLocation(getMousePosition().x, getMousePosition().y); pop.setVisible(true); } } public void mousePressed(MouseEvent e) public void mouseReleased(MouseEvent e) public void mouseEntered(MouseEvent e) public void mouseExited(MouseEvent e) { { } { { } } }
Creacin de Mens Contextuales
public void actionPerformed(ActionEvent e) { System.out.println("Algo se ha pulsado"); } }
43
Los Mens en Swing se pueden configurar prcticamente por completo. Se recomienda echar un vistazo a la API de Java para ampliar el conocimiento sobre ellos.
Barras de Botones. JToolBar

JToolBar es un contenedor de varios botones, habitualmente en una fila o columna. JToolBar permite que el usuario mueva en cualquier direccin de la ventana la barra de botones siempre y cuando JToolBar est contenida en un administrador de posicionamiento de tipo BorderLayout, y establezcamos que la barra de botones es flotante con el mtodo setFloteable. Para controlar los eventos de los botones de una JToolBar debemos implementar la interfaz ActionListener. Veamos un ejemplo:
public class BarraBotones extends JFrame implements ActionListener { JButton btn1 ; JButton btn2; JTextArea txt; public BarraBotones() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new BorderLayout(10, 10)); JToolBar barra = new JToolBar("General"); btn1 = new JButton(); btn2 = new JButton(); txt = new JTextArea(); this.setSize(new Dimension(400, 200)); barra.setFloatable(true); btn1.setToolTipText("Izquierda"); btn1.setActionCommand("Izda"); btn1.setIcon(new ImageIcon(BarraBotones.class.getResource("left.jpg"))); btn2.setIcon(new ImageIcon(BarraBotones.class.getResource("right.gif"))); btn2.setToolTipText("Derecha"); btn2.setActionCommand("Drch"); barra.add(btn1); barra.add(btn2); btn1.addActionListener(this); btn2.addActionListener(this); getContentPane().add(barra, BorderLayout.PAGE_START); getContentPane().add(txt, BorderLayout.CENTER); } public void actionPerformed(ActionEvent e) { txt.append("Has pulsado el botn: "); if (e.getActionCommand().equals("Izda")) { txt.append("Izquierda.\r\n"); }
if (e.getActionCommand().equals("Drch")) { txt.append("Derecha.\r\n"); } } }
El JFrame que obtenemos es el siguiente:
El usuario, tal y como se ha comentado anteriormente, puede jugar con la barra de botones, puesto que puede colocarla en cualquier posicin de la ventana e incluso sacarla fuera de ella. A pesar de ello, podemos indicarle la orientacin de la barra de botones a travs del mtodo setOrientation (barra.setOrientation(JToolBar.VERTICAL);). Si establecemos esta propiedad a la barra, obtenemos el siguiente resultado:
JPanel. GroupBox
Los paneles o cajas grupales se utilizan precisamente para agrupar conjunto de componentes o controles. Resultan de gran utilidad para el usuario, puesto que permiten identificar informacin relacionada. En Swing, JPanel es el componente que permite realizar las acciones comentadas anteriormente. JPanel es bastante configurable puesto que nos permite establecer colores de fondo para la agrupacin, as como el pintado de todo el componente. Al igual que los contenedores principales, un JPanel al ser tambin un contenedor, tiene un administrador de posicionamiento. Debido a la sencillez de este componente, vamos a ir directamente al ejemplo:
public class Paneles extends JFrame { public Paneles() { JPanel panSup = new JPanel(); setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setSize(new Dimension(400, 250)); setResizable(false); setLayout(new BorderLayout());
panSup.setLayout(new FlowLayout(FlowLayout.CENTER)); JLabel lbl = new JLabel("Nombre"); JTextField txt = new JTextField(20); panSup.add(lbl); panSup.add(txt);
panSup.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED)); this.add(panSup, BorderLayout.PAGE_START); JPanel pantlfs = new JPanel(); pantlfs.setLayout(new FlowLayout()); JLabel lblt = new JLabel("Telfono"); JTextField txtt = new JTextField(20); pantlfs.add(lblt); pantlfs.add(txtt); pantlfs.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED) ); this.add(pantlfs, BorderLayout.PAGE_END); } }
El resultado sera el siguiente:
Cuadros de Dilogo 3
Un cuadro de dilogo o son ventanas que muestran informacin de cualquier tipo al usuario. Este tipo de informacin suele ser: errores, informacin que debe tener en cuenta, etc., y son especialmente tiles para comunicarnos con el usuario. En Java, la clase que implementa este comportamiento se denomina JOptionPane. Todos los cuadros de dilogo deben pertenecer a un Frame, de tal forma que cuando el Frame se destruye, lo hacen tambin sus Frames. De la misma forma sucede si se minimizan o maximizan. Los cuatros de dilogo por norma general son modales (bloquean la interaccin del usuario obligando a seleccionar alguna opcin en el dilogo). Si no deseamos este comportamiento deberemos utilizar la clase JDialog. Esta clase hereda directamente de la clase Dialog del paquete awt. Posee un contenedor principal, sobre el cual podemos incluir cualquier componente. Nos centraremos en la clase JOptionPane. JOptionPane nos proporciona implementaciones para mostrar diferentes tipos de mensajes al usuario. Nos permite mostrar
3
Se recomienda ampliar la informacin de esta clase, en la pgina web de Java.

46
mensajes con un texto concreto, un ttulo, una imagen, y un grupo de botones de opcin. Por defecto, JOptionPane proporciona una serie de iconos, dependientes del Look & Feel que estemos utilizando. A continuacin se resumen los tipos de mensajes que se pueden mostrar (a travs de mtodos estticos de la clase JOptionPane): showConfirmDialog
Mtodo
showInputDialog
showMessageDialog showOptionDialog
Muestra un mensaje para que el usuario confirme alguna posible accin. La opcin del usuario la recuperamos a travs del valor retornado por el mtodo. Por ejemplo: Est seguro que desea eliminar el archivo? Muestra una ventana de mensaje para que el usuario escriba o selecciona algn elemento. La informacin que ha proporcionado el usuario se obtiene a travs de la devolucin del mtodo como una cadena o un Object (dependiendo del mtodo usado). Por ejemplo: Escriba su nombre Muestra un mensaje de informacin general al usuario. Por ejemplo: La accin solicitada se ha realizado satisfactoriamente. Muestra un mensaje con diferentes opciones al usuario, para que seleccione una de ellas. La opcin del usuario, se obtiene mediante la devolucin del mtodo.
Descripcin
JOptionPane proporciona otro conjunto de mtodos tambin estticos usados cuando se muestren cuadros de dilogo contenidos en JInternalFrames. La API proporciona diferentes parmetros para construir los cuadros de dilogos, segn la sobrecarga que proporcionan los mtodos, son los siguientes: message: El objeto a mostrar. La informacin que se aporta al usuario. messageType: tipo de mensaje a mostrar, siendo posible los siguientes: ERROR_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE, QUESTION_MESSAGE, PLAIN_MESSAGE. optionType: determina las opciones a mostrar en el panel de botones. Las posibles opciones son: DEFAULT_OPTION, YES_NO_OPTION, YES_NO_CANCEL_OPTION, OK_CANCEL_OPTION. icon: El icono a mostrar en el mensaje. options: lista de opciones que se da al usuario (en un JList). initialValue: eleccin inicial que se ofrece al usuario.
Veamos un ejemplo, en el que se incluyen los cuatro tipos de mensajes que se pueden mostrar:
public class Dialogos extends JFrame implements ActionListener { public Dialogos() {
47
JButton btn1 = new JButton("Botn 1"); JButton btn2 = new JButton("Botn 2"); JButton btn3 = new JButton("Botn 3"); JButton btn4 = new JButton("Botn 4"); setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new FlowLayout(FlowLayout.CENTER)); btn1.setActionCommand("Boton1"); btn2.setActionCommand("Boton2"); btn3.setActionCommand("Boton3"); btn4.setActionCommand("Boton4"); btn1.addActionListener(this); btn2.addActionListener(this); btn3.addActionListener(this); btn4.addActionListener(this); getContentPane().add(btn1); getContentPane().add(btn2); getContentPane().add(btn3); getContentPane().add(btn4); pack(); } public void actionPerformed(ActionEvent e) { if (e.getActionCommand().equals("Boton1")) { int v = JOptionPane.showConfirmDialog(this, "Hola", "Titulo", JOptionPane.YES_NO_CANCEL_OPTION,JOptionPane.WARNING_MESSAGE); System.out.println(v); } if (e.getActionCommand().equals("Boton2")) { String s =(String)JOptionPane.showInputDialog(this,"Mensaje","Titulo", JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Uno","Dos"},"Uno"); System.out.println(s); } if (e.getActionCommand().equals("Boton3")) { JOptionPane.showMessageDialog(this, "La accin se ha llevado a cabo", "Titulo", JOptionPane.INFORMATION_MESSAGE, null); } if (e.getActionCommand().equals("Boton4")) { int v = JOptionPane.showOptionDialog(this, "Selecciona uno", "El Titulo", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.ERROR_MESSAGE, null, new String[]{"Uno","Dos"}, null); System.out.println(v); } } }
El resultado de los cuadros de dilogo es el siguiente:

48
Como se ha comentado anteriormente, la clase JDialog nos permite crear nuestros propios cuadros de dilogo. Un ejemplo de su utilizacin sera el siguiente:
JDialog dialogo = new JDialog(this, "Un Mensaje",true); dialogo.getContentPane().add(new JButton("Un Boton")); dialogo.pack(); dialogo.setVisible(true);
Dilogos Personalizados
File Choosers
Los selectores de ficheros proporcionan una interfaz para navegar a travs de un sistema de ficheros, as como elegirlos, etc. La clase que representa este comportamiento se denomina JFileChooser. Esta clase nos permite mostrar una ventana modal que contiene el componente. Esta clase permite adems, el directorio inicial donde se mostrarn los ficheros, as como un filtrado de los mismos (slo ficheros txt, o slo ficheros docx, etc.). Cuando se utilizan estos componentes, el usuario debe permitir el escaneo del contenido del disco, solamente cuando se utiliza JavaWebStart Un JFileChooser se puede mostrar con tres mtodos diferentes: showOpenDialog(Component c). showSaveDialog(Component c) showDialog(Component c, String s).
En los dos primeros mtodos, el componente recibe un parmetro de tipo component que determina el padre del JFileChooser. En el ltimo caso, adems de indicarle el padre del componente, nos permite especificar el contenido del botn de aprobacin. Una vez que el usuario, ha seleccionado un fichero, se pueden dar tres posibles casos: El usuario acepta la seleccin (pulsa sobre el botn de aprobacin)
El usuario cancela la seleccin (pulsa sobre el botn de cancelacin) Se produce un error con el componente modal.
Para todos estos casos, JFileChooser, contienen unas constantes (enteras) que representan estas situaciones. JFileChooser.APPROVE_OPTION JFileChooser.CANCEL_OPTION JFileCHooser.ERROR_OPTION
Cuando queramos recuperar el fichero y/o el directorio usaremos el mtodo getSelectedFile() o getSelectedFiles() en el caso que el usuario pueda seleccionar varios ficheros. Adems podemos usar los mtodos getPath(), isDirectory() o exists(), entre otros, para obtener informacin adicional sobre la seleccin del usuario. Veamos varios ejemplos: Permitir al usuario seleccionar un fichero:
JFileChooser f = new JFileChooser(); //JFileChooser.FILES_ONLY //JFileChooser.DIRECTORIES_ONLY //JFileChooser.FILES_AND_DIRECTORIES f.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES); f.setFileFilter(new FileNameExtensionFilter("Ficheros de Texto", "txt", "dat")); f.setDialogTitle("Selecciona un fichero."); int v = f.showOpenDialog(this); if (v == JFileChooser.APPROVE_OPTION) { File fichero = f.getSelectedFile(); }
La clase FileNameExtensionFilter es una implementacin de la clase abstracta FileFilter. El resultado que obtenemos es el siguiente:
Permitir al usuario guardar un fichero:

JFileChooser f = new JFileChooser(); f.setFileFilter(new FileNameExtensionFilter("Ficheros de Texto", "txt")); f.setDialogTitle("Introduzca el nombre del fichero a guardar"); int v = f.showSaveDialog(this); if (v == JFileChooser.APPROVE_OPTION) { File fichero = f.getSelectedFile(); Docs aux = (Docs) d.getSelectedFrame(); aux.guardarFichero(fichero); }
Y el resultado sera:
Por ltimo, modificar el botn de aprobacin del usuario:

int v = f.showDialog(this, "Abre el fichero");
Obtenemos el mismo comportamiento, pero con la siguiente interfaz (texto del botn de aprobacin, diferente):
51
Interfaces MDI. Internal Frames
Como se vio en la introduccin del tema, en general, existen dos tipos de aplicaciones: SDI y MDI. Esta ltima conocida como interfaz de documento mltiple permite crear ventanas que contienen a otras. Las aplicaciones de gestin suelen tener este tipo de interfaz. Para crear aplicaciones MDI, en Swing es necesario utilizar las clases JInternalFrames y JDesktopPane. Esta ltima clase ser la contenedora de los InternalFrames. Por convencin cuando se utilicen JInternalFrames debemos tener en cuentas las siguientes cuestiones: Siempre debemos establecer el tamao de los JInternalFrames Es conveniente establecer la localizacin de los JInternalFrames Los componentes de in JInternalFrame se aadirn siempre al contenedor principal Los JInternalFrame siempre se aadirn al JDesktopPane Los JInternalFrame se mostrarn con el mtodo setVisible. Los JInternalFrame lanzan eventos de tipo InternalFrameListener
JInternalFrame nos permite adems cambiar su propia interfaz y comportamiento con los siguientes mtodos: isCloseable();setCloseable(boolean b); setResizable(boolean b);isResisable(); setMaximizable(boolean b); setIconifiable(boolean b); show(); toBack(); toFront();
Veamos un ejemplo de implementacin:

public class MDI extends JFrame implements InternalFrameListener { JDesktopPane d = new JDesktopPane(); public MDI() { super("Interfaz MDI"); setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); JInternalFrame frmin = new JInternalFrame("Doc 1"); frmin.addInternalFrameListener(this); frmin.setSize(300, 200); frmin.setVisible(true); frmin.setResizable(true); frmin.setMaximizable(true); d.add(frmin); add(d); this.setExtendedState(JFrame.MAXIMIZED_BOTH); } public void internalFrameOpened(InternalFrameEvent e) System.out.println("Frame Abierto"); } {
52
public void internalFrameClosing(InternalFrameEvent e)
{ } {
public void internalFrameClosed(InternalFrameEvent e) { public void internalFrameIconified(InternalFrameEvent e)
} { } } }
public void internalFrameDeiconified(InternalFrameEvent e) public void internalFrameActivated(InternalFrameEvent e) {
public void internalFrameDeactivated(InternalFrameEvent e) { }
El resultado que obtenemos es similar al siguiente:
JSplitPane
JSplitPane es un componente que permite mostrar dos componentes en una zona concreta de un contenedor, que permite ampliar o reducir el tamao de ambos. Proporciona la utilidad similar a un explorador de Windows, donde la parte izquierda contiene las unidades del equipo y la parte derecha el contenido de cada unidad. La estructura de componentes que podemos crear puede ser la siguiente:
53
JSplitPane puede realizar la divisin de dos maneras: en horizontal o en vertical, que hay que determinar cundo se instancia el objeto as como los contenedores de cada una de las partes divididas. Sin embargo, podemos utilizar los mtodos setXXXComponent para establecer el componente en la izquierda, derecha, parte superior o inferior del componente. Para que JSplitPane funcione correctamente es conveniente establecer el tamao mnimo y el preferido de los componentes. De esta manera JSplitPane sabe cuntos pixeles puede moverse en una direccin u otra. A continuacin se muestran algunos mtodos que pueden resultar de utilidad para JSplitPane: setDividerSize(int): establece el ancho de JSplitPane (anchura/altura del divisor) setOneTouchExpandable(boolean b): determina si el split se podr expandir con un click. Cuando se establece a true, el control muestra unas pequeas flechitas para expandir de golpe los controles. En caso contrario, es una nica barra.
A continuacin se muestra un sencillo ejemplo, as como el resultado que obtendramos:

public class Splitter extends JFrame { public Splitter() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); JSplitPane div = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT); JList lst = new JList(new String[]{"OPcion1","Opcion2","Opcion3", "Opcion4"}); lst.setMinimumSize(new Dimension(180, this.getSize().height)); JLabel lbl = new JLabel("Zona Derecha"); div.setLeftComponent(lst); div.setRightComponent(lbl); div.setDividerLocation(0.7); div.setOneTouchExpandable(true); div.setOpaque(false); getContentPane().add(div); setExtendedState(JFrame.MAXIMIZED_BOTH); } }
54
JSlider
JSlider es un componente que proporciona una especie de barra de valores desplazable. Puede representar una barra de volumen en una aplicacin de reproduccin de flujos de audio, o para aumentar o disminuir el tamao de la letra en un editor de textos. Cuando se instancia un objeto JSlider podemos establecer la orientacin (horizontal o vertical) as como los valores mximos y mnimos que puede desplazarse. Adicionalmente, se puede instanciar el componente con un objeto de tipo BoundedRangeModel (una clase que implementa esta interfaz es DefaultDoundedRangeModel). A continuacin se comentan algunos mtodos de utilidad para este componente: setPaintTicks(boolean b): mtodo para indicarle al componente que dibuje las marcas de valores. setPaintLabels(boolean b):mtodo para indicar al componente, que pinte el rango de valores. Para que ambos mtodos funcionen correctamente, hay que llamar al mtodo setMinorTickSpacing o setMajorTickSpacing. setFont(Font f): establece la fuente usada para mostrar los valore de la barra.
Podemos controlar el cambio de valor del componente JSlider implementando la interfaz ChangeListener. Esta interfaz proporciona el mtodo stateChanged(ChangeEvent e) que debemos proporcionar el cdigo necesario en aquella clase que implemente dicha interfaz. Posteriormente, usaremos el mtodo addChangeListener de la clase JSlider para establecer el escuchador de esos eventos. A continuacin vemos un sencillo ejemplo de implementacin de este componente:
55
public class miSlider extends JFrame implements ChangeListener { JLabel lbl = null; public miSlider() {
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new FlowLayout(FlowLayout.CENTER)); lbl = new JLabel("Valor: "); //Orientacin, Valor mnimo, Valor Mximo, Valor inicial JSlider js = new JSlider(JSlider.HORIZONTAL,0, 20, 0); js.setMinorTickSpacing(5); js.setMajorTickSpacing(5); js.setPaintLabels(true); js.setFont(new Font("Arial", Font.ITALIC, 8)); js.setPaintTicks(true); js.addChangeListener(this); getContentPane().add(lbl); getContentPane().add(js); setSize(300, 200); } public void stateChanged(ChangeEvent e) { lbl.setText("Valor: " + ((JSlider)e.getSource()).getValue()); } }
Cuando la barra de desplazamiento se mueva, mostrar el valor que tiene en ese momento, en el JLabel cuyo contenido inicial es Valor. Nota: Se pueden cambiar los valores que muestra el componente, mediante el mtodo setLabelTable. Para ello hay que proporciona un objeto de tipo Dictionary.
JTabbedPane
JTabbedPane representa un componente de pestaas que permite incluir componentes en cualquiera de ellas. Es muy til cuando necesitamos mostrar mucha informacin al usuario que no es posible mostrar en toda la pantalla.
Puede parecer complicado el funcionamiento de este componente, pero resulta bastante sencillo. Cuando construimos un objeto de este tipo, es necesario indicar la orientacin del componente (JTabbedPane.TOP, JTabbedPane.BOTTOM, JTabbedPane.LEFT, or JTabbedPane.RIGHT), y su comportamiento cuando el componente no pueda mostrar el texto de las pestaas (JTabbedPane.WRAP_TAB_LAYOUT, JTabbedPane.SCROLL_TAB_LAYOUT) Para aadir o eliminar una pestaa usaremos el mtodo addTab o remove respectivamente. Cuando usemos el mtodo addTab en cualquier de sus sobrecargas, podemos establecer, el texto que muestra la pestaa, un icono significativo del contenido, un tooltip para ampliar informacin al usuario y el contenido que se debe mostrar cuando se active la pestaa. Podemos controlar el cambio de una pestaa a otra mediante la interfaz ChangeListener. Sin ms dilacin, veamos un sencillo ejemplo de utilizacin y el resultado que obtenemos.
public class Pestaas extends JFrame implements ChangeListener { public Pestaas() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); JTabbedPane pesta = new JTabbedPane(JTabbedPane.TOP, JTabbedPane.SCROLL_TAB_LAYOUT); pesta.addTab("Pestaa 1", new JLabel("Pestaa 1")); pesta.addTab("Pestaa 2", new JLabel("Pestaa 2")); pesta.addTab("Pestaa 3", null, new JButton("Algo"), "Una pestaa con un botn"); getContentPane().add(pesta); pesta.addChangeListener(this); setSize(210, 150); } public void stateChanged(ChangeEvent e) { } }
57
JTree

Una imagen de lo que puede representar es la siguiente:
Con este componente podemos mostrar una interfaz vertical de tipo jerrquica o arbrea. Proporciona una interfaz similar a un explorador de directorios del sistema Windows.
Cada elemento, que se muestra en una nica fila se denomina nodo que a su vez puede tener otros nodos hijos (tambin llamados ramas). Los nodos pueden estar expandidos o plegados (collapsed). Para la creacin de los nodos, debemos usar una clase que implemente la interfaz TreeNode, como puede ser la clase DefaultMutableTreeNode o DefaultTreeModel. Cuando se crea el objeto JTree es necesario pero no obligatorio indicarle el objeto TreeNode raz, y a partir de este objeto, se indican los hijos de cada uno. Siempre hay que generar la estructura a partir del nodo raz, y una vez que la tengamos generada, crear el JTree con el nodo principal. Al igual que en otros componentes, podemos controlar los eventos del objeto JTree implementando la interfaz TreeSelectionListener, TreeExpansionListener y TreeWillExpandListener. Estas interfaces proporcionan los mtodos void valueChanged(TreeSelectionEvent e); public void treeExpanded(TreeExpansionEvent event); y public void treeCollapsed(TreeExpansionEvent event); public void treeWillExpand(TreeExpansionEvent event) throws ExpandVetoException; y public void treeWillCollapse(TreeExpansionEvent event) throws ExpandVetoException; respectivamente. Se lanza el mtodo de la interfaz TreeSelectionListener cuando se selecciona un nodo diferente. Se lanza los mtodos de TreeExpansionListener cuando se expande o plega un nodo, y finalmente se lanzan los mtodos de TreeWillExpandListener antes de expandir o plegar un nodo. La apariencia de este componente viene determinada por el Look & Feel que se haya establecido. Podemos cambiarle parte de la apariencia a travs de pares clave-valor. Por ejemplo, para cambiar la apariencia de las lneas de referencia de los nodos, podemos hacerlo mediante el mtodo tree.putClientProperty("JTree.lineStyle", "Horizontal"). Los posibles valores son: Horizontal, None, Angled. A continuacin se muestra el cdigo as como el resultado que obtenernos:
public class Arbol extends JFrame implements TreeSelectionListener, TreeExpansionListener, TreeWillExpandListener { public Arbol() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new FlowLayout(FlowLayout.CENTER));
//Instanciamos el raz y le indicamos que puede tener hijos DefaultMutableTreeNode raiz = new DefaultMutableTreeNode("Raz", true); //Agregamos al nodo raz un nuevo hijo raiz.add(new DefaultMutableTreeNode("Hijo 1",true)); //Instanciamos un nuevo nodo DefaultMutableTreeNode hijo2 = new DefaultMutableTreeNode("Hijo 2", true); //Y le agregamos un subnodo hijo2.add(new DefaultMutableTreeNode("Sub Hijo de Hijo 2",false)); //Agregamos el Hijo 2 al nodo raz raiz.add(hijo2); //Agregamos toda la estructura al nodo Raz. JTree arb = new JTree(raiz,true); arb.setEditable(true); arb.putClientProperty("JTree.lineStyle", "Horizonal"); arb.addTreeExpansionListener(this); arb.addTreeSelectionListener(this); arb.addTreeWillExpandListener(this); getContentPane().add(arb); setSize(300, 250); } public void valueChanged(TreeSelectionEvent e) { } public void treeExpanded(TreeExpansionEvent event) { } public void treeCollapsed(TreeExpansionEvent event) { } public void treeWillExpand(TreeExpansionEvent event) throws ExpandVetoException { } public void treeWillCollapse(TreeExpansionEvent event) throws ExpandVetoException { } }
ScrollPanes
Los JScrollPane son componentes que permiten mostrar una vista desplazable de un componente. Resultan muy tiles cuando el tamao de la pantalla es limitado y se necesita mostrar bastante informacin.
El funcionamiento del componente es sencillo, teniendo en cuenta que acta como un contenedor ms, aunque no lo es. Cuando construyamos el objeto, debemos indicarle el componente sobre el cual debe aparece una barra de desplazamiento, y el comportamiento de las barras de desplazamiento: aparecer siempre, nunca, o cuando sea necesario. Estos valores, se corresponden con un conjunto de constantes de la interfaz ScrollPaneConstants que pueden ser:
ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS
Lo nico que debemos tener en cuenta, es que si vamos a agregar a un componente un JScrollPane, debemos agregar al contenedor principal la referencia al objeto JScrollPane. A continuacin se muestra un sencillo ejemplo
public class PanelScroll extends JFrame { public PanelScroll() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); JTextArea txt = new JTextArea(); JScrollPane jsp = new JScrollPane(txt); jsp.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLL BAR_ALWAYS); jsp.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ ALWAYS); jsp.setPreferredSize(new Dimension(250, 180)); getContentPane().add(jsp); this.setSize(400, 350); this.setMinimumSize(new Dimension(300, 300)); } }
Siendo el resultado que obtenemos el siguiente:
60
ToolTips
Un tooltip es un mensaje de informacin que se muestra al usuario en relacin a algn componente que est activo en un contenedor. Es muy til para ampliar informacin sobre lo que hace el componente como por ejemplo un botn. Su uso es muy sencillo.
public class miToolTip extends JFrame implements ActionListener { public miToolTip() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new FlowLayout(FlowLayout.CENTER)); JButton btn = new JButton("Boton"); btn.setToolTipText("Si me pulsas sale un mensaje!"); getContentPane().add(btn); pack(); } public void actionPerformed(ActionEvent e) { JOptionPane.showMessageDialog(this, "Me has pulsado!"); } }
Lo que obtenemos es lo siguiente:
Barras de Progreso
En la generacin de interfaces de usuario, muchas veces es importante informar al usuario de una forma u otra sobre algunas operaciones que pueden llevar un tiempo considerable, o directamente indicarle la situacin del proceso. Esta accin se puede llevar a cabo de muchas maneras: un simple mensaje o a travs de una barra de progreso, como podemos ver en un instalador, o cuando realizamos la copia de un grupo grande de ficheros de un sitio a otro de nuestro ordenador. En Swing, se proporciona este comportamiento a travs de tres clases: JProgressBar: es un componente grfico al que podemos establecerle valores segn una operacin determinada ProgressMonitor: componente no grfico que nos avisa cuando se acaba una operacin ProgressMonitorInputStream: clase asociada a un objeto ProgressMonitor que monitoriza una operacin de Entrada y Salida.
Veremos en este caso la implementacin de JProgressBar. Tanto ProgressMonitor como ProgressMonitorInputStream se ver a posteriori en el tema de concurrencia. A continuacin se comentan algunos mtodos que nos pueden resultar de inters para el funcionamiento del componente: setValue(int i) / getValue(): establece / obtiene el valor actual de la barra setMaximum(int i) / getMaximum(): establece / obtiene el valor mximo de la barra de progreso setMinimum(int i) / getMinimum(): establece / obtiene el valor mnimo de la barra de progreso. setString(String s) /getString(): Establece/obtiene la cadena a mostrar sobre la barra de progreso. setStringPainted(boolean b): establece si la barra de progreso debe mostrar su valor actual (porcentaje) sobre ella misma. setIndeterminate(boolean b): establece una caracterstica a la barra de progreso que se utiliza para indicar al usuario que el fin de la operacin no se sabe exactamente. Digamos, que genera una barra como la carga del sistema Windows.
JProgressBar
A continuacin se muestra un sencillo cdigo, con un botn y una barra de progreso que va aumentando segn se pincha sobre el botn.
public class Barras extends JFrame implements ActionListener { JProgressBar jpb = null; public Barras() { jpb = new JProgressBar(SwingConstants.HORIZONTAL,0, 40); JButton btn1 = new JButton("Aumentar"); btn1.addActionListener(this); setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); jpb.setStringPainted(rootPaneCheckingEnabled); jpb.setIndeterminate(true); setLayout(new FlowLayout(FlowLayout.CENTER)); getContentPane().add(jpb); getContentPane().add(btn1); setSize(450, 300); } public void actionPerformed(ActionEvent e) { if (jpb.getValue()<jpb.getMaximum()) { jpb.setValue(jpb.getValue() + 1); if (jpb.getValue() == jpb.getMaximum()) jpb.setIndeterminate(false); } } }

62
Temporizadores. Timer 4.
Los temporizadores son unos objetos que nos permiten ejecutar un mtodo despus de un periodo de tiempo, sin necesidad que la interaccin del usuario. Se basan en la ejecucin de subprocesos que veremos en temas posteriores. Cuando creemos el objeto temporizador, debemos indicarle el tiempo en milisegundos a partir del cual nos ejecutara un mtodo. Este mtodo ser el implementado por la interfaz ActionListener: es decir: actionPerformed. Los siguientes mtodos pueden resultar de utilidad start()/stop(): inicia o para el temporizador restart(): inicia nuevamente un temporizador parado, cancelando todas las operaciones pendientes de ejecucin setInitialDelay(int s): tiempo en milisegundos de espera antes de iniciar la primera ejecucin del mtodo actionPerformed. setDelay(int s): tiempo en milisegundos que se debe esperar entre ejecuciones sucesivas del mtodo actionPerformed.
A continuacin se muestra un sencillo ejemplo de implementacin de esta clase, que intenta simular la ejecucin de un reloj digital.
public class Temporizadores extends JFrame implements ActionListener { DateFormat df = new SimpleDateFormat("HH:mm:ss"); JLabel lbl = null; public Temporizadores() { setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); setLayout(new FlowLayout(FlowLayout.CENTER)); lbl = new JLabel(); lbl.setFont(new Font("Arial", Font.ITALIC, 28)); lbl.setText(df.format(new Date())); Timer t = new Timer(1000, this); getContentPane().add(lbl); t.setInitialDelay(3000); t.start(); pack();
4
Usar los temporizadores del paquete javax.swing

63
public void actionPerformed(ActionEvent e) { lbl.setText(df.format(new Date())); } }
El resultado que se obtiene es el siguiente:
64

Interfaces de Usuario Con Java

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Interfaces de Usuario Con Java

Hochgeladen von

Copyright:

Verfügbare Formate

Contenido

INTERFACES DE USUARIO CON JAVA

Interfaces de Usuario con Java Swing

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Notas del Documento.

Interfaces de Usuario con Java Swing

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Interfaces de Usuario con Java Swing

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Interfaces de Usuario con Java Swing

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Interfaces de Usuario con Java Swing

El aspecto que mostrara nuestra ventana en un sistema Windows sera el siguiente:

Sin embargo si lo ejecutamos en un sistema BSD, sera:

Interfaces de Usuario con Java Swing

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Interfaces de Usuario con Java Swing

Receptores y gestores de Eventos

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

En esencia, nos estamos refiriendo a lo siguiente:

Interfaces de Usuario con Java Swing

public class otroFrame implements ActionListener { public void actionPerformed(ActionEvent e) { } }

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Interfaces de Usuario con Java Swing

Almacn de clases que capturan eventos

public void actionPerformed(ActionEvent e) { if (e.getSource() == btn1) { } else if (e.getSource() == btn2) { } } }

Interfaces de Usuario con Java Swing

Look And Feel

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Interfaces de Usuario con Java Swing

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Interfaces de Usuario con Java Swing

Propiedades de Look and feel

Interfaces de Usuario con Java Swing

Establecer la configuracin Look and feel

Look and Feels disponibles en el sistema

Solaris, Linux with GTK+ 2.2 or later GTK+

//Establecer una apariencia en concreto UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());

Interfaces de Usuario con Java Swing

Para establecer un tamao al componente haramos lo siguiente:

Una vez que tengamos establecido el tamao, se deber actualizar la interfaz:

El cdigo de la interfaz anterior sera:

Interfaces de Usuario con Java Swing

La siguiente imagen muestra la interfaz con el tamao large y mini.

Interfaces de Usuario con Java Swing

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

La apariencia de los componentes sera la siguiente:

Interfaces de Usuario con Java Swing

Contenedores de alto nivel

A continuacin se muestra una imagen en la que se indica el contenedor y el panel.

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Aadir componentes al Panel Contenedor

Interfaces de Usuario con Java Swing

Aadir una barra de Men

Para aadir una barra de mens se utilizar el mtodo setJMenuBar.

Layouts. Posicionar Componentes.

PAGE_START PAGE_END LINE_START LINE_END CENTER

Interfaces de Usuario con Java Swing

Veamos el ejemplo de posicionamiento de la ventana anterior

Siendo el resultado el siguiente:

Javier Garrido Daz 2 I. T. I. G. Tecnologa de la Programacin Universidad Europea Miguel de Cervantes

Interfaces de Usuario con Java Swing

La interfaz que genera el anterior cdigo es el siguiente: