Interfaces Gráficas En Java

ELT-753 INFORMATICA SUPERIOR I

PROGRAMACION VISUAL CON JAVA

PAQUETES PARA EL DESARROLLO GRAFICO

- java.applet: Para crear applets y clases que las applets utilizan para comunicarse con su contexto.

- java.awt: Para crear interfaces con el usuario, y para dibujar imágenes y gráficos.- javax.swing: Conjunto de componentes gráficos que funcionan igual en todas las

plataformas que java soporta.- javax.accesibility: Da soporte a clases de accesibilidad para personas discapacitadas.- java.beans: Para el desarrollo de JavaBeans.

AWT y Swing

Java provee dos API's con las que podemos trabajar para desarrollar GUIs, la más básica es AWT (Abstract Window Toolkit). Las más desarrolladas se hacen con Swing, las cuales son más identificables ya que todas comienzan con "J", por ejemplo: JButton, JTextField, JTextArea, JPanel y JFrame son clases de Swing.

En Java se pueden desarrollar interfaces gráficas de mayor calidad y vistosidad a través de labiblioteca de clases AWT. Hemos de decir que la estructura básica del AWT se basa en componentes y contenedores. Los contenedores con tienen componentes, y estos últimos no son más que elementos gráficos básicos. Los elementos gráficos más comunes que podemos destacar son los botones, las barras de desplazamiento, etiquetas, listas, cajas de selección, o campos de texto.

La interfaz del programa hacia el usuario que la utiliza es la manera en que el programa coge los datos del usuario y le devuelve los resultados.

Hasta ahora vimos unas interfaces de texto, el caso de la suma de los números en las que los datos se cogían del input estándar con una System.in.read() y los resultados se imprimían en el output estándar con una System.out.print().

Las System.in y out representan una interfaz del programa hacia el exterior, en este caso, hacia el usuario.

Por tanto, la interfaz está compuesta por todos los canales de los que un programa recoge informaciones y hacia las que devuelve unos resultados.Algunos datos de entrada sirven para que cambie sólo el estado del programa, otros, en cambio, dan inmediatamente un output.

INTERFAZ GRAFICA GUI

Llamamos Interfaz Gráfica GUI (Graphical User Interface) al conjunto de componentes gráficos que posibilitan la interacción entre el usuario y la aplicación. Es decir ventanas, botones, combos, listas, cajas de diálogo, campos de texto, etc.

Primero tenemos que diseñar la aplicación, programarla y por último los eventos que se generan a medida que el usuario interactúa con la Interfaz. Los componentes son objetos de las clases que heredan de la clase base componente como Button, List, TextField, TextArea, Label, etc. En una GUI los componentes son contenidos en Contenedores o containers. Un Container es un objeto cuya clase hereda de Container(clase que a su vez es subclase de Component) y tiene la responsabilidad de contener Componentes.

1


Generalmente una GUI se monta sobre un Frame. Esté sera el Container principal que contendrá a los componentes de la Interfaz Gráfica, un Container podría contener a otros containers.

En nuestra explicación de los componentes GUI analizaremos cómo definirlos, cómo inicializarlos, cómo introducirlos en una ventana o en un aplique y, finalmente, cómo gestionar los sucesos.

¿Qué ES UNA APLICACIÓN O VENTANA?

La aplicación a ventanas es el tipo de aplicación que más a menudo utilizamos cuando trabajamos con el ordenador. Por lo tanto veremos cómo se crea una Ventana usando el paquete AWT.

Como siempre creamos una aplicación con el main, como hicimos anteriormente. Sin embargo, la clase que creamos ahora ampliará la clase java.awt.Frame, que representa la ventana completa, incluye el título, los pulsantes de reducción a icono, maximizar y cerrar. La clase Frame tiene varios métodos y constructores que veremos dentro de poco. Ahora vamos a crear nuestra primera ventana con el título Primera Ventana y que no incluye nada. La editamos en Ventana.java.

Ejemplo 1

import java.awt.*;

public class Ventana extends Frame{

public Ventana(){ super("Primera Ventana"); setLocation(100,100); setSize(200,100); show();

}

public static void main(String[] arg){ new Ventana();

System.out.println("he creado la ventana");}

}

Al principio, como para cada aplicación, se invoca el main que crea un nuevo objeto de tipo Ventana. (El main y la ventana podrían estar en dos archivos separados, uno que gestiona el main, y el otro que gestiona la ventana).

En el constructor del objeto ventana se invoca al constructor de la superclase, es decir, del frame, con la cadena "Primera Ventana" (es el título). Luego se invoca el método setLocation que declara la posición del ángulo derecho en la parte que está arriba de la ventana en el

2


escritorio, en este caso <100, 100> (Son la x y la y respectivamente. La x se mide partiendo del lado izquierdo de la pantalla y aumenta a medida que se va hacia la derecha. La y se mide partiendo de la parte superior de la pantalla y aumenta a medida que se va hacia abajo).Después se invoca el método setSize que permite especificar anchura y altura. En nuestro caso, tiene una anchura de 200 y una altura de 100. Finalmente se invoca el método show() y a continuación aparece la ventana en la pantalla.

Las coordinadas de la pantalla no son las coordenadas cartesianas. realmente la y es precisamente opuesta porque aumenta a medida de que se baja y disminuye a medida de que se sube. Éste es un problema que tiene no sólo Java, sino que todos los lenguajes de programación y todas las bibliotecas para la gráfica Raster. Se debe a razones históricas, supongo, debidas a la forma de dibujar los pixel en pantalla a nivel de hardware. Hay que acostumbrarse, pero las primeras veces puede provocar problemas de razonamiento.Intentad redactar y poner en marcha el programa y cuando se ve vuestra primera ventana. Sucesivamente elimina, por turnos, los métodos setLocation, setSize y show, coloca también las ventanas en distintas posiciones y evalua los cambios. En el ejemplo, se ven sucesos que el sistema gestiona automáticamente. Son Ir Resize de la Ventana y la presión de los pulsadores reduce a iconos y maximiza (minimiza), los cuales se gestionan en la clase Frame.En cambio, no se gestiona el suceso cerrar ventana (el pulsador de la x). Si se teclea no ocurre nada y para acabar la puesta en marcha del programa hay que ir al prompt del DOS desde el que empezó la aplicación y teclear CTRL+C (el exit para todos los programas DOS).

Además no es verdad que a una aplicación se puede asociar a una solo ventana. Java es un lenguaje que permite la multiprogramación. Cada ventana es un programa independiente que trabaja contemporáneamente con otros. Por eso puedo crear, para la misma aplicación, más ventanas Frame, como en el ejemplo que ofrecemos a continuación.

Ejemplo 2.

import java.awt.*;

public class Ventanas extends Frame{

public Ventanas(String Nombre, int x, int y){

super(Nombre);

setLocation(x,y);

setSize(200,100);

show();

3


}

public static void main(String[] arg){

System.out.println("Creo 4 ventanas solapadas");

for (int e=1;e<5;e++) new Ventanas("Ventana "+e,10+(e*10), 10+(e*10));

System.out.println("Creo 4 ventanas a cuadros");

for (int e=5;e<9;e++) new Ventanas("Ventana "+e,(e-5)*200, 100+(e-5));

System.out.println("He creado las ocho ventanas");}

}

Las mismas cosas se podían hacer extendiendo la clase JFrame del paquete javax.swing.

import javax.swing.*;

public class VentanaSwing extends JFrame{

public VentanaSwing(){

super("Primera Ventana");

setLocation(100,100);

setSize(200,100);

show();

}

public static void main(String[] arg){new VentanaSwing();

System.out.println("He creado la ventana con Swing");

}

}

Interfaces gráficas con Swing

Swing es una biblioteca de interfaces gráficas de usuario (GUI) para Java.

● Viene incluida con el entorno de desarrollo de Java (JDK).● Extiende a otra librería gráfica más antigua llamada AWT.● Paquetes: javax.swing

4


java.awt java.awt.event

Ventanas● Componentes● Layout Managers● Manejo de eventos● Cuadros de diálogo predefinidos● Dibujo de gráficos

Creación de ventanas

La clase JFrame proporciona operaciones para manipular ventanas.● Constructores:● JFrame()● JFrame(String titulo)● Una vez creado el objeto de ventana, hay que:● Establecer su tamaño.● Establecer la acción de cierre.● Hacerla visible.

EJEMPLO 1

import javax.swing.*;public class VentanaTest {public static void main(String[] args) { JFrame f = new JFrame("Titulo de ventana"); f.setSize(400, 300); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); f.setVisible(true); }}

Acciones de cierre:● JFrame.EXIT_ON_CLOSE: Abandona aplicación.● JFrame.DISPOSE_ON_CLOSE: Libera los recursos asociados a la ventana.● JFrame.DO_NOTHING_ON_CLOSE: No hace nada.● JFrame.HIDE_ON_CLOSE: Cierra la ventana, sin liberar sus recursos.

EJEMPLO 2.

public class MiVentana extends JFrame {public MiVentana() {super("Titulo de ventana");setSize(400, 300);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

5


}}public class VentanaTest {public static void main(String[] args) {MiVentana v = new MiVentana();v.setVisible(true);}}

PONER IMAGEN DE FONDO

Lo primero que debemos hacer es crear un proyecto Java nuevo : File – New – Java Proyect.

Le llamaremos ImangenDeFondo

Una vez creado el proyecto nos situamos sobre él en el PackageExplorer y creamos un nuevo

Package en el que guardaremos las imágenes para nuestros fondos: Pulsando botón derecho

sobre el paquete ImagenDeFondo – New – Package. Le llamaremos Imágenes.

Lo siguiente será crear dentro del proyecto una nueva clase heredada de JPanel.

En esta clase redefinimos el método paintComponent con la intención de poder crear nuestros

propios JPanel personalizados con una imagen de fondo. A esta clase la llamaremos

PanelImagen y su código será el siguiente.

import java.awt.Dimension;

import java.awt.Graphics;

import javax.swing.ImageIcon;

public class PanelImagen extends javax.swing.JPanel {

public PanelImagen(){

6

http://i1.wp.com/bytelchus.com/wp-content/uploads/2013/05/1.png

http://i0.wp.com/bytelchus.com/wp-content/uploads/2013/05/1.2.png



this.setSize(400,280);

}

public void paintComponent (Graphics g){

Dimension tamanio = getSize();

ImageIcon imagenFondo = new ImageIcon(getClass().getResource("/imagenes/Koala.jpg"));

g.drawImage(imagenFondo.getImage(),0,0,tamanio.width, tamanio.height, null);

setOpaque(false);

super.paintComponent(g);

}

}

En esta linea indicamos la ruta en la que se encuentra la imagen dentro de nuestro proyecto:

ImageIcon imagenFondo = new ImageIcon(getClass().getResource(“/imagenes/Koala.jpg”));

Ahora vamos a crear dentro de nuestro proyecto una nueva clase (New – Other – JFrame) en

la que utilizaremos el JPanel que hemos creado para añadir un fondo al JFrame, le llamaremos

JFrameConFondo.

Lo que haremos será crear un objeto de la clase PanelImagen y lo definiremos como fondo del

JFrame.

El código de esta clase será el siguiente:

import java.awt.BorderLayout;

import java.awt.EventQueue;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.border.EmptyBorder;

7



public class JFrameConFondo extends JFrame {

public static void main(String[] args) {

EventQueue.invokeLater(new Runnable() {

public void run() {

try {

JFrameConFondo frame = new JFrameConFondo();

frame.setVisible(true);

} catch (Exception e) {

e.printStackTrace();

}

}

});

}

public JFrameConFondo() {

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

setBounds(100, 100, 450, 300);

PanelImagen p = new PanelImagen();

p.setBorder(new EmptyBorder(5, 5, 5, 5));

p.setLayout(new BorderLayout(0, 0));

setContentPane(p);

}

}

Ahora nuestro JFrame tendrá como fondo un bonito Koala.

8


COMPONENTES DE UNA VENTANA

Componentes de una ventana

JButton

JLabel

JTextField

JCheckBox

JRadioButton

Tras crear uno de estos componentes con new, ha de añadirse al contentPane de la ventana correspondiente mediante su método add.

Añadir componentes

EJEMPLO 3.

import javax.swing.*;import java.awt.event.*;public class Formulario extends JFrame implements ActionListener { JButton boton1; public Formulario() { setLayout( null ) ; boton1=new JButton( "Finalizar" ) ; boton1.setBounds(300,250,100,30); add(boton1); boton1 .addActionListener( this ) ; } public void actionPerformed(ActionEvent e) { if (e.getSource()==boton1) { System.exit(0); } } public static void main(String[] ar) { Formulario formulario1=new Formulario(); formulario1.setBounds(0,0,450,350); formulario1.setVisible(true); }}

9


La mecánica para atrapar el clic del objeto de la clase JButton se hace mediante la implementación de una interface. Una interface es un protocolo que permite la comunicación entre dos clases. Una interface contiene uno o más cabecera de métodos, pero no su implementación. Por ejemplo la interface ActionListener tiene la siguiente estructura:

interface ActionListener {

public void actionPerformed(ActionEvent e) {

}

Luego las clases que implementen la interface ActionListener deberán especificar el algorítmo del método actionPerformed.

Mediante el concepto de interfaces podemos hacer que desde la clase JButton se puede llamar a un método que implementamos en nuestra clase.

Para indicar que una clase implementará una interface lo hacemos en la declaración de la clase con la sintaxis:

public class Formulario extends JFrame implements ActionListener {

Con esto estamos diciendo que nuestra clase implementa la interface ActionListener, luego estamos obligados a codificar el método actionPerformed.

Definimos un objeto de la clase JButton:

JButton boton1;

En el constructor creamos el objeto de la clase JButton y mediante la llamada del método addActionListener le pasamos la referencia del objeto de la clase JButton utilizando la palabra clave this (this almacena la dirección de memoria donde se almacena el objeto de la clase JFrame, luego mediante dicha dirección podemos llamar al método actionPerformed):

public Formulario() { setLayout(null); boton1=new JButton("Finalizar"); boton1.setBounds(300,250,100,30); add(boton1); boton1.addActionListener(this); }

El método actionPerformed (este método de la interface ActionListener debe implementarse obligatoriamente, en caso de no codificarlo o equivocarnos en su nombre aparecerá un mensaje de error en tiempo de compilación de nuestro programa.

10


El método actionPerformed se ejecutará cada vez que hagamos clic sobre el objeto de la clase JButton.

La interface ActionListener y el objeto de la clase ActionEvent que llega como parámetro están definidos en el paquete:

import java.awt.event.*;

Es decir que cada vez que se presiona el botón desde la clase JButton se llama al método actionPerformed y recibe como parámetro un objeto de la clase ActionEvent.

En el método actionPerformed mediante el acceso al método getSource() del objeto que llega como parámetro podemos analizar que botón se presionó:


if (e.getSource()==boton1) {

System.exit(0);

}

}

Si se presionó el boton1 luego el if se verifica verdadero y por lo tanto llamando al método exit de la clase System se finaliza la ejecución del programa.

LAYOUT MANAGERS

Todos los contenedores en java tienen en su interior una clase, de nombre genérico "layout", que es la encargada de distribuir los botones dentro del contenedor. Por ejemplo, la claseFlowLayout se encarga de hacer que los botones vayan todos seguidos de izquierda a derecha, como sería el caso de tu barra de herramientas del navegador. El GridLayout los coloca en forma de matriz, etc.

En Java no es habitual indicar explícitamente la posición de los componentes de la interfaz dentro de la ventana.

● Los layout managers se encargan de colocar los componentes de la interfaz de usuario en la ventana contenedora.

● Especifican la posición y el tamaño de dichos componentes.- FlowLayout- GridLayout- BorderLayout- GridBagLayout

FlowLayout

Acomoda los componentes de izquierda a derecha, hasta que se acaba la pantalla y entonces empieza en el siguiente renglon:● Métodos:● setAligment(int alineacion)● setHgap(int separacion)● setVgap(int separacion)

11


GridLayout

El GridLayout dispone los componentes de un contenedor en una rejilla rectangular. El contenedor se dividirá en rectangulos iguales y en cada uno se colocará uno de los componentes. A la hora de construir este layout debemos especificar el número de filas y columnas que necesitamos para nuestros componentes, para ello usaremos el siguiente constructor GridLayout(int rows, int cols) , además si queremos controlar el espacio que existirá entre los componentes en el contenedor de manera similar a como hicimos con BorderLayout podemos usar este otro: GridLayout(int rows, int cols, int hgap, int vgap).

● GridLayout(int filas, int columnas)● Métodos:

- setHgap(int separacion)- setVgap(int separacion)

EJEMPLO 4.

import java.awt.*;import java.awt.event.*;import javax.swing.*; public class DemoGridLayout extends JFrame implements ActionListener { private JButton botones[]; private final String nombres[] = { "uno", "dos", "tres", "cuatro", "cinco", "seis" }; private boolean alternar = true; private Container contenedor; private GridLayout cuadricula1, cuadricula2; // configurar GUI public DemoGridLayout() { super ( "Demostración de GridLayout" ); // establecer esquemas cuadricula1 = new GridLayout( 2, 3, 10, 10 ); cuadricula2 = new GridLayout( 3, 2 );

// obtener panel de contenido y establecer su esquema contenedor = getContentPane(); contenedor.setLayout( cuadricula1 ); // crear y agregar botones botones = new JButton[ nombres.length ]; for ( int cuenta = 0; cuenta < nombres.length; cuenta++ ) { botones[ cuenta ] = new JButton( nombres [ cuenta ] ) ;

12


botones [ cuenta ].addActionListener( this ) ; botones [ cuenta ].setToolTipText( "Cambia el esquema de GridLayout" ) ; contenedor.add( botones[ cuenta ] ); } setSize( 300, 150 ); setVisible( true ); } // fin del constructor de DemoGridLayout

// manejar eventos de botón, alternando entre los esquemas public void actionPerformed( ActionEvent evento ) { if ( alternar ) contenedor.setLayout( cuadricula2 ); else contenedor.setLayout( cuadricula1 ); alternar = !alternar; // establecer alternar en el valor opuesto contenedor.validate(); } public static void main( String args[] ) { DemoGridLayout aplicacion = new DemoGridLayout(); aplicacion.setDefaultCloseOperation( JFrame. EXIT_ON_CLOSE ) ; } } // fin de la clase DemoGridLayout

BorderLayout

● Arregla los componentes en posiciones CENTER, NORTH, SOUTH, EAST, WEST.● Métodos:● setHgap(int separacion)● setVgap(int separacion)● Al añadir un elemento a la ventana, hay que especificar su colocación:JButton b = new JButton(...);getContentPane().add(b, BorderLayout.EAST)

EJEMPLO 5.

import java.lang.*; import java.awt.*;

13


import java.awt.event.*;

public class Prog4 {

//declaracion, creacion e inicializacion de componentes, objetos y variables

static Frame ventana= new Frame();

static Label l1 = new Label("norte");

static Label l2 = new Label("sur");

static Label l3 = new Label("este");

static Label l4 = new Label("oeste");

static Button b1 = new Button("CENTRO");

// parte principal de programa

public static void main(String[] args)

{ // area de definicion de propiedades de el objeto

ventana.setTitle("mi programa");

ventana.setLayout(new BorderLayout());

ventana.add(l1,BorderLayout.NORTH);

ventana.add(l2,BorderLayout.SOUTH);

ventana.add(l3,BorderLayout.EAST);

ventana.add(l4,BorderLayout.WEST);

ventana.add(b1,BorderLayout.CENTER);

ventana.pack();

ventana.setVisible(true);

//area de asociacion de objeto-eventos

ventana.addWindowListener( new WindowAdapter()

{ public void windowClosing(WindowEvent e){ System.exit(0); }} );

}; // termina main

} // termina clase

14


Interfaces

Manejo de eventos

● Un evento es un suceso que ocurre como consecuencia de la interacción del usuario conla interfaz gráfica.● Pulsación de un botón.● Cambio del contenido en un cuadro de texto.● Deslizamiento de una barra.● Activación de un JCheckBox.● Movimiento de la ventana.

Pulsación de un botón

● La clase JButton tiene un método:● void addActionListener(ActionListener l)● Que especifica el objeto (manejador de evento) que se encargará de tratar el evento de pulsación del botón.● Este objeto ha de interpretar la interfazActionListener (paquete java.awt.event)public interface ActionListener {void actionPerformed(ActionEvent e)}

● Cuando el usuario pulse el botón, se llamará almétodo actionPerformed de todos losmanejadores de eventos que se hayanregistrado.

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

● Métodos de ActionEvent:● public Object getSource()● public int getModifiers()

EJEMPLO 6.

import javax.swing.*;import java.awt.event.*;public class Formulario extends JFrame implements ActionListener { JButton boton1; public Formulario() {

15


setLayout( null ) ; boton1=new JButton( "Finalizar" ) ; boton1.setBounds(300,250,100,30); add(boton1); boton1 .addActionListener( this ) ; } public void actionPerformed(ActionEvent e) { if (e.getSource()==boton1) { System.exit(0); } } public static void main(String[] ar) { Formulario formulario1=new Formulario(); formulario1.setBounds(0,0,450,350); formulario1.setVisible(true); }}

Métodos y constructores

Hay que destacar los métodos y constructores más relevantes que nos permitirán configurar los componentes según nuestras necesidades. -Contenido del botón

16


Ajustes sobre la apariencia del botón

17


Funcionalidad del botón

EJEMPLO 7.

En este ejemplo igual que en los demás se va a crear una pequeña aplicación que nos muestreuna iniciación a como crear el correspondiente componente.Vamos a crear dos objetos JButton y demostramos que soportan el despliegue de objetos Icon. El manejo de eventos se lleva a cabo mediante una sola instancia de la clase interna ManejadorBoton.import java.awt.*;import java.awt.event.*;import javax.swing.*;public class PruebaBoton extends JFrame {private JButton botonSimple, botonElegante;public PruebaBoton(){super ( "Prueba de botones" ); Container c = getContentPane();c.setLayout( new FlowLayout() );// crea los botonesbotonSimple = new JButton( "Boton simple" ) ;//agregamos el boton al panel de contenidoc.add( botonSimple );//creamos dos objetos ImageIcon que representan al//objeto Icon predeterminado y al objeto Icon de//sustitucion para el botonElegante.//los gif se presupone que estan en el mismo//directorio que la aplicación que las utilizaIcon icono1 = new ImageIcon( "icono1.gif" ) ;Icon icono2 = new ImageIcon( "icono2.gif" ) ;//crea el boton con el gif y el texto (texto a la//derecha del icono como predeterminado)botonElegante = new JButton( "Boton elegante" ,icono1) ;//se utiliza el metodo setRollOverIcon heredado de//AbstractButton para especificar la imagen que//aparece cuando el raton se posiciona sobre el botonbotonElegante .setRolloverIcon( icono2 ) ;

18


//agregamos el boton al panel de contenidoc.add( botonElegante );// crea una instancia de la clase interna//anejadorBoton para usarla en el manejo de eventos//de botónManejadorBoton manejador = new ManejadorBoton();botonElegante .addActionListener( manejador ) ;botonSimple .addActionListener( manejador ) ;setSize( 300, 100 );show () ;} // fin del constructor de PruebaBoton

public static void main( String args[] ){PruebaBoton ap = new PruebaBoton();ap.addWindowListener(new WindowAdapter() {public void windowClosing( WindowEvent e ){System.exit( 0 );} // fin del método windowClosing} // fin de la clase interna anónima); // fin de addWindowListener} // fin de main// clase interna para el manejo de eventos de botónprivate class ManejadorBoton implements ActionListener {public void actionPerformed( ActionEvent e ){//mostramos un cuadro de dialogo de mensaje que contiene la//etiqueta del boton que se pulsoJOptionPane. showMessageDialog ( null , "Usted oprimio:" + e.getActionCommand() ) ;}}}

EJERCICIOS

1. Disponer dos objetos de la clase JButton con las etiquetas: "varón" y "mujer", al presionarse mostrar en mensaje del botón presionado.

JCheckBox

El componente JCheckBox nos provee de un simple dispositivo de encedido/apagado con una etiqueta de texto a un lado. Veamos el siguiente ejemplo:

EJEMPLO 1:

Confeccionar un programa que muestre 3 objetos de la clase JCheckBox con etiquetas de tres idiomas. Cuando se lo selecciona mostrar en el título del JFrame todos los JCheckBox seleccionados hasta el momento.

19


import javax.swing.*;import javax.swing.event.*;public class FormularioCheck extends JFrame implements ChangeListener{ private JCheckBox check1,check2,check3; public FormularioCheck() { setLayout( null ) ; check1=new JCheckBox( "Inglés" ) ; check1.setBounds(10,10,150,30); check1 .addChangeListener( this ) ; add(check1);

check2=new JCheckBox( "Francés" ) ; check2.setBounds(10,50,150,30); check2 .addChangeListener( this ) ; add(check2);

check3=new JCheckBox( "Alemán" ) ; check3.setBounds(10,90,150,30); check3 .addChangeListener( this ) ; add(check3); } public void stateChanged(ChangeEvent e){ String cad=""; if (check1 .isSelected() ==true) { cad=cad+"Inglés-"; } if (check2 .isSelected() ==true) { cad=cad+"Francés-"; } if (check3 .isSelected() ==true) { cad=cad+"Alemán-"; } setTitle(cad); }

public static void main(String[] ar) { FormularioCheck formulario1=new FormularioCheck(); formulario1.setBounds(0,0,300,200); formulario1.setVisible(true); } }

Lo primero y más importante que tenemos que notar que para capturar el cambio de estado del JCheckBox hay que implementar la interface ChangeListener que se encuentra en el paquete:

import javax.swing.event.*;

y no en el paquete:import java.awt.event.*

Cuando declaramos la clase JFrame indicamos que implementaremos la interface ChangeListener:public class Formulario extends JFrame implements ChangeListener{

Definimos tres objetos de la clase JCheckBox: private JCheckBox check1,check2,check3;

En el constructor creamos cada uno de los objetos de la clase JCheckBox y llamamos al método addChangeListener indicando quien procesará el evento de cambio de estado:

20


check1=new JCheckBox("Inglés"); check1.setBounds(10,10,150,30); check1.addChangeListener(this); add(check1);

El método que debemos implementar de la interface ChangeListener es: public void stateChanged(ChangeEvent e){

En este mediante tres if verificamos el estado de cada JCheckBox y concatenamos los String con los idiomas seleccionados:

String cad=""; if (check1.isSelected()==true) { cad=cad+"Inglés-"; } if (check2.isSelected()==true) { cad=cad+"Francés-"; } if (check3.isSelected()==true) { cad=cad+"Alemán-"; } setTitle(cad);

La selección o deseleccion de un JCheckBox es enviada a la interface ItemListener. El ItemEvent es enviado conteniendo el método getStatedChange(), el cual regresa ItemEvent.DESELECTED o un ItemEvent.SELECTED, según se el caso.

EJEMPLO 2.Disponer un control JLabel que muestre el siguiente mensaje: "Esta de acuerdo con las normas del servicio?", luego un JCheckBox y finalmente un objeto de tipo JButton desactivo. Cuando se tilde el JCheckBox debemos activar el botón.

import javax.swing.*;import javax.swing.event.*;import java.awt.event.*;public class FormularioCheck2 extends JFrame implements ActionListener, ChangeListener{ private JLabel label1; private JCheckBox check1; private JButton boton1; public FormularioCheck2() { setLayout( null ) ;

label1=new JLabel( "Esta de acuerdo con las normas del servicio?" ) ;

label1.setBounds(10,10,400,30); add(label1); check1=new JCheckBox( "Acepto" ) ; check1.setBounds(10,50,100,30); check1 .addChangeListener( this ) ; add(check1); boton1=new JButton( "Continuar" ) ; boton1.setBounds(10,100,100,30); add(boton1); boton1 .addActionListener( this ) ; boton1 .setEnabled( false ) ; } public void stateChanged(ChangeEvent e) { if (check1 .isSelected() ==true) { boton1 .setEnabled( true ) ; } else {

21


boton1 .setEnabled( false ) ; } }

public void actionPerformed(ActionEvent e) { if (e.getSource()==boton1) { System.exit(0); } } public static void main(String[] ar) { FormularioCheck2 formulario1=new FormularioCheck2(); formulario1.setBounds(0,0,350,200); formulario1.setVisible(true); } }

Importamos los paquetes donde se encuentran las interfaces para captura de eventos de objetos de tipo JButton y JCheckBox:

import javax.swing.event.*;import java.awt.event.*;

También importamos el paquete donde están definidas las clase JFrame, JButton y JCheckBox:import javax.swing.*;

Como debemos implementar dos interfaces las debemos enumerar después de la palabra implements separadas por coma:public class Formulario extends JFrame implements ActionListener, ChangeListener{

Definimos los tres objetos: private JLabel label1; private JCheckBox check1; private JButton boton1;

En el constructor creamos el objeto de tipo JLabel: public Formulario() { setLayout(null); label1=new JLabel("Esta de acuerdo con las normas del servicio?"); label1.setBounds(10,10,400,30); add(label1);

El objeto de tipo JCheckBox: check1=new JCheckBox("Acepto");

22


check1.setBounds(10,50,100,30); check1.addChangeListener(this); add(check1);y también creamos el objeto de tipo JButton y llamando al método setEnabled con un valor false luego el botón aparece desactivo:

boton1=new JButton("Continuar"); boton1.setBounds(10,100,100,30); add(boton1); boton1.addActionListener(this); boton1.setEnabled(false);

Cuando se cambia el estado del control JCheckBox se ejecuta el método stateChanged donde verificamos si está seleccionado procediendo a activar el botón en caso negativo lo desactivamos: public void stateChanged(ChangeEvent e) { if (check1.isSelected()==true) { boton1.setEnabled(true); } else { boton1.setEnabled(false); } }

El método actionPerformed se ejecuta cuando se presiona el objeto de tipo JButton (debe estar activo para poder presionarlo): public void actionPerformed(ActionEvent e) { if (e.getSource()==boton1) { System.exit(0); } }

3.5.1 Métodos y constructores

23


JRadioButton

Los Botones de Radio son grupos de botones en los que, por convención, sólo uno de ellos puede estar seleccionado. Swing soporta botones de radio con las clases JRadioButton y ButtonGroup.

Para poner un botón de radio en un menú, se utiliza la clase JRadioButtonMenuItem. Otras formas de presentar una entre varias opciones son los combo boxes y las listas.

Como JRadioButton desciende de AbstractButton, los botones de radio Swing tienen todas las caracterísitcas de los botones normales.Los métodos de AbstractButton que más se utilizan son setMnemonic, addItemListener, setSelected, y isSelected.

Para cada grupo de botones de radio, se necesita crear un ejemplar de ButtonGroup y añadirle cada uno de los botones de radio. El ButtonGroup tiene cuidado de desactivar la selección anterior cuando el usuario selecciona otro botón del grupo.

Generalmente se debería inicializar un grupo de botones de radio para que uno de ellos esté seleccionado. Sin embargo, la API no fuerza esta regla un grupo de botones de radio puede no tener selección inicial. Una vez que el usuario hace una selección, no existe forma para desactivar todos los botones de nuevo.

Cada vez que el usuario pulsa un botón de radio, (incluso si ya estaba seleccionado), el botón dispara un evento action. También ocurren uno o dos eventos ítem: uno desde el botón que acaba de ser seleccionado, y otro desde el botón que ha perdido la selección (si existía).

Normalmente, las pulsaciones de los botones de radio se manejan utilizando un oyente de action.

Métodos y constructores

- ButtonGroups

- RadioButton

EJEMPLO 1.

Confeccionar un programa que muestre 3 objetos de la clase JRadioButton que permitan configurar el ancho y alto del JFrame.

import javax.swing.*;import javax.swing.event.*;public class FormularioRadio1 extends JFrame implements ChangeListener{ private JRadioButton radio1,radio2,radio3; private ButtonGroup bg; public FormularioRadio1() { setLayout( null ) ; bg=new ButtonGroup() ; radio1=new JRadioButton( "640*480" ) ; radio1.setBounds(10,20,100,30);

24


radio1 .addChangeListener( this ) ; add(radio1); bg .add( radio1 ) ; radio2=new JRadioButton( "800*600" ) ; radio2.setBounds(10,70,100,30); radio2 .addChangeListener( this ) ; add(radio2); bg .add( radio2 ) ; radio3=new JRadioButton( "1024*768" ) ; radio3.setBounds(10,120,100,30); radio3 .addChangeListener( this ) ; add(radio3); bg .add( radio3 ) ; } public void stateChanged(ChangeEvent e) { if (radio1 .isSelected() ) { setSize(640,480); } if (radio2 .isSelected() ) { setSize(800,600); } if (radio3 .isSelected() ) { setSize(1024,768); } }

public static void main(String[] ar) { FormularioRadio1 formulario1=new FormularioRadio1(); formulario1.setBounds(0,0,350,230); formulario1.setVisible(true); } }

Importamos los dos paquetes donde están definidas las clases e interfaces para la captura de eventos:


import javax.swing.event.*;

Heredamos de la clase JFrame e implementamos la interface ChangeListener para capturar el cambio de selección de objeto de tipo JRadioButton:

public class Formulario extends JFrame implements ChangeListener{

Definimos tres objetos de la clase JRadioButton y uno de tipo ButtonGroup:

private JRadioButton radio1,radio2,radio3;

private ButtonGroup bg;

En el constructor creamos primero el objeto de la clase ButtonGroup:

bg=new ButtonGroup();

Creamos seguidamente el objeto de la clase JRadioButton, definimos su ubicación, llamamos al método addChangeListener para informar que objeto capturará el evento y finalmente añadimos el objeto JRadioButton al JFrame y al ButtonGroup:

25


radio1=new JRadioButton("640*480");

radio1.setBounds(10,20,100,30);

radio1.addChangeListener(this);

add(radio1);

bg.add(radio1);

Exactamente hacemos lo mismo con los otros dos JRadioButton:




add(radio2);

bg.add(radio2);




add(radio3);

bg.add(radio3);

En el método stateChanged verificamos cual de los tres JRadioButton está seleccionado y procedemos a redimensionar el JFrame:

public void stateChanged(ChangeEvent e) {

if (radio1.isSelected()) {

setSize(640,480);

}


setSize(800,600);

}


setSize(1024,768);

}

}

JLABEL

26


Los JLabel son textos que podemos colocar en un Frame, pero además de textos podemos colocar imagenes (animadas o no) para darle una buena presentación a nuestra ventana.

La clase JLabel nos permite mostrar básicamente un texto.

Primero para crear un JLabel necesitamos importar la Clase necesaria para eso:

import javax.swing.JLabel;

Ahora por orden y para que se vea bien crearemos un método para cada JLabel que queremos introducir a nuestro frame de manera tal que sea más fácil su ubicación y posterior modificación.

EJEMPLO 1.

Confeccionar una ventana que muestre el nombre de un programa en la parte superior y su número de versión en la parte inferior. No permitir modificar el tamaño de la ventana en tiempo de ejecución.

import javax.swing.*;public class Formulario extends JFrame { private JLabel label1,label2; public Formulario() { setLayout( null ) ; label1=new JLabel( "Sistema de Facturación." ) ; label1.setBounds(10,20,300,30); add(label1); label2=new JLabel( "Vesion 1.0" ) ; label2.setBounds(10,100,100,30); add(label2); } public static void main(String[] ar) { Formulario formulario1=new Formulario(); formulario1.setBounds(0,0,300,200); formulario1.setResizable(false); formulario1.setVisible(true); }}

Importamos el paquete javax.swing donde se encuentran definidas las clase JFrame y JLabel:


Heredamos de la clase de JFrame:

public class Formulario extends JFrame {

Definimos dos atributos de la clase JLabel:

private JLabel label1,label2;

En el constructor creamos las dos JLabel y las ubicamos llamando al método setBounds, no hay que olvidar de llamar al método add que añade la JLabel al JFrame:

27


public Formulario() {

setLayout(null);

label1=new JLabel("Sistema de Facturación.");

label1.setBounds(10,20,300,30);

add(label1);

label2=new JLabel("Vesion 1.0");


add(label2);

}

Por último en la main creamos un objeto de la clase que acabamos de codificar, llamamos al setBounds para ubicar y dar tamaño al JFrame, llamamos al método setResizable pasando el valor false para no permitir modificar el tamaño del JFrame en tiempo de ejecución y finalmente llamamos al método setVisible para que se visualice el JFrame:

public static void main(String[] ar)

{

Formulario formulario1=new Formulario();

formulario1.setBounds(0,0,300,200);

formulario1.setResizable(false);

formulario1.setVisible(true);

}

EJERCICIOS1. Disponer tres objetos de la clase JCheckBox con nombres de navegadores web. Cuando se presione un botón mostrar en el título del JFrame los programas seleccionados.

2. Crear tres objetos de la clase JLabel, ubicarlos uno debajo de otro y mostrar nombres de colores.

JTEXTFIELD (Cuadros de Texto)

Un campo de texto es un control básico que permite al usuario teclear una pequeña cantidad de texto y dispara un evento action cuando el usuario indique que la entrada de texto se ha completado (normalmente pulsando Return). Generalmente se usa la clase JTextField para proporcionar campos de texto.

Si necesitamos proporcionar un password field -- un campo de texto editable que no muestra los caracteres tecleados por el usuario -- utilizaremos la clase JPasswordField. Esta sección explica estos dos campos de texto.

28


Así como podríamos decir que el control JLabel remplaza a la salida estándar System.out.print, el control JTextField cumple la función de la clase Scanner para la entrada de datos.

El control JTextField permite al operador del programa ingresar una cadena de caracteres por teclado.

EJEMPLO 1:

Confeccionar un programa que permita ingresar el nombre de usuario y cuando se presione un botón mostrar el valor ingresado en la barra de títulos del JFrame.


import java.awt.event.*;public class FormularioText1 extends JFrame implements ActionListener{ private JTextField textfield1; private JLabel label1; private JButton boton1; public FormularioText1() { setLayout( null ) ; label1=new JLabel( "Usuario:" ) ; label1.setBounds(10,10,100,30); add(label1); textfield1=new JTextField() ; textfield1.setBounds(120,10,150,20); add(textfield1); boton1=new JButton( "Aceptar" ) ; boton1.setBounds(10,80,100,30); add(boton1); boton1 .addActionListener( this ) ; } public void actionPerformed(ActionEvent e) { if (e.getSource()==boton1) { String cad=textfield1 .getText() ; setTitle(cad); } } public static void main(String[] ar) { FormularioText1 formulario1=new FormularioText1(); formulario1.setBounds(0,0,300,150); formulario1.setVisible(true); }}

Definimos los tres objetos que colaboran con nuestra aplicación:

public class FormularioText1 extends JFrame implements ActionListener{

private JTextField textfield1;

private JLabel label1;

private JButton boton1;

En el constructor creamos los tres objetos y los ubicamos:

public FormularioText1() {

29


setLayout(null);

label1=new JLabel("Usuario:");


add(label1);

textfield1=new JTextField();

textfield1.setBounds(120,10,150,20);

add(textfield1);

boton1=new JButton("Aceptar");

boton1.setBounds(10,80,100,30);

add(boton1);

boton1.addActionListener(this);

}

En el método actionPerformed se verifica si se presionó el objeto JButton, en caso afirmativo extraemos el contenido del control JTextField mediante el método getText:


if (e.getSource()==boton1) {

String cad=textfield1.getText();

setTitle(cad);

}

}

En la variable auxiliar cad almacenamos temporalmente el contenido del JTextField y seguidamente actualizamos el título del control JFrame.

EJEMPLO 2:

Realizar un programa que permita ingresar dos números en controles de tipo JTextField, luego sumar los dos valores ingresados y mostrar la suma en la barra del título del control JFrame.

import javax.swing.*;import java.awt.event.*;public class FormularioSuma extends JFrame implements ActionListener{ private JTextField textfield1,textfield2; private JButton boton1; public FormularioSuma() { setLayout( null ) ; textfield1=new JTextField() ; textfield1.setBounds(10,10,100,30); add(textfield1); textfield2=new JTextField() ; textfield2.setBounds(10,50,100,30); add(textfield2);

30


boton1=new JButton( "Sumar" ) ; boton1.setBounds(10,90,100,30); add(boton1); boton1 .addActionListener( this ) ; } public void actionPerformed(ActionEvent e) { if (e.getSource()==boton1) { String cad1=textfield1 .getText() ; String cad2=textfield2 .getText() ; int x1=Integer.parseInt(cad1); int x2=Integer.parseInt(cad2); int suma=x1+x2; String total=String.valueOf(suma); setTitle(total); } } public static void main(String[] ar) { FormularioSuma formulario1=new FormularioSuma(); formulario1.setBounds(0,0,140,150); formulario1.setVisible(true); }}

Definimos los tres objetos:

public class Formulario extends JFrame implements ActionListener{

private JTextField textfield1,textfield2;

private JButton boton1;

En el método actionPerformed es donde debemos sumar los valores ingresados en los controles de tipo JTextField. Para extraer el contenido de los controles debemos extraerlos con el método getText:

String cad1=textfield1.getText();

String cad2=textfield2.getText();

Como debemos sumar numéricamente los valores ingresados debemos convertir el contenido de las variables cad2 y cad2 a tipo de dato int:

int x1=Integer.parseInt(cad1);


El método parseInt de la clase Integer retorna el contenido de cad1 convertido a int (provoca un error si ingresamos caracteres en el control JTextField en lugar de números)

Una vez que tenemos los dos valores en formato numérico procedemos a sumarlos y almacenar el resultado en otra variable auxiliar:

int suma=x1+x2;

31


Ahora tenemos que mostrar el valor almacenado en suma en la barra de títulos del control JFrame, pero como el método setTitle requiere un String como parámetro debemos convertirlo a tipo String:

String total=String.valueOf(suma);

setTitle(total);

Como veremos de acá en adelante es muy común la necesidad de convertir String a enteros y enteros a String:

De String a int:


De int a String:

String total=String.valueOf(suma);

EJERCICIO

1. Realizar un programa que permita ingresar dos números en controles de tipo JTextField, luego multiplicar los dos valores ingresados y mostrar la suma en la barra del título del control JFrame.

JTEXTAREA

JTextArea es un control para pedir varias líneas de texto, que a diferencia de JTextField, visto

en el artículo anterior, sólo nos permitía ingresar una línea de texto.

El método setText, muestra el texto en el control JTextArea.

Indicar que si deseamos capturar el texto ingresado en un control JTextArea se puede usar el

método getText, igual que para el control JTextField. Se utiliza de la siguiente manera:

String s = jtextarea.getText().

String s = jtexfield.getText().

EJEMPLO 1.

Confeccionar un programa que permita ingresar un mail en un control de tipo JTextField y el

cuerpo del mail en un control de tipo JTextArea.

import javax.swing.*;public class FormularioTextarea extends JFrame{ private JTextField textfield1; private JTextArea textarea1; public FormularioTextarea() { setLayout( null ) ;

32


textfield1=new JTextField() ; textfield1.setBounds(10,10,200,30); add(textfield1); textarea1=new JTextArea() ; textarea1.setBounds(10,50,400,300); add(textarea1); }

public static void main(String[] ar) { FormularioTextarea formulario1=new FormularioTextarea(); formulario1.setBounds(0,0,540,400); formulario1.setVisible(true); }

}

Como vemos crear un control de tipo JTextArea es similar a la creación de controles de tipo

JTextField:

textarea1=new JTextArea(); textarea1.setBounds(10,50,400,300); add(textarea1);

El inconveniente que tiene este control es que si ingresamos más texto que el que puede

visualizar no aparecen las barras de scroll y no podemos ver los caracteres tipeados.

Para salvar el problema anterior debemos crear un objeto de la clase JScrollPane y añadir en

su interior el objeto de la clase JTextArea, luego el programa definitivo es el siguiente:

import javax.swing.*;public class FormularioTextarea2 extends JFrame{ private JTextField textfield1; private JScrollPane scrollpane1; private JTextArea textarea1; public FormularioTextarea2() { setLayout( null ) ; textfield1=new JTextField() ; textfield1.setBounds(10,10,200,30); add(textfield1); textarea1=new JTextArea() ; scrollpane1=new JScrollPane( textarea1 ) ; scrollpane1.setBounds(10,50,400,300); add(scrollpane1); }

public static void main(String[] ar) { FormularioTextarea2 formulario1=new FormularioTextarea2(); formulario1.setBounds(0,0,540,400); formulario1.setVisible(true); }

}

Declaramos los dos objetos:

33


private JScrollPane scrollpane1; private JTextArea textarea1;

Primero creamos el objeto de la clase JTextArea:

textarea1=new JTextArea();

Seguidamente creamos el objeto de la clase JScrollPane y le pasamos como parámetro el

objeto de la clase JTextArea:

scrollpane1=new JScrollPane(textarea1);

Definimos la posición y tamaño del control de tipo JScrollPane (y no del control JTextArea):

scrollpane1.setBounds(10,50,400,300);

Finalmente añadimos el control de tipo JScrollPane al JFrame:

add(scrollpane1);

EJEMPLO 2.Confeccionar un programa que permita ingresar en un control de tipo JTextArea una carta. Luego al presionar un botón mostrar un mensaje si la carta contiene el String "argentina".

import javax.swing.*;import java.awt.event.*;public class FormularioTextarea3 extends JFrame implements ActionListener{ private JScrollPane scrollpane1; private JTextArea textarea1; private JButton boton1; public FormularioTextarea3 () { setLayout(null); textarea1=new JTextArea(); scrollpane1=new JScrollPane(textarea1); scrollpane1.setBounds(10,10,300,200); add(scrollpane1); boton1=new JButton("Verificar"); boton1.setBounds(10,260,100,30); add(boton1); boton1.addActionListener(this); } public void actionPerformed(ActionEvent e) { if (e.getSource()==boton1) { String texto=textarea1.getText(); if (texto.indexOf("argentina")!=-1) { setTitle("Si contiene el texto \"argentina\""); } else { setTitle("No contiene el texto \"argentina\""); } } }

34


public static void main(String[] ar) { FormularioTextarea3 formulario1=new FormularioTextarea3 (); formulario1.setBounds(0,0,400,380); formulario1.setVisible(true); } }

Cuando se presiona el botón se ejecuta el método actionPerformed y procedemos a extraer el contenido del control TextArea a través del método getText: String texto=textarea1.getText();Luego mediante el método indexOf de la clase String verificamos si el String "argentina" está contenido en la variable texto: if (texto.indexOf("argentina")!=-1) { setTitle("Si contiene el texto \"argentina\""); } else { setTitle("No contiene el texto \"argentina\""); }Si queremos introducir una comilla doble dentro de un String de Java debemos antecederle la barra invertida (luego dicho caracter no se lo considera parte del String):setTitle("Si contiene el texto \"argentina\"");

EJERCICIO

1. Confeccionar un programa que permita ingresar en un control de tipo JTextArea un parrafo. Luego al presionar un botón mostrar un mensaje si el parrafo contiene la palabra "electrónica".

JCOMBOBOX

El control JComboBox permite seleccionar un String de una lista. Para inicializar los String que contendrá el JComboBox debemos llamar al método addItem tantas veces como elementos queremos cargar.Un evento muy útil con este control es cuando el operador selecciona un Item de la lista. Para capturar la selección de un item debemos implementar la interface ItemListener que contiene un método llamada itemStateChanged.

EJEMPLO 1:Cargar en un JComboBox los nombres de varios colores. Al seleccionar alguno mostrar en la barra de título del JFrame el String seleccionado.

import javax.swing.*;import java.awt.event.*;public class FormularioCombo1 extends JFrame implements ItemListener{ private JComboBox combo1; public FormularioCombo1 () { setLayout(null); combo1=new JComboBox(); combo1.setBounds(10,10,80,20); add(combo1); combo1.addItem("rojo"); combo1.addItem("vede"); combo1.addItem("azul"); combo1.addItem("amarillo"); combo1.addItem("negro"); combo1.addItemListener(this); }

public void itemStateChanged(ItemEvent e) { if (e.getSource()==combo1) { String seleccionado=(String)combo1.getSelectedItem(); setTitle(seleccionado);

35


} } public static void main(String[] ar) { FormularioCombo1 formulario1=new FormularioCombo1 (); formulario1.setBounds(0,0,200,150); formulario1.setVisible(true); } }

Indicamos a la clase que implementaremos la interface ItemListener:public class Formulario extends JFrame implements ItemListener{Declaramos un objeto de la clase ComboBox: private JComboBox combo1;En el constructor creamos el objeto de la clase JComboBox: combo1=new JComboBox();Posicionamos el control: combo1.setBounds(10,10,80,20);Añadimos el control al JFrame: add(combo1);Añadimos los String al JComboBox: combo1.addItem("rojo"); combo1.addItem("vede"); combo1.addItem("azul"); combo1.addItem("amarillo"); combo1.addItem("negro");Asociamos la clase que capturará el evento de cambio de item (con this indicamos que esta misma clase capturará el evento): combo1.addItemListener(this);El método itemStateChanged que debemos implementar de la interface ItemListener tiene la siguiente sintaxis: public void itemStateChanged(ItemEvent e) { if (e.getSource()==combo1) { String seleccionado=(String)combo1.getSelectedItem(); setTitle(seleccionado); } }Para extraer el contenido del item seleccionado llamamos al método getSelectemItem() el cual retorna un objeto de la clase Object por lo que debemos indicarle que lo transforme en String: String seleccionado=(String)combo1.getSelectedItem();

EJEMPLO 2:

Disponer tres controles de tipo JComboBox con valores entre 0 y 255 (cada uno representa la cantidad de rojo, verde y azul). Luego al presionar un botón pintar el mismo con el color que se genera combinando los valores de los JComboBox.

import javax.swing.*;import java.awt.*;import java.awt.event.*;public class FormularioCombo2 extends JFrame implements ActionListener{ private JLabel label1,label2,label3; private JComboBox combo1,combo2,combo3; private JButton boton1; public FormularioCombo2 () { setLayout(null); label1=new JLabel("Rojo:"); label1.setBounds(10,10,100,30); add(label1);

36


combo1=new JComboBox(); combo1.setBounds(120,10,50,30); for(int f=0;f<=255;f++) { combo1.addItem(String.valueOf(f)); } add(combo1); label2=new JLabel("Verde:"); label2.setBounds(10,50,100,30); add(label2); combo2=new JComboBox(); combo2.setBounds(120,50,50,30); for(int f=0;f<=255;f++) { combo2.addItem(String.valueOf(f)); } add(combo2); label3=new JLabel("Azul:"); label3.setBounds(10,90,100,30); add(label3); combo3=new JComboBox(); combo3.setBounds(120,90,50,30); for(int f=0;f<=255;f++) { combo3.addItem(String.valueOf(f)); } add(combo3); boton1=new JButton("Fijar Color"); boton1.setBounds(10,130,100,30); add(boton1); boton1.addActionListener(this); }

public void actionPerformed(ActionEvent e) { if (e.getSource()==boton1) { String cad1=(String)combo1.getSelectedItem(); String cad2=(String)combo2.getSelectedItem(); String cad3=(String)combo3.getSelectedItem(); int rojo=Integer.parseInt(cad1); int verde=Integer.parseInt(cad2); int azul=Integer.parseInt(cad3); Color color1=new Color(rojo,verde,azul); boton1.setBackground(color1); } } public static void main(String[] ar) { FormularioCombo2 formulario1=new FormularioCombo2 (); formulario1.setBounds(0,0,400,300); formulario1.setVisible(true); } }

Importamos el paquete java.awt ya que el mismo contiene la clase Color:import java.awt.*;Implementaremos la interface ActionListener ya que tenemos que cambiar el color del botón cuando se lo presione y no haremos actividades cuando cambiemos items de los controles JComboBox:public class Formulario extends JFrame implements ActionListener{Definimos los siete objetos requeridos en esta aplicación: private JLabel label1,label2,label3; private JComboBox combo1,combo2,combo3; private JButton boton1;

37


En el constructor creamos los objetos, primero el control label1 de la clase JLabel: label1=new JLabel("Rojo:"); label1.setBounds(10,10,100,30); add(label1);Lo mismo hacemos con el objeto combo1: combo1=new JComboBox(); combo1.setBounds(120,10,50,30);Para añadir los 256 elementos del JComboBox disponemos un for y previa a llamar al método addItem convertimos el entero a String: for(int f=0;f<=255;f++) { combo1.addItem(String.valueOf(f)); } add(combo1);En el método actionPerformed cuando detectamos que se presionó el botón procedemos a extraer los tres item seleccionados: public void actionPerformed(ActionEvent e) { if (e.getSource()==boton1) { String cad1=(String)combo1.getSelectedItem(); String cad2=(String)combo2.getSelectedItem(); String cad3=(String)combo3.getSelectedItem();Los convertimos a entero: int rojo=Integer.parseInt(cad1); int verde=Integer.parseInt(cad2); int azul=Integer.parseInt(cad3);y creamos finalmente un objeto de la clase Color, el constructor de la clase Color requiere que le pasemos tres valores de tipo int: Color color1=new Color(rojo,verde,azul);Para cambiar el color de fondo del control JButton debemos llamar al método setBackground y pasarle el objeto de la clase Color: boton1.setBackground(color1);

EJERCICIO

1. Realizar un control JComboBox de paises. Al presionar un botón mostrar en la barra del título del JFrame el país seleccionado.

JMenuBar, JMenu, JMenuItem

Ahora veremos como crear un menú de opciones y la captura de eventos de los mismos. Cuando necesitamos implementar un menú horizontal en la parte superior de un JFrame requerimos de un objeto de la clase JMenuBar, uno o más objetos de la clase JMenu y por último objetos de la clase JMenuItem.Par la captura de eventos debemos implementar la interface ActionListener y asociarlo a los controles de tipo JMenuItem, el mismo se dispara al presionar con el mouse el JMenuItem.

EJERCICIO 1:

Confeccionaremos un menú de opciones que contenga tres opciones que permita cambiar el color de fondo del JFrame a los colores: rojo, verde y azul.

import javax.swing.*;import java.awt.*;import java.awt.event.*;public class FormularioMenu extends JFrame implements ActionListener{ private JMenuBar mb; private JMenu menu1;

38


private JMenuItem mi1,mi2,mi3; public FormularioMenu () { setLayout(null); mb=new JMenuBar(); setJMenuBar(mb); menu1=new JMenu("Opciones"); mb.add(menu1); mi1=new JMenuItem("Rojo"); mi1.addActionListener(this); menu1.add(mi1); mi2=new JMenuItem("Verde"); mi2.addActionListener(this); menu1.add(mi2); mi3=new JMenuItem("Azul"); mi3.addActionListener(this); menu1.add(mi3); } public void actionPerformed(ActionEvent e) { Container f=this.getContentPane(); if (e.getSource()==mi1) { f.setBackground(new Color(255,0,0)); } if (e.getSource()==mi2) { f.setBackground(new Color(0,255,0)); } if (e.getSource()==mi3) { f.setBackground(new Color(0,0,255)); } } public static void main(String[] ar) { FormularioMenu formulario1=new FormularioMenu (); formulario1.setBounds(10,20,300,200); formulario1.setVisible(true); } }

Importamos el paquete javax.swing ya que en el mismo se encuentran las tres clases JMenuBar, JMenu y JMenuItem:import javax.swing.*;Importamos java.awt donde se encuentra la clase Color:import java.awt.*;Para la captura de eventos mediante la interface ActionListener debemos importar el paquete java.awt.event:import java.awt.event.*;Declaramos la clase Formulario, heredamos de la clase JFrame e indicamos que implementaremos la interface ActionListener:public class Formulario extends JFrame implements ActionListener{Definimos un objeto de la clase JMenuBar (no importa que tan grande sea un menú de opciones solo se necesitará un solo objeto de esta clase): private JMenuBar mb;Definimos un objeto de la clase JMenu (esta clase tiene por objeto desplegar un conjunto de objetos de tipo JMenuItem u otros objetos de tipo JMenu: private JMenu menu1;Definimos tres objetos de la clase JMenuItem (estos son los que disparan eventos cuando el operador los selecciona: private JMenuItem mi1,mi2,mi3;En el constructor creamos primero el objeto de la clase JMenuBar y lo asociamos al JFrame llamando al método setJMenuBar:

39


mb=new JMenuBar(); setJMenuBar(mb);Seguidamente creamos un objeto de la clase JMenu, en el constructor pasamos el String que debe mostrar y asociamos dicho JMenu con el JMenuBar llamando al método add de objeto de tipo JMenuBar (Es decir el objeto de la clase JMenu colabora con la clase JMenuBar): menu1=new JMenu("Opciones"); mb.add(menu1);Ahora comenzamos a crear los objetos de la clase JMenuItem y los añadimos al objeto de la clase JMenu (también mediante la llamada al método addActionListener indicamos al JMenuItem que objeto procesará el clic): mi1=new JMenuItem("Rojo"); mi1.addActionListener(this); menu1.add(mi1);Lo mismo hacemos para los otros dos JMenuItem: mi2=new JMenuItem("Verde"); mi2.addActionListener(this); menu1.add(mi2); mi3=new JMenuItem("Azul"); mi3.addActionListener(this); menu1.add(mi3); En el método actionPerformed primero obtenemos la referencia al panel asociado con el JFrame: public void actionPerformed(ActionEvent e) { Container f=this.getContentPane();Luego mediante if verificamos cual de los tres JMenuItem fue seleccionado y a partir de esto llamamos al método setBackground del objeto de la clase Container): if (e.getSource()==mi1) { f.setBackground(new Color(255,0,0)); } if (e.getSource()==mi2) { f.setBackground(new Color(0,255,0)); } if (e.getSource()==mi3) { f.setBackground(new Color(0,0,255)); } }

EJEMPLO 2:

Confeccionaremos un menú de opciones que contenga además del JMenu de la barra otros dos objetos de la clase JMenu que dependan del primero.Uno debe mostrar dos JMenuItem que permitan modificar el tamaño del JFrame y el segundo también debe mostrar dos JMenuItem que permitan cambiar el color de fondo.JMenuBar JMenu JMenuItemPrograma:

import javax.swing.*;import java.awt.*;import java.awt.event.*;public class FormularioMenu2 extends JFrame implements ActionListener{ private JMenuBar mb; private JMenu menu1,menu2,menu3; private JMenuItem mi1,mi2,mi3,mi4; public FormularioMenu2 () { setLayout(null); mb=new JMenuBar(); setJMenuBar(mb);

40


menu1=new JMenu("Opciones"); mb.add(menu1); menu2=new JMenu("Tamaño de la ventana"); menu1.add(menu2); menu3=new JMenu("Color de fondo"); menu1.add(menu3); mi1=new JMenuItem("640*480"); menu2.add(mi1); mi1.addActionListener(this); mi2=new JMenuItem("1024*768"); menu2.add(mi2); mi2.addActionListener(this); mi3=new JMenuItem("Rojo"); menu3.add(mi3); mi3.addActionListener(this); mi4=new JMenuItem("Verde"); menu3.add(mi4); mi4.addActionListener(this); }

public void actionPerformed(ActionEvent e) { if (e.getSource()==mi1) { setSize(640,480); } if (e.getSource()==mi2) { setSize(1024,768); } if (e.getSource()==mi3) { getContentPane().setBackground(new Color(255,0,0)); } if (e.getSource()==mi4) { getContentPane().setBackground(new Color(0,255,0)); } } public static void main(String[] ar) { FormularioMenu2 formulario1=new FormularioMenu2 (); formulario1.setBounds(0,0,300,200); formulario1.setVisible(true); } }

Definimos un objeto de la clase JMenuBar, 3 objetos de la clase JMenu y finalmente 4 objetos de la clase JMenuItem: private JMenuBar mb; private JMenu menu1,menu2,menu3; private JMenuItem mi1,mi2,mi3,mi4;Es importante notar el orden de creación de los objetos y como los relacionamos unos con otros.Primero creamos el JMenuBar y lo asociamos con el JFrame: mb=new JMenuBar(); setJMenuBar(mb);Creamos el primer JMenu y lo pasamos como parámetro al JMenuBar mediante el método add: menu1=new JMenu("Opciones"); mb.add(menu1);Ahora creamos el segundo objeto de la clase JMenu y lo asociamos con el primer JMenu creado: menu2=new JMenu("Tamaño de la ventana"); menu1.add(menu2);

41


En forma similar creamos el tercer objeto de la clase JMenu y lo asociamos con el primer JMenu creado: menu3=new JMenu("Color de fondo"); menu1.add(menu3);Finalmente comenzamos a crear los objetos de la clase JMenuItem y los dos primeros los asociamos con el segundo JMenu: mi1=new JMenuItem("640*480"); menu2.add(mi1); mi1.addActionListener(this); mi2=new JMenuItem("1024*768"); menu2.add(mi2); mi2.addActionListener(this);También hacemos lo mismo con los otros dos objetos de tipo JMenuItem pero ahora los asociamos con el tercer JMenu: mi3=new JMenuItem("Rojo"); menu3.add(mi3); mi3.addActionListener(this); mi4=new JMenuItem("Verde"); menu3.add(mi4); mi4.addActionListener(this);En el método actionPerformed si se presiona el mi1 procedemos a redimensionar el JFrame llamando al método setSize y le pasamos dos parámetros que representan el nuevo ancho y alto de la ventana: if (e.getSource()==mi1) { setSize(640,480); }De forma similar si se presiona el segundo JMenuItem cambiamos el tamaño de la ventana a 1024 píxeles por 768: if (e.getSource()==mi2) { setSize(1024,768); }Para cambiar de color de forma similar al problema anterior mediante el método getContentPane obtenemos la referencia al objeto de la clase Container y llamamos al método setBackground para fijar un nuevo color de fondo: if (e.getSource()==mi3) { getContentPane().setBackground(new Color(255,0,0)); } if (e.getSource()==mi4) { getContentPane().setBackground(new Color(0,255,0)); }

EJERCICIO

1. Mediante dos controles de tipo JTextField permitir el ingreso de dos números. Crear un menú que contenga una opción que redimensione el JFrame con los valores ingresados por teclado. Finalmente disponer otra opción que finalice el programa (Finalizamos un programa java llamando al método exit de la clase System: System.exit(0))

42

Documents

Interfaces Gráficas En Java