Programacion en JAVA 2

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

Container

Window JComponent Panel

Frame Dialog AbstractButton JTextComponent ….. Applet

JFrame JDialog JButton ….. JTextField JTextArea …..

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.


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);


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 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);
}
}


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.


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");
panel.setBackground(Color.CYAN);
panel.add(lbl1);
panel.add(txt1);
panel.add(lbl2);
panel.add(txt2);
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”);


EJEMPLO:
public Frame2() {
setTitle("DATOS");
setSize(300, 200);
JLabel lbl1 = new JLabel("Nombre");
JLabel lbl2 = new JLabel("Edad");
panel.add(lbl1);
panel.add(txt1);
panel.add(lbl2);
panel.add(txt2);
panel.add(new JButton("Click aquí"));
setVisible(true);
}

EJERCICIO:
Escriba 4 métodos para cambiar el estado de un botón, una etiqueta y un cuadro
de texto:
……………………………………………………………………………………………......
………………………………………………………………………………………………..
………………………………………………………………………………………………..
………………………………………………………………………………………………..
……………………………………………………………………………………………......
………………………………………………………………………………………………..
………………………………………………………………………………………………..
………………………………………………………………………………………………..
……………………………………………………………………………………………......
………………………………………………………………………………………………..
………………………………………………………………………………………………..
………………………………………………………………………………………………..


 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);
panel.add(cmbLista);
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


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).


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,


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 java.awt.*;
class TestFlowLayout extends JFrame{
TestFlowLayout frame = new TestFlowLayout ();


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.


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{
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.setTitle("Prueba de BorderLayoutLayout");
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.


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 java.awt.*;
class TestGridLayout extends JFrame{
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.setTitle("Prueba de BorderLayoutLayout");
}
}


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=1, c.gridy=1 c.gridx=2, c.gridy=0


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.

c.gridwidth=GridBagCostraints.RELATIVE c.gridwidth=GridBagCostraints.REMAINDER
c.gridheigth=1 c.gridheigth=1

c.gridwidth=1
c.gridheigth=1

c.gridwidth=GridBagCostraints.RELATIVE
c.gridheigth=GridBagConstraints.RELATIVE

c.gridwidth=GridBagCostraints.REMAINDER
c.gridheigth=GridBagConstraints.REMAINDER c.gridwidth=GridBagCostraints.REMAINDER
c.gridheigth=GridBagConstraints.RELATIVE

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.


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:


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)


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{

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;


c.weightx = 1.0;
container.add(new JTextField(), c);
c.gridwidth = GridBagConstraints.RELATIVE;
c.gridheight = GridBagConstraints.REMAINDER;
c.weightx = 0.4;
container.add(new JLabel("Contraseña"), c);
c.gridwidth = GridBagConstraints.REMAINDER;
c.gridheight = GridBagConstraints.REMAINDER;
c.weightx = 1.0;
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


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.*;
public class TestBoxLayout extends JFrame {

TestBoxLayout f = new TestBoxLayout();
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.setTitle("Demo BoxLayout");
f.setVisible(true);
}
}


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);


Ejemplo:

public class TestSpringLayout extends JFrame{
TestSpringLayout f=new TestSpringLayout();
SpringLayout sl=new SpringLayout();
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.setTitle("Login");
f.setVisible(true);
}
}


EJERCICIO:

Diseñe la siguiente pantalla utilizando el Layout más indicado para la ubicación de
los componentes en el Frame


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)
JMenu JMenuBar

JMenuItem

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);
}
new VentanaMenu().setVisible(true);
}


}
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);


 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.


 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


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:


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:


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


JScrollPane scrollPane = new JScrollPane(table);
//Agregamos el JScrollPane al contenedor
getContentPane().add(scrollPane, BorderLayout.CENTER);
}

EjemploTabla1 frame = new EjemploTabla1();
frame.pack();
}
}

 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)


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)},


{"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);
}

EjemploTabla2 frame = new EjemploTabla2();
frame.pack();
}
}

 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:


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:

...
...
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:
...
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:

final String[] columnNames = {
...
}
final Object[][] data = {
...
}
...
}


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:

...
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.


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);


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.


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.


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.


 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 componentHidden(ComponentEvent)
ComponentAdapter componentShown(ComponentEvent)
componentMoved(ComponentEvent)
componentResized(ComponentEvent)
ContainerListener componentAdded(ContainerEvent)
ContainerAdapter componentRemoved(ContainerEvent)
FocusListener focusGained(FocusEvent)
FocusAdapter focusLost(FocusEvent)
KeyListener keyPressed(KeyEvent)
KeyAdapter keyReleased(KeyEvent)
keyTyped(KeyEvent)
MouseListener mouseClicked(MouseEvent)
MouseAdapter mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
MouseMotionListener mouseDragged(MouseEvent)
MouseMotionAdapter mouseMoved(MouseEvent)
WindowListener windowOpened(WindowEvent)
WindowAdapter 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.


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);
}
});
}
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);
}
}
});


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;
}
}
...
...
}
}


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);
}
}


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)


 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();


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 );
}
}


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:


 Á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.


 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
..........


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:


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


 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.


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


Programacion en JAVA 2

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Programacion en JAVA 2

Similar to Programacion en JAVA 2 (20)

Programacion en JAVA 2