Programacion 2 Jhomara Luzuriaga
1. PROGRAMACIÓN GRÁFICA CON COMPONENTES SWING
Swing es una biblioteca gráfica para Java. Incluye widgets para interfaz gráfica de
usuario. Una interfaz es lo que le permite a un usuario comunicarse con un
programa a través de componentes visuales como cajas de texto, botones,
desplegables, tablas, etc.
1.1. COMPONENTE
Un componente no es más que un objeto que representa un elemento de una
interfaz gráfica y que en su mayoría tienen una representación gráfica. Se puede
dividir en dos tipos:
1. Simples o atómicos: Son los que no están formados por otros componentes:
Ejemplo: Etiquetas, botones, cajas de texto.
2. Contenedores: Son componentes que pueden contener a otros.
Contenedores de Alto Nivel: Son aquellos que brindan un espacio dentro
de la pantalla para todos los elementos de una interfaz gráfica. Ejemplo:
Frames, Applet.
Contenedores intermedios: Permiten agrupar y organizar los
componentes de una interfaz gráfica dentro de un contenedor de alto nivel.
Ejemplo: Paneles
El patrón de desarrollo que utiliza SWING es MVC (Modelo Vista Controlador), que
permite dividir una aplicación en 3 partes:
o Modelo: Datos
o Vista: Interfaz gráfica
o Controlador: Permite manejar las interacciones del usuario con la interfaz
gráfica y a su vez manejar los cambios entre la vista y el modelo.
1.2. JERARQUÍA DE COMPONENTES
Todos los componentes para el diseño de una interfaz gráfica obedecen a una
jerarquía de clases.
La clase principal es java.awt.Component de la cual se heredan componentes
como java.awt.Button, java.awt.Label, etc..., y también se hereda la clase
java.awt.Container que representa a un objeto contenedor. Los componentes
simples derivan de la clase JComponent, mientras los contenedores de la clase
Window.
Programacion 2 Jhomara Luzuriaga
1.3. CONTENEDORES
1.3.1. Clase JFrame
JAVA Frame es el componente, control u objeto principal de una aplicacion visual o
grafica en java.
Para crear un Frame deberemos crear una instancia de JFrame, y si deseamos
modificar algunas propiedades de la ventana debemos crear una clase que
extienda de JFrame.
Ejemplo:
import javax.swing.*;
class Frame extends JFrame {
//el constuctor
public Frame(){
//Este es uno de los métodos que nuestra clase Frame ha
//heredado de JFrame. Pone un título a la ventana
setTitle("Hola!!!");
//método heredado que le da un tamaño a la ventana
setSize(300,200);
setVisible(true);
}
}
Las ventanas JFrame son invisibles por defecto, se debe modificar la propiedad por
defecto de JFrame de manera que nuestra ventana sea visible, para esto se
sobreescribe el método setVisible(true) con el parámetro true.
Container
Panel JComponent Window
Frame
JFrame
Dialog
JDialog
AbstractButton JTextComponent ….. Applet
JButton ….. ….. JTextField JTextArea
Programacion 2 Jhomara Luzuriaga
Algunos métodos de JFrame son:
setResizable(boolean): Permite hacer modificable el tamaño de la ventana
setState(int): Modificar el tamaño de la ventana, recibe como parámetro un valor
entero que corresponde a una constante de JFrame, que puede ser:
JFrame.NORMAL, JFrame.ICONFIED.
setExtendedState(int): Permite ampliar los estados de una ventana.
setLocationRelativeTo(Component): Ubicar un componente en base a un
segundo componente enviado como parámetro. Para ubicar la ventana en el centro
de la pantalla el parámetro deberá ser null.
EJERCICIO:
Crear un proyecto DiseñoVentanas y en una clase ejecutable crear 5 ventanas,
cada una visualizada en un estado diferente (minimizado, maximizado,
max_horizontal, max_vertical, y normal centrado), estableciendo un título en cada
una con el estado de la ventana.
1.3.2. Clase JDialog
JDialog es un Componente que sirve para presentar diálogos que son ventanas
auxiliares que se presentan cuando se registra un evento dentro de un programa,
sirven para prevención o en su defecto se puede utilizar para dar información sobre
algo, los diálogos que JDialog muestra pueden ser modales o no modales, esto
quiere decir que si son modales la ventana del diálogo bloquea las entradas a otras
ventanas, este tipo de diálogos se pueden hacer también con JOptionPane.
Todos los diálogos dependen de un frame, las modificaciones que se le hagan al
frame afectaran a el diálogo, en caso de que el frame sea cerrado, minizado o
maximizado, sus diálogos tendrán el mismo comportamiento
Un JDialog siempre deberá tener un componente Parent del cual se derive, que
debe ser un contenedor de alto nivel y su efecto modal o no, de manera que
cuando se crea una instancia de esta clase se deberá establecer estos parámetros.
Ejemplo:
Frame ventana= new Frame();
JDialog cuadroDialogo= new JDialog(ventana, true);
Programacion 2 Jhomara Luzuriaga
En este caso hemos creado un JDialog cuyo parent es un JFrame ventana. Los
JDialog obedecen un evento, es decir se mostrarán cuando sobre el parent se
realice algún evento que invoque la aparición del JDialog.
1.3.3. Clase JPanel
JPanel es un objeto de los llamados "contenedores". Es así porque sirven para
contener otros objetos.
Una de las ventajas de añadir paneles sobre nuestro frame es que los paneles al
derivar de JComponent poseen el método paintComponent que permite dibujar y
escribir texto sobre el panel de modo sencillo.
Para añadir un JPanel a nuestro frame primero obtenemos uno de los objetos que
forman el frame: el “panel contenedor” (content pane). Para ello invocaremos al
método getContentPane de nuestro JFrame. El objeto que nos devuelve será de
tipo Container:
Container [nombre_del_contentpane] = frame.getContentPane();
A continuación invocamos al método add del Container obtenido para añadir el
panel, pasándole el propio panel al método: [nombre_del_contentpane].add(nombre_del_panel);
Ejemplo:
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
class Frame extends JFrame {
public Frame(){
setTitle("Hola!!!");
setSize(300,200);
//Le pido al Frame su objeto contenedor
Container contentpane = getContentPane();
//Creo un objeto de tipo JPanel
JPanel panel = new JPanel();
//Añado el panel en el objeto contenedor del frame
contentpane.add(panel);
//Pongo el color de fondo del panel de color rojo
panel.setBackground(Color.RED);
}
}
Programacion 2 Jhomara Luzuriaga
Para agregar componentes a un panel se utiliza el método add:
panel.add(new JButton(“Click aquí”));
Si no señalamos la ubicación de los componentes en el panel, éstos se ubican
conforme se vayan añadiendo de manera horizontal, uno después de otro en todo
el ancho de la ventana.
Para visualizar el Frame que hemos creado se añade a la clase el método main
dentro del cual se creará un objeto de nuestra clase Frame. La clase JFrame
implementa la interfaz Runneable, la cual permite ejecutar y visualizar el Frame
hasta que el usuario lo cancele.
public static void main(String[] args) {
new Frame();
}
1.4. ALGUNOS COMPONENTES SIMPLES
Todos los contenedores así como los componentes tienen propiedades que se
pueden modificar mediante los métodos de la clase que corresponden, así como
sus respectivos constructores.
Clase JLabel
Es una etiqueta de texto que podemos colocar al lado de cualquier componente
para darle una indicación al usuario de cuál es la función de dicho componente.
También se puede emplear a modo de título.
JLabel label = new JLabel("1 x 7 = 7");
Clases JTextArea, JTextPane y JTextField
Son componentes básicos del Swing de Java y su función principal es la de
capturar texto ingresado desde teclado por el usuario.
Clase JTextField
Está pensado para obtener texto del usuario, este tecleará en él y cuando pulse
intro podremos disponer del texto que tecleó. Únicamente se puede recoger una
línea de texto.
Programacion 2 Jhomara Luzuriaga
EJEMPLO: public class Frame1 extends JFrame {
public Frame1() {
setTitle("DATOS");
setSize(300, 200);
JLabel lbl1 = new JLabel("Nombre");
JTextField txt1 = new JTextField(18);
JLabel lbl2 = new JLabel("Edad");
JTextField txt2 = new JTextField(10);
Container contentpane = getContentPane();
JPanel panel = new JPanel();
panel.setBackground(Color.CYAN);
panel.add(lbl1);
panel.add(txt1);
panel.add(lbl2);
panel.add(txt2);
contentpane.add(panel);
setVisible(true);
}
}
EJECUCIÓN
Clase JPasswordField
Al igual que los anteriores permite al Usuario ingresar un texto que es reemplazado
por un carácter que oculta lo que se escribe, por ejemplo: *. Se emplea para pedirle
passwords al usuario y evitar que puedan ser leídas por alguien.
Clase JButton
Esta clase nos permite crear botones, cuya acción al pulsar será programado con
el manejo de eventos.
Para crear un botón podemos utilizar los siguientes constructores:
JButton() Crea un botón sin etiqueta
JButton(String label) Crea un botón con una etiqueta de texto
JButton t=new JButton(“Derecha”);
Programacion 2 Jhomara Luzuriaga
EJEMPLO: public Frame2() {
setTitle("DATOS");
setSize(300, 200);
JLabel lbl1 = new JLabel("Nombre");
JTextField txt1 = new JTextField(18);
JLabel lbl2 = new JLabel("Edad");
JTextField txt2 = new JTextField(10);
Container contentpane = getContentPane();
JPanel panel = new JPanel();
panel.add(lbl1);
panel.add(txt1);
panel.add(lbl2);
panel.add(txt2);
panel.add(new JButton("Click aquí"));
contentpane.add(panel);
setVisible(true);
}
EJERCICIO:
Escriba 4 métodos para cambiar el estado de un botón, una etiqueta y un cuadro
de texto:
……………………………………………………………………………………………......
………………………………………………………………………………………………..
………………………………………………………………………………………………..
………………………………………………………………………………………………..
……………………………………………………………………………………………......
………………………………………………………………………………………………..
………………………………………………………………………………………………..
………………………………………………………………………………………………..
……………………………………………………………………………………………......
………………………………………………………………………………………………..
………………………………………………………………………………………………..
………………………………………………………………………………………………..
Programacion 2 Jhomara Luzuriaga
Clase JComboBox
Permite seleccionar un objeto (opción) de una lista que se visualiza al dar click en
la pestaña de este componente.
Los constructores de la clase son:
JComboBox(ComboBoxModel amodel);
Requiere un objeto Modelo para el ComboBox
JComboBox(Object [] items);
Crea un combo, cuyos items corresponderán al arreglo de objetos.
JComboBox(Vector? items);
Crea un combo, cuyos items corresponderán a los elementos del Vector.
EJEMPLO: public class Selector extends JFrame {
public Selector() {
setTitle("Selector!!!");
setSize(300, 200);
String[] opciones = {"Arriba", "Abajo", "Derecha",
"Izquierda", "Todas las direcciones"};
JComboBox cmbLista = new JComboBox(opciones);
Container contentpane = getContentPane();
JPanel panel = new JPanel();
panel.add(cmbLista);
contentpane.add(panel);
setLocationRelativeTo(null);
setVisible(true);
}
}
Clase JCheckbox
Se trata de un componente empleado para tomar información del usuario sobre
cosas del tipo “sí”, “no”.
Dos de los constructores de un JCheckBox son:
o JCheckBox(String) Crea un JCheckBox con etiqueta
Programacion 2 Jhomara Luzuriaga
o JCheckBox(String,boolean) Crea un JCheckBox con etiqueta y aparece
seleccionado
Clase JRadioButton
Dos de los constructores de un JRadioButton son:
o JRadioButton (String) Crea un JRadioButton con etiqueta
o JRadioButton(String,boolean) Crea un JRadioButton con etiqueta y aparece
seleccionado
Para utilizar este componente debe ser añadido a un grupo de manera que permita
seleccionar una sola opción entre las del grupo. Para ello se utiliza el componente
ButtonGroup.
Ejemplo:
ButtonGroup bg= new ButtonGroup();
JRadioButton rb1=new JRadioButton("Radio1");
JRadioButton rb2=new JRadioButton("Radio2");
bg.add(rb1);
bg.add(rb2);
...
panel.add(rb1);
panel.add(rb2);
...
...
Ejercicio:
Crea una clase EjercicioSwing que extienda de JFrame y que contenga los
componentes de la siguiente figura. El tamaño del Frame será de (260 x 250).
Programacion 2 Jhomara Luzuriaga
2. LAYOUT MANAGERS
2.1. Concepto
El layout manager es el encargado de decidir en qué posiciones se renderizarán los
componentes, que tamaño tendrán, que porción del contenedor abarcarán, etc.
Un contenedor es un componente Java que puede contener otros componentes.
Si queremos cambiar el layout manager de un contenedor en un momento dado,
tan sólo tendremos que llamar al método:
contenedor.setLayout(LayoutManager layout);
Si en cualquier momento decidimos encargarnos nosotros mismos de la gestión de
componentes tan sólo tendremos que escribir:
contenedor.setLayout(null);
Cada componente de nuestro interfaz gráfico tiene asignada una coordenada
horizontal, una coordenada vertical, una longitud y una anchura determinadas.
Estos valores serán los que se utilizarán para renderizar el componente en
pantalla.
La clase java.awt.Component nos ofrece una serie de métodos para poder
modificar los valores de los atributos anteriores:
public void setSize(Dimension size);
public void setBounds(Rectangle r);
2.2. Layout null
Muchos deciden no utilizar layouts para ubicar los componentes de la ventana, en
este caso el Layout se establece a Nulll y en el código se decide la posición de
cada botón y qué tamaño ocupa.
contenedor.setLayout(null); // Eliminamos el layout
contenedor.add (boton); // Añadimos el botón
boton.setBounds (10,10,40,20); // Botón en posicion 10,10 con ancho 40
pixels y alto 20
Esto, no es recomendable. Si se expande la ventana los componentes seguirán en
su sitio, no se expandirán con la ventana. Si cambiamos de sistema operativo,
Programacion 2 Jhomara Luzuriaga
resolución de pantalla o fuente de letra, los componentes no se visualizarán
estéticamente bien.
2.3. FlowLayout
Es el que tienen los paneles por defecto. Los objetos se van colocando en filas en
el mismo orden en que se añadieron al contenedor. Cuando se llena una fila se
pasa a la siguiente.
Tiene tres posibles constructores:
FlowLayout();
Crea el layout sin añadirle los componentes.
FlowLayout(FlowLayout.LEFT[RIGTH][CENTER]);
Indica la alineación de los componentes: a la izquierda, derecha o centro.
FlowLayout(FlowLayout.LEFT, gap_horizontal,gap_vertical);
Además de la alineación de los componentes indica un espaciado (gap) entre los
distintos componentes, de tal modo que no aparecen unos junto a otros.
FlowLayout respeta siempre el tamaño preferido de cada componente. Los
componentes de cada fila se encuentran equiespaciados por un espacio de 5
puntos horizontal y verticalmente.
Primero se establece el layout a utilizar, luego se añaden los componentes al
panel.
contenedor.setLayout(new FlowLayout());
contenedor.add(boton);
contenedor.add(textField);
contenedor.add(checkBox);
Ejemplo:
import javax.swing.*;
import java.awt.*;
class TestFlowLayout extends JFrame{
public static void main(String[] args) {
TestFlowLayout frame = new TestFlowLayout ();
Programacion 2 Jhomara Luzuriaga
JPanel panel = new JPanel();
JButton boton1 = new JButton("botón 1");
JButton boton2 = new JButton("Este es el botón 2");
JButton boton3 = new JButton("botón 3");
panel.add(boton1);
panel.add(boton2);
panel.add(boton3);
frame.setContentPane(panel);
frame.setSize(350, 150);
frame.setTitle("Prueba de FlowLayout");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
2.4. BorderLayout
Este layout distribuye los componentes en cinco zonas predeterminadas: son norte
(NORTH), sur (SOUTH), este (EAST), oeste (WEST) y centro (CENTER). Si no
especificamos ninguna región por defecto el componente se inserta en el centro del
contenedor.
Programacion 2 Jhomara Luzuriaga
Posee dos contructores:
BorderLayout();
BorderLayout(int gap_horizontal, int gap_vertical);
El segundo creará el layout dejando los espacios horizontales y verticales entre sus
distintas zonas.
Al momento de añadir componentes se debe especificar en el método add la región
donde queremos añadir el componente:
panel.add(componente_a_añadir, BorderLayout.NORTH);
Ejemplo:
class TestBorderLayout extends JFrame{
public static void main(String[] args) {
TestBorderLayout frame = new TestBorderLayout ();
Container panel = frame.getContentPane();
JButton norte = new JButton("Norte");
JButton sur = new JButton("Sur");
JButton este = new JButton("Este");
JButton oeste = new JButton("Oeste");
JButton centro = new JButton("Centro");
panel.add(norte, BorderLayout.NORTH);
panel.add(sur, BorderLayout.SOUTH);
panel.add(este, BorderLayout.EAST);
panel.add(oeste, BorderLayout.WEST);
panel.add(centro, BorderLayout.CENTER);
frame.setSize(350, 250);
frame.setTitle("Prueba de BorderLayoutLayout");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);}
}
}
2.5. GridLayout
Distribuye los componentes de un contenedor en celdas y se ordenarán en el orden
como sean añadidas, de izquierda a derecha y de arriba hacia abajo.
El GridLayout es adecuado para hacer tableros, calculadoras en que todos los
botones son iguales, etc.
Programacion 2 Jhomara Luzuriaga
Todas las cuadrículas serán del mismo tamaño y crecerán o se harán más
pequeñas hasta ocupar toda el área del contenedor. Hay dos posibles
constructores:
GridLayout(int filas, int columnas);
GridLayout(int columnas, int filas, int gap_horizontal, int
gat_vertical);
Especifica espaciados verticales y horizontales entre las cuadrículas.
Ejemplo:
import javax.swing.*;
import java.awt.*;
class TestGridLayout extends JFrame{
public static void main(String[] args) {
TestGridLayout frame = new TestGridLayout();
Container container = frame.getContentPane();
int X = 3;
int Y = 3;
container.setLayout(new GridLayout(X, Y));
for (int i = 0; i < X; i++) {
for (int j = 0; j < Y; j++) {
container.add(new JButton(i + "x" + j));
}
}
frame.setSize(350, 250);
frame.setTitle("Prueba de BorderLayoutLayout");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
Programacion 2 Jhomara Luzuriaga
2.6. GridBagLayout
El GridBagLayout es de los layouts más versátiles y complejos de usar. Es como el
GridLayout, pone los componentes en forma de matriz (cuadrícula), pero permite
que las celdas y los componentes en ellas tengan tamaños variados. Las celdas se
crean a medida que se agregan los componentes.
Es posible hacer que un componente ocupe varias celdas
Un componente puede expandirse o no con su celda
Si no se expande, puede quedar en el centro de la celda o pegarse a sus
bordes o esquinas.
Las columnas al igual que las filas pueden ensancharse o no al estirar la
ventana y la proporción podemos decidirla
GridBagConstraints es una clase en cuyos atributos se guarda información de
cómo y dónde añadir el componente.
GridBagConstraints.gridx nos dice la posición x del componente, es decir, el
número de columna en la que está el componente, siendo la columna 0 la primera
columna de la izquierda.
GridBagConstraints.gridy nos dice la posición y del componente, es decir, el
número de fila en la que está el componente, siendo la fila 0 la primera fila de la
parte de arriba.
c.gridx=1, c.gridy=0
c.gridx=0, c.gridy=0
c.gridx=0, c.gridy=1
c.gridx=1, c.gridy=1 c.gridx=2, c.gridy=0
Programacion 2 Jhomara Luzuriaga
GridBagConstraints.gridwidth nos dice cuántas celdas en horizontal debe ocupar
el componente. El ancho del componente.
GridBagConstraints.gridheight nos dice cuantas celdas en vertical debe ocupar
el componente. El alto del componente.
Su valor puede ser:
Un número cardinal, en este caso indica exactamente el número de filas o columnas que ocupará el componente.
GridBagConstraints.RELATIVE, indica que el componente ocupará el espacio disponible desde la fila o columna actual hasta la última fila o columna disponibles.
GridBagConstraints.REMAINDER, indica que el componente es el último de la fila actual o columna actual.
Algunas constantes de esta clase son:
Anchor establece la alineación del componente, se utiliza cuando el éste es más
pequeño que el área utilizada: NORTH, SOUTH, EAST, WEAST, NORTHWEST,
SOUTHWEST, NORTHEAST, SOUTHEAST y CENTER.
c.gridwidth=GridBagCostraints.REMAINDER c.gridheigth=GridBagConstraints.RELATIVE
c.gridwidth=GridBagCostraints.REMAINDER c.gridheigth=GridBagConstraints.REMAINDER
c.gridwidth=1 c.gridheigth=1
c.gridwidth=GridBagCostraints.RELATIVE c.gridheigth=1
c.gridwidth=GridBagCostraints.REMAINDER c.gridheigth=1
c.gridwidth=GridBagCostraints.RELATIVE c.gridheigth=GridBagConstraints.RELATIVE
Programacion 2 Jhomara Luzuriaga
Fill establece el relleno de la celda: HORIZONTAL, VERTICAL, BOTH, NONE
En este caso las celdas ocupan todo el contenedor, pero eso es debido a que se ha utilizado los atributos weightx y weighty. weightx y weighty
Los atributos weightx y weighty especifican el porcentaje de espacio libre que ocupará una celda determinada. En el ejemplo anterior si no utilizamos estos atributos tendríamos:
Programacion 2 Jhomara Luzuriaga
Este espacio libre (flechas verdes) se dividirá entre todas las celdas que especifiquen valores dentro de los atributos weightx y weighty. La forma de especificar el espacio que quiere ocupar cada componente es mediante un número entre 0.0 y 1.0. Este número representa al porcentaje de espacio libre que ocupará cada celda.
Insets
El atributo insets es un objeto de la clase java.awt.Insets cuyo constructor es: Insets(int top, int left, int bottom, int right)
Programacion 2 Jhomara Luzuriaga
Los parámetros del constructor especifican el espacio que se dejará de márgen. Veamos un ejemplo:
Ejemplo:
Frame que distribuye los siguientes componentes:
public class TestGridBagLayout extends JFrame{
public static void main(String[] args) {
TestGridBagLayout f=new TestGridBagLayout();
Container container = f.getContentPane();
container.setLayout(new GridBagLayout());
((JPanel) container).setBorder(
BorderFactory.createTitledBorder("Entrada al sistema"));
GridBagConstraints c = new GridBagConstraints();
c.weightx = 0.4;
c.weighty = 1.0;
c.gridwidth = GridBagConstraints.RELATIVE;
c.gridheight = GridBagConstraints.RELATIVE;
c.fill = GridBagConstraints.BOTH;
c.anchor = GridBagConstraints.WEST;
c.insets = new Insets(2, 5, 2, 0);
container.add(new JLabel("Usuario"), c);
//Se debe definir los parámetros para cada uno de los componentes. c.gridwidth = GridBagConstraints.REMAINDER;
c.gridheight = GridBagConstraints.RELATIVE;
Programacion 2 Jhomara Luzuriaga
c.weightx = 1.0;
c.insets = new Insets(2, 0, 2, 5);
container.add(new JTextField(), c);
c.gridwidth = GridBagConstraints.RELATIVE;
c.gridheight = GridBagConstraints.REMAINDER;
c.weightx = 0.4;
c.insets = new Insets(2, 5, 2, 0);
container.add(new JLabel("Contraseña"), c);
c.gridwidth = GridBagConstraints.REMAINDER;
c.gridheight = GridBagConstraints.REMAINDER;
c.weightx = 1.0;
c.insets = new Insets(2, 0, 2, 5);
container.add(new JTextField(), c);
f.setSize(220, 110);
f.setTitle("Login");
f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Resultado:
2.7. BoxLayout
Este layout manager es uno de los más sencillos y de los más útiles. Aquí los componentes son agrupados horizontal o verticalmente dentro del contenedor que los contiene. Los componentes no se solapan de ningún modo. La anidación de paneles utilizando este layout manager nos puede permitir crear interfaces muy complejos como nos permite GridBagLayout pero a costa de la creación de objetos pesados como son paneles. El constructor de BoxLayout es muy simple: public BoxLayout(Container objetivo, int eje);
Donde el parámetro entero eje puede tomar los valores: X_AXIS, los componentes se organizan de izquierda a derecha y en horizontal. Y_AXIS, los componentes se organizan de arriba a abajo y en vertical. LINE_AXIS, los componentes se organizan como si estuviesen en una línea.
Para ello se tiene en cuenta la propiedad ComponentOrientation del contenedor. Si esta propiedad es horizontal entonces los componentes se organizarán
Programacion 2 Jhomara Luzuriaga
horizontalmente y además según su valor lo harán de izquierda a derecha o de derecha a izquierda. En otro caso se organizarán verticalmente de arriba a abajo.
PAGE_AXIS, los componentes se organizan como si estuvieran en una página. Para ello se tiene en cuenta la propiedad ComponentOrientation del contenedor.
Los componentes se organizan en el orden en el que se añaden al contenedor. En el caso de organización horizontal, BoxLayout intentará que todos los componentes del contenedor tengan la misma altura, siendo esta la máxima de los elementos del contenedor. En caso de que no sea posible, BoxLayout intentará alinearlos a todos horizontalmente de modo que sus centros coincidan en una línea horizontal imaginaria que los atraviese, de manera similar, si la organización es vertical. A menudo, en lugar de utilizar BoxLayout directamente, se utiliza la clase Box que es un contenedor ligero que tiene como layout manager un BoxLayout y que ofrece métodos que hacen que su manejo sea muy sencillo. EJEMPLO: import java.awt.*;
import javax.swing.*;
public class TestBoxLayout extends JFrame {
public static void main(String[] args) {
TestBoxLayout f = new TestBoxLayout();
Container container = f.getContentPane();
container.setLayout(new BoxLayout(container,
BoxLayout.X_AXIS));
((JPanel) container).setBorder(
BorderFactory.createTitledBorder("Demo BoxLayout"));
JPanel panel1 = new JPanel();
panel1.setBorder(BorderFactory.createTitledBorder("Panel1"));
JPanel panel2 = new JPanel();
panel2.setBorder(BorderFactory.createTitledBorder("Panel2"));
panel1.setLayout(new BoxLayout(panel1, BoxLayout.Y_AXIS));
panel2.setLayout(new BoxLayout(panel2, BoxLayout.Y_AXIS));
for (int i = 0; i < 3; i++) {
panel1.add(new JButton("Botón número " + i));
panel2.add(new JButton("Botón número " + i));
}
container.add(panel1);
container.add(panel2);
f.setSize(285, 300);
f.setTitle("Demo BoxLayout");
f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Programacion 2 Jhomara Luzuriaga
2.8. SpringLayout
Este layout manager está únicamente disponible a partir de la versión 1.4 del JDK. SpringLayout define los componentes que estarán dentro del interfaz y la relación entre estos componentes, es decir, el espacio que habrá entre ellos. SpringLayout intentará respetar siempre que pueda el tamaño preferido de los componentes. El espacio entre los componentes se define utilizando objetos Spring. Cada objeto Spring tiene cuatro propiedades, sus tamaños máximo, mínimo y preferido junto con su tamaño actual. (x, y, width, height) Todos estos objetos Spring se acumulan formando un conjunto de restricciones que estarán en un objeto de tipo SpringLayout.Constraints. Para crear un objeto Spring: Spring.constant(min, pref, max); Spring.constant(int valor); El método para ubicar un componente aplicando constraint tespecto de otro: putConstraint(borde, componente, constraint, borde, componenteRelativo);
Programacion 2 Jhomara Luzuriaga
Ejemplo: public class TestSpringLayout extends JFrame{
public static void main(String[] args) {
TestSpringLayout f=new TestSpringLayout();
SpringLayout sl=new SpringLayout();
Container container = f.getContentPane();
container.setLayout(sl);
((JPanel)container).setBorder(BorderFactory.createTitledBorder(
"Entrada al sistema"));
JLabel lblUsuario =new JLabel("Usuario");
JLabel lblContraseña=new JLabel("Contraseña");
JTextField txtUsuario=new JTextField(10);
JTextField txtContraseña=new JTextField(10);
container.add(lblUsuario);
container.add(txtUsuario);
container.add(lblContraseña);
container.add(txtContraseña);
sl.putConstraint(SpringLayout.WEST, lblUsuario,
Spring.constant(30),SpringLayout.WEST,container);
sl.putConstraint(SpringLayout.NORTH, lblUsuario,
Spring.constant(20),SpringLayout.NORTH,container);
sl.putConstraint(SpringLayout.WEST,txtUsuario,
Spring.constant(35),SpringLayout.EAST,lblUsuario);
sl.putConstraint(SpringLayout.NORTH, txtUsuario,
Spring.constant(20),SpringLayout.NORTH,container);
sl.putConstraint(SpringLayout.WEST, lblContraseña,
Spring.constant(30),SpringLayout.WEST,container);
sl.putConstraint(SpringLayout.NORTH, lblContraseña,
Spring.constant(25),SpringLayout.NORTH,lblUsuario);
sl.putConstraint(SpringLayout.WEST,txtContraseña,
Spring.constant(15),SpringLayout.EAST,lblContraseña);
sl.putConstraint(SpringLayout.NORTH, txtContraseña,
Spring.constant(25),SpringLayout.NORTH,txtUsuario);
f.setSize(250, 150);
f.setTitle("Login");
f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Programacion 2 Jhomara Luzuriaga
EJERCICIO:
Diseñe la siguiente pantalla utilizando el Layout más indicado para la ubicación de
los componentes en el Frame
Programacion 2 Jhomara Luzuriaga
3. ALGUNOS COMPONENTES COMPLEJOS
3.1. Componentes contenedores de otros.
Clase JMenuBar
Es una barra de menús, en ella se pueden añadir los siguientes componentes:
Clase JMenu: Es una opción de la cual se pueden desplegar mas opciones.
Clase JMenuItem: Es una opción final (no desplega mas opciones)
EJEMPLO:
public class VentanaMenu extends JFrame{
public JMenuBar barraMenu=new JMenuBar();
public VentanaMenu(){
super("Test Menu");
setSize(300,200);
agregarComponentes();
}
public void agregarComponentes(){
JMenu mnArchivo=new JMenu("Archivo");
mnArchivo.add(new JMenuItem("Nuevo"));
mnArchivo.add(new JMenuItem("Guardar",new
ImageIcon(getClass().getResource("zip.gif"))));
mnArchivo.add(new JMenuItem("Abrir"));
mnArchivo.add(new JMenuItem("Cerrar"));
barraMenu.add(mnArchivo);
JMenu mnEditar=new JMenu("Editar");
JMenu mnAyuda=new JMenu("Ayuda");
barraMenu.add(mnEditar);
barraMenu.add(mnAyuda);
BorderLayout bl=new BorderLayout();
this.getContentPane().setLayout(bl);
this.getContentPane().add(barraMenu,BorderLayout.NORTH);
}
public static void main(String[] args) {
new VentanaMenu().setVisible(true);
}
JMenu
JMenuItem
JMenuBar
Programacion 2 Jhomara Luzuriaga
}
RESULTADO:
Ejercicio:
Modifique la clase anterior para:
Agregar al Menu Archivo el menu Guardar Como y a éste los ítems: Imagen,
Texto, Articulo Completo.
Agregar en el Menu Editar los ítems: Deshacer, Rehacer, Seleccionar Todo,
Buscar.
Agregar una imagen en los Menus de la barra principal.
Clase JScrollPane
Es un panel que permite visualizar un componente de un tamaño mayor que el
disponible, mediante el uso de barras de desplazamiento.
Como su nombre lo indica, funciona como un contenedor, de manera que podemos
agregar un componente que requiera mayor espacio en el Frame.
JLabel imagen=new JLabel(new ImageIcon(getClass().getResource(
"/imagenes/imagen1.jpg")));
JScrollPane panel=new JScrollPane(imagen);
Programacion 2 Jhomara Luzuriaga
Clase JSplitPane
Permite visualizar dos componentes, uno a cada lado, con la posibilidad de
modificar la cantidad de espacio otorgado a cada uno. Se puede agregar un
contenedor como un JPanel en cada lado del Split y este a su vez contener más
componentes. Además se puede modificar una propiedad que indica la disposición
de los componentes: horizontal o vertical.
//espacio del primer componente con respecto del segundo
split.setDividerLocation(150);
//separación entre componentes del Split
split.setDividerSize(20);
//cambiando el componente de la izquierda y derecha
split.setLeftComponent(componenteIzquierda);
split.setRightComponent(componenteDerecha);
EJERCICIO:
SPLITPANE Y SCROLLPANE
Ubicar el primer componente con mayor ventaja que el segundo, con respecto al
tamaño del contenedor principal y una división de 20pix.
Programacion 2 Jhomara Luzuriaga
Clase JTabbedPane
Permite definir varias hojas con pestañas, que pueden contener otros
componentes. El componente básico de cada hoja debe ser un Panel que es el que
agrupe el resto de componentes.
Para agregar más hojas basta con añadir un panel al TabbedPane.
Ejemplo:
JTabbedPane tabbed=new JTabbedPane();
tabbed.add("Tabbed 1", new JPanel());
tabbed.add("Tabbed 2",new JPanel());
3.2. COMPONENTES CON MODELO DE DATOS.
Los componentes que permiten mostrar un listado o un conjunto de objetos se
pueden crear a partir de un modelo de datos. Por ejemplo un componente sencillo
como el JComboBox contiene un arreglo de objetos.
3.2.1. JLIST
Un componente JList permite administrar una lista de elementos de tipo Object con
una representación en String
Los constructores de la clase JList son:
JList()
JList(ListModel dataModel)
JList(Object[ ] listData)
JList(Vector? listData)
El segundo constructor recibe un objeto tipo ListModel, como ésta es una interface
utilizaremos una clase que la implementa: DefaultListModel
Programacion 2 Jhomara Luzuriaga
DefaultListModel modeloLista=new DefaultListModel();
Un objeto de esta clase puede implementar el método addElement(Object o).
modeloLista.addElement(“Elemento1”);//Object de tipo String.
modeloLista.addElement(“Elemento2”);
JList lista=new JList(modeloLista);// Se crea un JList con el modelo de elementos.
Ejemplo:
public class Lista extends JFrame{
private JList listaCursos;
private DefaultListModel modeloListaCursos;
public Lista() {
agregarComponentes();
setTitle("CURSOS");
setContentPane(p);
setSize(250, 200)
}
public void agregarComponentes(){
modeloListaCursos=new DefaultListModel();
modeloListaCursos.addElement("C++");
modeloListaCursos.addElement("Java");
modeloListaCursos.addElement("OpenOffice");
modeloListaCursos.addElement("Linux");
modeloListaCursos.addElement("Phyton");
listaCursos=new JList(modeloListaCursos);
JPanel p=new JPanel();
p.setBorder(BorderFactory.createTitledBorder("Lista de Cursos"));
p.add(listaCursos);
}
public static void main(String []args){
new Lista().setVisible(true);
}
}
Resultado:
Programacion 2 Jhomara Luzuriaga
EJERCICIO
Crear un Proyecto denominado ComponentesAvanzados y dentro del paquete
ventanas diseñar un clase VentanaPrincipal que extienda de JFrame y que tenga
los constructores necesarios para modificar sus propiedades.
Crear una clase ComponenteLista que permita utilizar la VentanaPrincipal para
añadir un JList similar al ejemplo, que contenga la lista de 5 estudiantes del salón.
3.2.2. JTABLE
JTable es uno de los componentes con APIs más extensas y también son
complejos, esa complejidad le permite ser más personalizable y potente.
Los constructores que proporciona esta clase son:
JTable()
JTable(int numRows, int numColumns)
JTable(Object[][] rowData, Object[] columnNames)
JTable(TableModel dm)
JTable(TableModel dm, TableColumnModel cm)
JTable(TableModel dm, TableColumnModel cm, ListSelectionModel sm)
JTable(Vector rowData, Vector columnNames)
El primer constructor permite crear un JTable con las propiedades por defecto, el
segundo crea la tabla como una matríz de numRows x numColumns.
Vamos a ver un ejemplo utilizando el constructor, que permite crear una tabla con
una matriz de datos (rowData) y los nombres de las columnas contenidos en un
array de String.
Nuestro primer ejemplo tendrá las siguientes columnas:
String[] columnNames =
{"Nombre", "Apellido", "Pasatiempo", "Años de Practica", "Soltero(a)"};
Y utilizaremos el siguiente array para su contenido:
Programacion 2 Jhomara Luzuriaga
Object[][] data = {
{"Maria", "Castro", "Esquiar", new Integer(5), new
Boolean(false)},
{"Lucas", "Herrera", "Patinar", new Integer(3), new
Boolean(true)},
{"Kthya", "Espinoza", "Escalar", new Integer(2), new
Boolean(false)},
{"Marco", "Molina", "Correr", new Integer(7), new
Boolean(true)},
{"Angela", "Díaz", "Nadar", new Integer(4), new
Boolean(false)}};
La creación de una tabla con estos datos sería:
JTable table = new JTable(data, columnNames);
Ejemplo:
import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
public class EjemploTabla1 extends JFrame{
public EjemploTabla1() {
super("Ejemplo 1");
//array bidimencional de objetos con los datos de la tabla
Object[][] data = {
{"Maria", "Castro", "Esquiar", new Integer(5), new Boolean(false)},
{"Lucas", "Herrera", "Patinar", new Integer(3), new Boolean(true)},
{"Kthya", "Espinoza", "Escalar", new Integer(2), new Boolean(false)},
{"Marco", "Molina", "Correr", new Integer(7), new Boolean(true)},
{"Angela", "Díaz", "Nadar", new Integer(4), new Boolean(false)}};
//array de String's con los títulos de las columnas
String[] columnNames = {"Nombre", "Apellido", "Pasatiempo",
"Años de Practica", "Soltero(a)"};
//se crea la Tabla
JTable table = new JTable(data, columnNames);
table.setPreferredScrollableViewportSize(new Dimension(500, 70));
//Creamos un JscrollPane y le agregamos la JTable
Programacion 2 Jhomara Luzuriaga
JScrollPane scrollPane = new JScrollPane(table);
//Agregamos el JScrollPane al contenedor
getContentPane().add(scrollPane, BorderLayout.CENTER);
}
public static void main(String[] args) {
EjemploTabla1 frame = new EjemploTabla1();
frame.pack();
frame.setVisible(true);
}
}
Modelo de tabla
Los modelos de tabla son objetos que implementan la interface TableModel; a
través de ellos es posible personalizar mucho más y mejor el comportamiento de
los componentes JTable, permitiendo utilizar al máximo sus potencialidades.
Todas las tablas cuentan con un modelo de tabla, aunque en el ejemplo 1 no se
haya especificado, existe uno por omisión
La clase AbstractTableModel es la que implementa directamente a
la interface TableModel, aunque es esta clase la que se recomienda extender para
utilizarla como modelo de tabla, existe un modelo de tabla predeterminado que
facilita mucho el trabajo con tablas. Este modelo predeterminado es la
clase DefaultTableModel
DefaultTableModel
Esta clase tiene el siguiente diagrama de herencia:
java.lang.Object
|
+-javax.swing.table.AbstractTableModel
|
+-javax.swing.table.DefautTableModel
Nuevamente, antes de comenzar a utilizar esta clase, veremos cuales son
los constructores con que cuenta:
DefaultTableModel()
DefaultTableModel(int numRows, int numColumns)
DefaultTableModel(Object[][] data, Object[] columnNames)
DefaultTableModel(Object[] columnNames, int numRows)
DefaultTableModel(Vector columnNames, int numRows)
DefaultTableModel(Vector data, Vector columNames)
Programacion 2 Jhomara Luzuriaga
Utilizaremos el constructor que nos permite crear un DefaultTableModel, a partir de
los datos con que ya contamos del ejemplo anterior:
Por lo tanto, el constructor queda así:
DefaultTableModel dtm= new DefaultTableModel(data, columnNames);
Despues de haber creado el modelo de tabla, dtm en el ejemplo, se crea
la tabla con el constructor correspondiente:
JTable table = new JTable(dtm);
Una vez hecho esto, cualquier modificación que se realice sobre el modelo de
tabla se reflejará directamente en la tabla.
Agregar una columna:
String[] newColumn= {"Contabilidad", "Informatica",
"Medicina",
"Musica",
"Diseño"};
dtm.addColumn("Carrera",newColumn);
Agregar una fila:
Object[] newRow={"Jose", "Ordóñez",
"Tenis", new Integer(5), new Boolean(false), "Pera"};
dtm.addRow(newRow);
Modificar una celda en especial, en este ejemplo la celda ubicada en la
columna 1, fila 1:
dtm.setValueAt("Catherine", 1, 1);
Puedes revisar los métodos que proporciona la clase DefaultTableModel para
conocer qué otras cosas puedes realizar con ella.
Ejemplo
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import javax.swing.JScrollPane;
import javax.swing.JPanel;
import javax.swing.JFrame;
public class EjemploTabla2 extends JFrame {
public EjemploTabla2() {
super("Ejemplo 2");
//array bidimencional de objetos con los datos de la tabla
Object[][] data = {
{"Maria","Castro", "Esquiar", new Integer(5), new Boolean(false)},
{"Lucas", "Herrera", "Patinar", new Integer(3), new Boolean(true)},
Programacion 2 Jhomara Luzuriaga
{"Kthya","Espinoza", "Escalar", new Integer(2), new Boolean(false)},
{"Marco", "Molina", "Correr", new Integer(7), new Boolean(true)},
{"Angela","Díaz", "Nadar", new Integer(4), new Boolean(false)}};
//array de String's con los títulos de las columnas
String[] columnNames = {"Nombre", "Apellido", "Pasatiempo",
"Años de Practica", "Soltero(a)"};
//creamos el Modelo de la tabla con los datos anteriores
DefaultTableModel dtm= new DefaultTableModel(data, columnNames);
//se crea la Tabla con el modelo DefaultTableModel
final JTable tabla = new JTable(dtm);
// una vez creada la tabla con su modelo
// podemos agregar columnas
String[] newColumn= {"Contabilidad",
"Informatica",
"Medicina",
"Musica",
"Diseño" };
dtm.addColumn("Carrera",newColumn);
//filas
Object[] newRow={"José", "Ordóñez",
"Tenis", new Integer(5), new Boolean(false), "Informatica"};
dtm.addRow(newRow);
//o modificar una celda en especifico
dtm.setValueAt("Sofía", 1, 1);
//se define el tamaño
tabla.setPreferredScrollableViewportSize(new Dimension(500, 70));
//Creamos un JscrollPane y le agregamos la JTable
JScrollPane scrollPane = new JScrollPane(tabla);
//Agregamos el JScrollPane al contenedor
getContentPane().add(scrollPane, BorderLayout.CENTER);
}
public static void main(String[] args) {
EjemploTabla2 frame = new EjemploTabla2();
frame.pack();
frame.setVisible(true);
}
}
AbstractTableModel
Con esta clase es posible implementar, de una manera más completa y eficiente,
los métodos necesarios para crear un modelo de tabla.
Para crear un modelo de tabla personalizado, lo primero que necesitamos
es extender la clase AbstractTableModel.
class MyTableModel extends AbstractTableModel {
.....
}
Como es una clase Abstracta debemos de implementar los 3 métodos siguientes:
Programacion 2 Jhomara Luzuriaga
class MyTableModel extends AbstractTableModel {
public int getRowCount(){
...
}
public int getColumnCount(){
...
}
public Object getValueAt(int row, int column){
...
}
}
Con la implementación de los métodos anteriores, las celdas de la tabla NO serán
editables y NO se podrán modificar los valores de cada una de ellas.
Si deseamos tener un mecanismo para modificar los valores de las celdas de
la tabla, tenemos que sobrescribir el método setValueAt de la
clase AbstractTableModel:
class MyTableModel extends AbstractTableModel {
...
...
public void setValueAt(Object value, int row, int col) {
...
}
}
Y, si la modificación de los valores de las celdas, se hace directamente sobre ellas,
necesitamos indicar a nuestro modelo de tabla que las celdas de la tabla serán
editables, esto se hace sobrescribiendo el método isCellEditable:
class MyTableModel extends AbstractTableModel {
...
public boolean isCellEditable(int row, int col) {
...
} }
Ya lo único que haría falta sería agregar los nombres de las columnas de
nuestra tabla y definir su contenido inicial:
class MyTableModel extends AbstractTableModel {
final String[] columnNames = {
...
}
final Object[][] data = {
...
}
...
}
Programacion 2 Jhomara Luzuriaga
JTable invoca un método del modelo de tabla para determinar el
editor/renderer predeterminado que utilizará para mostrar el valor de cada celda.
Por ejemplo para celdas con valores booleanos utilizará check box's; este método
es: getColumnClass, y también es recomendable implementarlo:
class MyTableModel extends AbstractTableModel {
...
public Class getColumnClass(int c) {
...
}
}
Ejercicio
Crear un proyecto ProyectoTablaSwing dentro del cual tendremos el paquete
modelo con las clases ModeloTablaEstudiante y Estudiante:
Estudiante
- id: int - nombre: String - apellido: String - carrera: String - modulo: String - paralelo: String - promedio: double
Adicionalmente un paquete presentacion contiene la clase VentanaEstudiantes
que será el frame con la tabla de estudiantes.
Diseña una clase Ejecutable que permita crear 5 estudiantes y almacenarlos en
un Vector de manera que se pueda crear el Modelo de la tabla con estos datos.
JTree
Al igual que JTable su creación se basa en un modelo que permite definir el nodo
raíz y los nodos hoja del componente.
Programacion 2 Jhomara Luzuriaga
Algunos de sus constructores son:
JTree()
JTree(Object[] value)
Retorna un JTree cuyos nodos hoja serán los objetos contenidos en el Array
value.
JTree(TreeModel newModel)
Crea una instancia de JTree en base al modelo del parámetro
JTree(TreeNode root)
Crea un JTree con un nodo raíz TreeNode.
JTree(Vector<?> value)
Crea un JTree con cada elemento especificado en el Vector como hijos de
un nodo raíz que no es mostrado.
TreeNode es la interfaz que permite generar los nodos del árbol, sin embargo por
su naturaleza no podemos crear objetos de ella. Existen algunas clases que
implementan esta interfaz y de las cuales podemos hacer uso.
DefaultMutableTreeNode
Esta clase permite crear objetos TreeNode para añadirlos a un JTree; como es
necesario tener un Nodo principal crearemos primeramente éste y luego
añadiremos sus nodos hoja utilizando el constructor que recibe como parámetro el
nombre del nodo:
DefaultMutableTreeNode nodoPrincipal=new DefaultMutableTreeNode(
"Nodo Principal");
DefaultMutableTreeNode nodo1=new DefaultMutableTreeNode("Nodo 1");
DefaultMutableTreeNode nodoSub1=new DefaultMutableTreeNode("Nodo hijo 1");
nodo1.add(nodoSub1);
nodoPrincipal.add(nodo1);
Programacion 2 Jhomara Luzuriaga
Ahora crearemos el árbol con el nodo principal, utilizando el cuarto constructor de
los antes mencionados:
JTree arbol=new JTree(nodoPrincipal);
EJERCICIO
Para el ejercicio utilizaremos el Proyecto ComponentesAvanzados de modo que
podamos reutilizar la clase VentanaPrincipal para crear el frame que contendrá
un árbol con la clasificación de los animales.
Programacion 2 Jhomara Luzuriaga
4. EVENTOS
4.1. ¿Qué es un evento?
Todos los sistemas operativos están constantemente atendiendo a los eventos
generados por los usuarios. Estos eventos pueden ser: pulsar una tecla, mover el
ratón, hacer clic con el ratón, pulsar el ratón sobre un botón o menú (Java distingue
entre simplemente pulsar el ratón en un sitio cualquiera o hacerlo, por ejemplo, en
un botón). El sistema operativo notifica a las aplicaciones que están ocurriendo
estos eventos, y ellas deciden si han de responder o no de algún modo a este
evento.
4.2. Gestión de Eventos
Para hacer que el manejador escuche los eventos de otro objeto se emplea el
método add[nombre_evento]Listener.
Programacion 2 Jhomara Luzuriaga
Ejemplo:
frame.addMouseListener(manejador);
Este método permite registrar eventos del ratón asociados a un objeto frame.
Esto se denomina Registro de Receptores específicos para los eventos. El objeto
fuente utiliza esta lista para notificar a cada receptor que ha sucedido un evento de
los que controla.
Hay algunas clases de eventos que involucran a más de un evento, tal es el caso
del ratón. Por tanto, la clase que implementa el manejador de eventos del ratón
debe sobreescribir todos los métodos declarados en la interfaz MouseListener,
tales como mousePressed, mouseReleased, mouseClicked, mouseMoved y otros.
Para facilitar el manejo de estos eventos, se han definido un número de clases
intermedias, conocidas como clases adaptadores (Adapters), para no tener que
sobreescribir todos los métodos de la interfaz cuando se requiere controlar un solo
tipo de evento.
De esta manera podemos definir dos caminos para acceder a los Oyentes de los
eventos para un componente específico:
Implementando la interfaz, lo cual implica sobreescribir todos sus métodos.
public class EventoMouse implements MouseListener{...
Extendiendo una clase adaptadora, con lo cual se sobreescriben solo los
métodos deseados. public class EventoMouse extends MouseAdapter{...
Los eventos están agrupados de acuerdo a su naturaleza en los siguientes grupos:
ActionListener: acciones sobre componentes.
WindowListener: cierre o manipulación una ventana (Frame/Dialog).
MouseListener: presión de un botón del mouse mientras el cursor está
sobre el componente.
MouseMotionListener: movimiento del mouse sobre un componente.
ComponentListener: visibilidad del componente.
FocusListener: obtención del foco del teclado.
Programacion 2 Jhomara Luzuriaga
ListSelectionListener: selección de ítems dentro de una lista.
A continuación en la siguiente se lista las principales interfaces junto a sus
respectivas clases “Adapter” y los métodos que poseen para los componentes:
Listener interface y Adapter Metodos
ActionListener actionPerformed(ActionEvent)
AdjustmentListener adjustmentValueChanged(AdjustmentEvent)
ComponentListener
ComponentAdapter
componentHidden(ComponentEvent)
componentShown(ComponentEvent)
componentMoved(ComponentEvent)
componentResized(ComponentEvent)
ContainerListener
ContainerAdapter
componentAdded(ContainerEvent)
componentRemoved(ContainerEvent)
FocusListener
FocusAdapter
focusGained(FocusEvent)
focusLost(FocusEvent)
KeyListener
KeyAdapter
keyPressed(KeyEvent)
keyReleased(KeyEvent)
keyTyped(KeyEvent)
MouseListener
MouseAdapter
mouseClicked(MouseEvent)
mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
MouseMotionListener
MouseMotionAdapter
mouseDragged(MouseEvent)
mouseMoved(MouseEvent)
WindowListener
WindowAdapter
windowOpened(WindowEvent)
windowClosing(WindowEvent)
windowClosed(WindowEvent)
windowActivated(WindowEvent)
windowDeactivated(WindowEvent)
windowIconified(WindowEvent)
windowDeiconified(WindowEvent)
ItemListener itemStateChanged(ItemEvent)
ListSelectionListener valueChanged(ListSelectionEvent)
Ejemplo
1. Vamos a trabajar con un evento que permite finalizar la ejecución del programa
al momento de cerrar la VentanaBase, ya que de otro modo seguirá
ejecutándose.
Programacion 2 Jhomara Luzuriaga
public class VentanaBase extends JFrame {
public VentanaBase() {
setTitle("Evento WindowClosing");
setSize(new Dimension(300, 200));
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
JOptionPane.showMessageDialog(null,"El programa
finalizara cuando pulse Aceptar");
System.exit(0);
}
});
}
public static void main(String[] args) {
new VentanaBase().setVisible(true);
}
}
En el ejemplo añadimos un escuchador WindowListener al frame e implementamos
el método windowClosing.
2. Añadimos a la VentanaBase un botón salir para cerrar la Ventana mostrando
un cuadro de confirmación.
salir.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
int opc=JOptionPane.showConfirmDialog(null,"Esta seguro de
cerrar la Ventana");
if(opc==0){
System.exit(0);
}
}
});
Programacion 2 Jhomara Luzuriaga
Ejemplo
ItemListener
ItemListener es un manejador que escucha todos los eventos relacionados con la
selección o cambio de algún ítem en un componente que implica selección.
Vamos a crear una clase JFrame como la siguiente:
Para manejar los eventos generados a partir de la selección de los ChekBox,
construiremos una clase que implemente la interfaz ItemListener de manera que
podamos sobreescribir el método itemStateChanged (ItemEvent e)
Trabajamos con la clase Font para cambiar el estilo de la Fuente del TextField
private class CheckBoxListener implements ItemListener {
private int valBold = Font.PLAIN;
private int valItalic = Font.PLAIN;
@Override
public void itemStateChanged(ItemEvent e) {
if (e.getSource() == bold) {
if (e.getStateChange() == ItemEvent.SELECTED) {
valBold = Font.BOLD;
} else {
valBold = Font.PLAIN;
}
}
if (e.getSource() == italic) {
if (e.getStateChange() == ItemEvent.SELECTED) {
valItalic = Font.ITALIC;
} else {
valItalic = Font.PLAIN;
}
}
...
...
}
}
Programacion 2 Jhomara Luzuriaga
Añadimos el escuchador a los componentes del Frame (CheckBox):
JCheckBox bold = new JCheckBox("Bold");
JCheckBox italic = new JCheckBox("Italic");
CheckBoxListener handler = new CheckBoxListener();
bold.addItemListener(handler);
bold.addItemListener(handler);
Es el mismo objeto listener que añadimos a todos los CheckBox ya que es un solo
objeto el que va a recibir los eventos y va a realizar los cambios seleccionados.
Ejemplo:
MouseMotionListener
public class Ventana extends JFrame{
public Ventana(){
setTitle("Evento Mouse");
setSize(new Dimension(250, 150));
setLocationRelativeTo(null);
final JPanel panel1=new JPanel();
panel1.setBackground(Color.gray);
final JButton boton =new JButton("Boton");
boton.addMouseMotionListener(new MouseMotionAdapter(){
public void mouseMoved(MouseEvent e){
boton.setCursor(new Cursor(Cursor.MOVE_CURSOR));
}
});
panel1.add(boton);
panel1.addMouseMotionListener(new MouseMotionAdapter(){
public void mouseMoved(MouseEvent e){
panel1.setCursor(new Cursor(Cursor.HAND_CURSOR));
}
});
this.add(panel1);
this.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
setVisible(true);
}
}
Programacion 2 Jhomara Luzuriaga
5. GRÁFICOS EN SWING
Todos los contenedores en swing permiten ser redibujados (repaint) en tiempo de
ejecución, es decir añadir algún componente modificar posiciones, pintar sobre el
contenedor, etc. Esto se debe a que un contenedor swing deriva de
java.awt.Container, y de esta manera a sus métodos.
Uno de ellos es el método
paint(Graphics g)
dibuja un gráfico (Graphics) en el contenedor. La clase Graphics permite diseñar
algunas formas como:
Lineas drawLine(int x1, int y1, int x2, int y2)
Dibuja una línea usando el color actual entre los puntos (x1, y1) y
(x2, y2) en el sistema de coordenadas del grafico
Circulos drawOval(int x, int y, int width, int height)
Dibuja un óvalo en la posición x, y, el ancho y alto del círculo.
Polígono drawPolygon(int[] xPoints, int[] yPoints, int nPoints)
Dibuja un poligono cerrado definido por arreglos de (x, y) coordenadas.
Rectángulo drawRect(int x, int y, int width, int height)
Dibuja un rectángulo en (x, y) con su tamaño width, height.
drawString(String str, int x, int y)
Dibuja el texto del String srt usando el contexto actual del gráfico y
el actual color de fuente.
Para dibujar formas con relleno usa los métodos:
fill3DRect(int x, int y, int width, int height, boolean raised)
fillArc(int x, int y, int width, int height, int startAngle,
int arcAngle)
fillOval(int x, int y, int width, int height)
Programacion 2 Jhomara Luzuriaga
fillPolygon(int[] xPoints, int[] yPoints, int nPoints)
fillRect(int x, int y, int width, int height)
fillRoundRect(int x, int y, int width, int height, int arcWidth,
int arcHeight)
Ejemplo:
g.fillOval(10,5, 4, 4);
dibujará un óvalo relleno en un cuadrado de 4x4 en la posición (10,5) del contedor
donde se dibuja.
EJEMPLO
JFrame Pintor:
public class Pintor extends JFrame {
private int cuentaPuntos = 0;
private JLabel j=new JLabel("Van: "+cuentaPuntos+" puntos");
// arreglo de 2000 referencias a java.awt.Point
private Point puntos[] = new Point[ 2000 ];
// configurar GUI y registrar manejador de eventos de ratón
public Pintor() {
super( "Un programa simple de dibujo" );
//crear una etiqueta y colocarla en la parte SOUTH del BorderLayout
getContentPane().add( new JLabel( "Arrastre el ratón para dibujar" ),
BorderLayout.SOUTH );
getContentPane().add( j,BorderLayout.NORTH );
addMouseMotionListener(
new MouseMotionAdapter() { // clase interna anónima
// almacenar coordenadas de arrastre y llamar a repaint
public void mouseDragged( MouseEvent evento )
{
if ( cuentaPuntos < puntos.length ) {
puntos[ cuentaPuntos ] = evento.getPoint();
++cuentaPuntos;
repaint();
Programacion 2 Jhomara Luzuriaga
j.setText("Van: "+cuentaPuntos+" puntos, le quedan:"
+(2000-cuentaPuntos)+"puntos");
}
}
} // fin de la clase interna anónima
); // fin de la llamada a addMouseMotionListener
setSize( 400, 200 );
setVisible( true );
} // fin del constructor de Pintor
// dibujar óvalo en un cuadro delimitador de 4x4 en ubicación especifica
public void paint( Graphics g ){
super.paint( g ); // borra el área de dibujo
for ( int i = 0; i < puntos.length && puntos[ i ] != null; i++ )
g.fillOval( puntos[ i ].x, puntos[ i ].y, 4, 4 );
}
public static void main( String args[] )
{
Pintor aplicacion = new Pintor();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
}
Programacion 2 Jhomara Luzuriaga
6. GENERADOR DE INTERFACES DE NETBEANS
El IDE Netbeans permite crear interfaces gráficas de manera visual, es decir
agregar a un Frame los componentes que deseamos tan solo con arrastrar el
componente desde la paleta hasta el Frame y modificar sus propiedades.
Para crear un Frame podemos seleccionar del Proyecto new JFrame en lugar de
Java Class. De esta manera se creará una clase con algunos atributos y
propiedades de JFrame, incluyendo el método main que permitirá visualizar el
Frame al ejecutar la clase.
VENTANAS DEL GENERADOR DE INTERFAZ GRÁFICA
Al agregar un contenedor de JFrame a un proyecto el programa abre el formulario
en una ficha del Editor con una barra de herramientas que incluye varios botones.
El formulario se abre en la vista Diseño del generador de interfaces gráficas de
usuario y aparecen automáticamente tres ventanas adicionales en las esquinas del
programa, que permiten navegar, organizar y editar los formularios de la interfaz
gráfica de usuario a medida que los genera.
Las diferentes ventanas del generador de interfaces gráficas de usuario
incluyen:
Programacion 2 Jhomara Luzuriaga
Área de diseño: Ventana principal del generador de interfaces gráficas de
usuario para crear y editar formularios de interfaz gráfica de usuario de Java.
Los botones Origen y Diseño de la barra de herramientas permiten ver el
código fuente de una clase o la vista gráfica de sus componentes de la
interfaz gráfica de usuario. Los botones adicionales de la barra de
herramientas permiten acceder cómodamente a los comandos habituales,
por ejemplo para elegir entre los modos de selección o conexión, alinear
componentes, definir el comportamiento de cambio automático del tamaño
de los componentes o pre visualizar los formularios.
Inspector: Proporciona una representación, tanto visual como no visual, de
todos los componentes de la aplicación en forma de jerarquía de árbol. El
inspector también permite visualizar el componente del árbol que se está
editando en el generador de interfaces gráficas de usuario, así como
organizar los componentes en los paneles disponibles.
Programacion 2 Jhomara Luzuriaga
Paleta: Lista personalizable de los componentes disponibles que contiene
fichas para los componentes de JavaBeans, JFC/Swing y AWT, así como
administradores de diseño.
Ventana de propiedades: Muestra las propiedades del componente
seleccionado en el generador de interfaces gráficas de usuario y las
ventanas Inspector, Proyectos o Archivos.
Método initComponents()
El código del método initComponents() es generado al momento que se añaden
componentes al frame, es decir las propiedades y eventos que se agreguen a los
componentes, de manera que no se pueden editar desde aquí.
La única manera de modificar o aumentar código a éste método es mediante la
pestaña Code del panel Properties en la vista diseño:
Crear el componente Antes de crear el componente Después de crear el componente Para inicializar el valor del componente Después de inicializar el componente ..........
Programacion 2 Jhomara Luzuriaga
PRÁCTICA
1. Crear un proyecto denominado ProyectoSwing.
2. Crear una clase PrimerFrame en un paquete denominado presentacion.
3. Agregar los siguientes componentes y modificar sus propiedades de diseño:
Diseño:
Asignamos nombres a cada componente:
Modificar el layout del panel Operaciones a BoxLayout
El cuadro de texto de Resultado no debe ser editable.
Agregamos los eventos a cada botón de las operaciones:
Programacion 2 Jhomara Luzuriaga
Una vez seleccionado el evento estaremos en la vista Source en donde está
todo el código generado al agregar y modificar los componentes.
Modificamos el contenido del método actionPerformed de cada botón:
El resultado será el siguiente:
Codificar los eventos de cada botón y controlar las excepciones para el
ingreso de texto en los campos de número.
EJERCICIO:
Leer un archivo de texto desde un programa en java que permita leer y modificar el
contenido en un JTextArea.
Utilice el patrón Modelo – Vista – Controlador para manejar los archivos
Programacion 2 Jhomara Luzuriaga
Uso de JFileChooser para buscar y abrir el archivo.
Uso de JFileColor para cambiar el color de fondo del área de texto y el color
de fuente.
Uso del paquete java.io para la lectura y escritura del Archivo.
EJERCICIO:
Elabore un programa que permita administrar en una tabla (JTable) los datos de los
estudiantes.
Utilizar el patrón MVC, de manera que la tabla pueda almacenar los
estudiantes como objetos.
Trabajar los eventos que permiten actualizar los datos de la tabla al agregar,
modificar o eliminar
Utilizar la opción binding de Netbeans para obtener los datos del Estudiante.
Programacion 2 Jhomara Luzuriaga
BIBLIOGRAFÍA
1. PÉREZ Gustavo Guillermo, Aprendiendo Java y Programación Orientada a
Objetos. http://compunauta.com/forums/linux/programacion/java/ebook.html
2. DEITEL Paul. Como programar en Java 7/e. Pearson Education. 2007.
3. Micael Gallego & Soto Montalvo, Interfaces Gráficas en Java. Ramón Areces, 2005. http://gavab.escet.urjc.es/wiki/download/mp/material/Modulo-Ev-Tema2-1.pdf
4. PAVÓN GÓMEZ Santiago Dpto. Ingeniería Sistemas Telemáticos Univ. Politécnica de Madrid http://jungla.dit.upm.es/~santiago/docencia/apuntes/Swing/
5. El tutorial Java de Sun: http://java.sun.com/docs/books/tutorial 6. Tutorial Java Básico Versión 3.0 http://www.javahispano.org
7. API Java de Sun (version 6): http://java.sun.com/javase/6/docs/api