Programacion en JAVA 2

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.

http://es.wikipedia.org/wiki/Biblioteca_%28programaci%C3%B3n%29

http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_Java

http://es.wikipedia.org/wiki/Widget

http://es.wikipedia.org/wiki/Interfaz_gr%C3%A1fica_de_usuario




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


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.

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


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)

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

}

JMenu

JMenuItem

JMenuBar


}

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

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.


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

http://compunauta.com/forums/linux/programacion/java/ebook.html

http://gavab.escet.urjc.es/wiki/download/mp/material/Modulo-Ev-Tema2-1.pdf

http://gavab.escet.urjc.es/wiki/download/mp/material/Modulo-Ev-Tema2-1.pdf

http://jungla.dit.upm.es/~santiago/docencia/apuntes/Swing/

http://java.sun.com/docs/books/tutorial

http://www.javahispano.org/

http://java.sun.com/javase/6/docs/api

Programacion en JAVA 2

Documents

Transcript of Programacion en JAVA 2