Java Grafico

Introducción a
Interfaces
Gráficas
Por: Gilberto Pacheco Gallegos
Copyright © 2008 Gilberto Pacheco Gallegos

Índice
1. Conceptos Básicos.................................................................................................................................1
1.1. Objetos y Propiedades....................................................................................................................1
1.2. Tipos de Ventanas...........................................................................................................................2
1.3. Construcción de Interfaces Gráficas en Java..................................................................................3
1.4. Componentes Gráficos...................................................................................................................3
1.5. Abstract Window Toolkit (AWT)...................................................................................................4
1.6. Swing..............................................................................................................................................4
1.7. Propiedades....................................................................................................................................4
1.8. Eventos...........................................................................................................................................5
1.9. Primer Programa.............................................................................................................................5
1.9.1. Ventana...................................................................................................................................5
1.9.2. Salida de Texto............................................................................................................................5
1.9.3. Código Fuente.........................................................................................................................6
1.10. Layouts.........................................................................................................................................7
1.11. Interfaz1........................................................................................................................................8
1.11.1. Ventana..................................................................................................................................8
1.11.2. Código Fuente.......................................................................................................................8
1.12. Interfaz2......................................................................................................................................10
1.12.1. Ventana...............................................................................................................................10
1.12.2. Código Fuente.....................................................................................................................11
2. Componenentes Básicos......................................................................................................................13
2.1. Cuadros de Texto Con Formato (Enteros)....................................................................................13
2.1.1. Ventana.................................................................................................................................13
2.1.2. Código Fuente.......................................................................................................................13
2.2. Texto con Formato (Números en General)...................................................................................16
2.2.1. Ventana.................................................................................................................................16
2.2.2. Código Fuente.......................................................................................................................16
2.3. Texto con Formato (Fechas).........................................................................................................19
2.3.1. Ventana.................................................................................................................................19
2.3.2. Código Fuente.......................................................................................................................19
2.4. Cuadros Combinados...................................................................................................................22
2.4.1. Ventana.................................................................................................................................22
2.4.2. Código Fuente.......................................................................................................................23
2.5. Listas.................................................................................................................................................25
2.5.1. Ventana.................................................................................................................................25
2.5.2. Código Fuente.......................................................................................................................25
3. Tablas...................................................................................................................................................27
3.1. Tablas con Arreglos Bidimensionales..........................................................................................27
3.1.1. Ventana.................................................................................................................................27
3.1.2. Código Fuente.......................................................................................................................28
3.2. Tablas con Arreglos de referencias...............................................................................................31
3.2.1. Código Fuente de “Proveedor.java”.....................................................................................31
3.2.2. Código Fuente de “Tabla2.java”...........................................................................................32
4. Cuadros de Diálogo..............................................................................................................................36
4.1. Cuadros de Diálogo Predefinidos................................................................................................36
4.1.1. Ventana.................................................................................................................................36
4.1.2. Código Fuente.......................................................................................................................37
4.2. Cuadros de Selección de Color....................................................................................................40
4.2.1. Ventana.................................................................................................................................40
4.2.2. Código Fuente.......................................................................................................................41
4.3. Areas de Texto y Diálogos de Impresión.....................................................................................42
4.3.1. Ventana.................................................................................................................................42
4.3.2. Código Fuente.......................................................................................................................43
5. Layouts.................................................................................................................................................45
5.1. FlowLayout..................................................................................................................................45
5.1.1. Ventana.................................................................................................................................46
5.1.2. Código Fuente.......................................................................................................................46
5.2. BorderLayout................................................................................................................................47
5.2.1. Ventana.................................................................................................................................47
5.2.2. Código Fuente.......................................................................................................................47
5.3. GridBagLayout.............................................................................................................................48
5.3.1. Ventana.................................................................................................................................50
5.3.2. Código Fuente.......................................................................................................................50
5.4. Clase de Ayuda para GridBagLayout...........................................................................................51
5.4.1. Ventana.................................................................................................................................51
5.4.2. Código Fuente de “GBC.java”.............................................................................................52
5.4.3. Código Fuente de “GridBagLayout2.java”...........................................................................54
Introducción a Interfaces Gráficas
1. Conceptos Básicos.
Hoy en día los gráficos por computadora son el principal medio de comunicación entre usuarios y
computadoras, debido a su facilidad de uso. Pues los diferentes recursos disponibles de representan con
imágenes que pueden controlarse con dispositivos de etrada tales como teclado, mouse, pantallas
sensitivas al contacto etc.
El punto de entrada en la interacción del usuario con la computadora es el escritorio (desktop), donde
se puede usar la información almacenada en carpetas(folders) y documentos, que se administran
mediante programas de aplicación y herramientas.
El escritorio también nos da acceso a programas de aplicación y herramientas para manipular la

información de la computadora. Cuando los ejecutamos se despliegan en áreas de la pantalla (ventanas)
que hacen un fuerte uso de gráficos. Cuando están bien diseñadas son fáciles de aprender y requieren
poca escritura.
1.1. Objetos y Propiedades.

Las ventanas pueden desplegar objetos de la interfaz de usuarios. Un objeto es una entidad lógica que
la aplicación despliega y el usuario manipula. Por ejemplo, en una aplicación de procesamiento de
texto tenemos párrafos y palabras. Representan datos y partes de las labores que realiza el usuario.
Los objetos tienen características que definen su comportamiento, llamadas propiedades. Por ejemplo,
una párrafo puede tener una propiedad llamada font, que determina el tipo de letra utilizado. Los
usuarios normalmente pueden ver el valor asignado a las propiedades y modificarlo.
Las vistas son diferentes formas de desplegar objetos y sus caracterísiticas, como son listas de
elementos, tablas de propiedades o íconos.
1
1.2. Tipos de Ventanas.
● Ventanas Primarias. Aquellas donde el usuario realiza principalmente la interacción con los
datos o documentos. Una aplicación puede tener una o más de estas ventanas y se manejan de
forma independiente. Representan un objeto (por ejemplo un documento de texto) o un conjunto
de objetos (como el contenido de una carpeta). Normalmente contienen los siguientes
elementos.
○ Barra de título. Despliega texto que incluye el nombre del objeto o conjunto de objetos que
la ventana representa y el nombre de la aplicación.
○ Barra de menú. Es opcional y despliega una lista de opciones para ser elegidas.
Típicamente los menú se agrupan de foma lógica para que el usuario no memorice todas las
órdenes disponibles.
○ Barra de herramientas. Es opcional y contiene una colección de las órdenes o de opciones
usadas más frecuentemente. Normalmente aparecen horizontalmente debajo de la barra de
menú de una ventana primaria, pero puede arrastrarse a cualquier parte de la ventana.
Normalmente contienen una combinación de los siguientes controles:
■ Botones de orden. Por ejemplo, los botones para guardar o imprimir documentos.
■ Controles para elegir modos de interacción. Por ejemplo, para seleccionar alguna
herramienta de dibujo.
■ Controles que cambian y despliegan dinámicamente las propiedades de objetos. Por
ejemplo, los botones que muestran si cierto caracter está en negrilla o en itálica.
○ Barra de estado. Es opcional y despliega mensajes sobre lo que está sucediendo en la
aplicación e información sobre el el objeto representado por la ventana.
● Ventanas Secundarias. Son auxiliares y dependen de la ventana principal o de otra ventana
secundaria. Se clasifican en:
○ Ventanas de alerta. Permiten una interacción breve con el usuario, por ejemplo
desplegando mensajes de error o avisar sobre problemas potenciales.
○ Cuadros de diálogo. A su vez se clasifican en:
■ Ventanas de propiedades. Normalmente son abiertas desde otras ventanas donde se
muestran objetos y permiten al usuario desplegar o asignar las propiedades de uno o más
objetos.
■ Ventanas de acción. Normalmente son abiertas desde otras ventanas donde se solicita
realizar una acción. Solicitan al usuario información necesaria para realizar esa acción
(por ejemplo, para abrir un archivo).
● Ventanas de Utilerías. Despliegan un conjunto de herramiantas (por ejemplo, las herramientas
de dibujo) o permiten otro tipo de interacción que tiene efecto sobre una ventana primaria
activa. Permanecen abiertas aún cuando las ventanas primarias se cierran o minimizan. Un
ejemplo son las ventanas de herramientas usadas para seleccionar alguna herramienta gráfica.
● Ventanas Planas. No tienen barras de título ni controles de ventana. Se usan típicamente para
2
pantallas de bienvenida, que se muestran brevemente mientras la aplicación inicia y despliega la

ventana primaria.
1.3. Construcción de Interfaces Gráficas en Java.

Para construir interfaces gráficas desde el lenguaje de programación Java es necesario conocer los
siguietnes temas:
● Objetos y referencias.
● Constructores.
● Interfaces.
● Clases anónimas.
● Herencia.
● Arreglos de referencias.
● Manejo de excepciones.
1.4. Componentes Gráficos.

Cada uno de los elementos de una interfaz gráfica es conocido como componente gráfico.
Normalmente cada sistema operativo proporciona un juego de ellos. Los más comunes son:
● Etiquetas. Representan texto fijo.
● Botones.
● Campos de texto.
● Cuadros combinados.
● Listas.
● Tablas (también conocidos como grids, rejillas en español).
A cada componete gráfico le corresponde una clase. Por ejemplo, para construir ventanas primarias
podemos usar la clase javax.swing.JFrame con una instrucción como la siguiente:
JFrame r = new JFrame();
3
1.5. Abstract Window Toolkit (AWT).
Desde su origen, Java cuenta con la librería AWT, que contiene clases que se apoyan fuertamente en el
sistema operativo. Para cada componente gráfico se define una clase que corresponde a un tipo de
objeto proporcionado por el sistema operativo. Tiene el problema de que la cantidad de componentes es
muy pobre y que estos no se comportan igual en distintos sistemas operativos, lo cual hace complica el
diseño de aplicaciones que deban correr sobre diferentes plataformas.
1.6. Swing.
Swing es una librería más reciente, donde cada componente es dibujado y controlado directamente por
Java. De esta forma se puede tener un juego más amplio de componentes y con un comportamiento más
uniforme entre distintas plataformas. Está construido sobre AWT.
1.7. Propiedades
Cada componente de la interfaz gráfica corresponde normalmente a una clase en Java.
Una propiedad es una característica de un objeto, cuyo valor controla un aspecto del comportamiento
de dicho objeto. A cada propiedad le corresponden dos métodos:
● Un método para asignar la propiedad, que empieza con set. Por ejemplo al texto de la barra de
título de una ventana primaria le corresponde a la propiedad title y se asigna invocando al
método setTitle. Si se toma el ejemplo del punto anterior, se puede usar la siguiente instrucción:
r. setTitle(“Programa X”);
● Un método para obtener la propiedad, que empieza con set o con is en el caso de devolver un
valor booleano. Por ejemplo, el método getTitle devuelve el título de una ventana primaria y el
método isEnabled indica si puede procesar. Por lo mismo es posible escribir las siguientes
instrucciones:
String t = r.getTitle();
boolean e = r.isEnabled();
Cuando una propiedad no tiene definido el método set, se dice que es una propiedad de solo lectura.
4
1.8. Eventos.
Los eventos son sucesos que afectan a un componente gráfico y que pueden ser detectados. Por
ejemplo, cuando se quiere cerrar una ventana. Como respuesta, pueden notificar a otros objetos,
llamados listeners, de la presencia de estos eventos. Para ello, los objetos a los que se comunican
deben implementar registrarse con el componente gráfico. En el siguiente ejemplo, se registra un
objeto para ser notificado cuando se quiera cerrar una ventana primaria.
r.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent evt) {
System.out.println(“Adios”);
}
});
En este ejemplo, el operador new nos permite crear un objeto de la clase WindowAdapter, que por
definición implementa la interfaz WindowListener. Cuando se quiere cerrar una ventana, se invoca el
método windowClosing de los objetos registrados. En este caso, se mostrará el mensaje “Adios” en
la salida de texto. El objeto apuntado por evt contiene una descripción del evento windowClosing.
1.9. Primer Programa.

Este programa ilustra todos los temas tocados en este capítulo.
1.9.1. Ventana.
1.9.2. Salida de Texto

1 Adios
2
5
1.9.3. Código Fuente.
1 import java.awt.event.WindowAdapter;
2 import java.awt.event.WindowEvent;
3 import javax.swing.JFrame;
4 import javax.swing.SwingUtilities;
5
6 public class Primero {
7 public static void main(String[] args) {
8 /*
9 * Crea un objeto que implementa la interface Runnable. Esta
10 * instancia se pasa como parámetro a invokeLater; este método envía
11 * el objeto al hilo de swing, donde se ejecuta el método run en el
12 * momento que el sistema gráfico determine más adecuado.
13 */
14 SwingUtilities.invokeLater(new Runnable() {
15 public void run() {
16 // Crea una ventana principal con título "Interfaz 1"
17 JFrame r = new JFrame();
18 /*
19 * Se define la propiedad title para mostrar título "Programa
20 * X"
21 */
22 r.setTitle("Programa X");
23 /*
24 * Indica que la aplicación termina cuando se cierra la
25 * ventana.
26 */
27 r.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
28 /*
29 * Se define el tamaño de la ventana: 200 pixeles verticales
30 * por 100 horizontales.
31 */
32 r.setSize(200, 100);
33 /*
34 * Conecta la ventana con un objeto es notificado cuando se
35 * quiere cerrar la ventana.
36 */
37 r.addWindowListener(new WindowAdapter() {
38 public void windowClosing(WindowEvent evt) {
39 System.out.println("Adios");
40 }
41 });
42 /*
43 * Muestra la ventana al definir la propiedad visible como
44 * true.
45 */
46 r.setVisible(true);
47 }
48 });
49 }
50 }
6
1.10. Layouts.
Para colocar los componentes en una ventana normalmente se usa un panel de componentes de la clase
javax.swing.JPanel. Para organizar su contenido, generalmente se ayuda de objetos llamados layouts.
Hay distintas clases de layouts, especializadas en diferentes formas de organizar componentes. A
continuación enlistamos algunas clases que cumplen esta función:
● GridLayout – Coloca los componentes en una rejilla compuesta de celdas del mismo tamaño.
Cada componente ocupa una cola celda.
● FlowLayout – Coloca los componentes horizontalmente.
● BorderLayout – Coloca los componentes en cinco posiciones, que son arriba, abajo, izquierda,
derecha y al centro.
● GridBagLayout – Coloca los componentes en una rejilla compuesta de celdas de diferente
tamaño. Cada componente puede ocupar más de una celda
El que nos permite disponer componentes de una forma más variada, manteniendo un estilo bastante
simple de programar es java.awt.Grid Layout.
Tiene diferentes Constructores:
public GridLayout( )
Descripción:
Crea una rejilla de un solo renglón.
public GridLayout(int renglones, int columnas)

Descripción:
Crea una rejilla con el número especificado de renglones y columnas. Todos los componentes se
despliegan del mismo tamaño. Alguno de los parámetros puede ser cero, pero no ambos.
Parámetros:
renglones – el número de renglones; cuando es cero representa cualquier número de renglones.
columnas – el número de columnas; cuendo es cero representa cualquier número de columnas.
public GridLayout(int renglones, int columnas, int sepHorizontal, int sepVertical)

Descripción:
Crea una rejilla con el número especificado de renglones y columnas. Todos los componentes se
despliegan del mismo tamaño. También se especifica separación horizontal entre las columnas y la
distancia vertical entre los renglones. Los renglones y las columnas pueden ser cero, pero no ambos.
7
Parámetros:
renglones – el número de renglones; cuando es cero representa cualquier número de renglones.
columnas – el número de columnas; cuendo es cero representa cualquier número de columnas.
sepHorizontal – separación horizontal entre columnas.
sepVertical – separación vertical entre renglones.
1.11. Interfaz1.
Una interfaz gráfica normalmente consta de una ventana principal donde se despliega una forma, que
contiene mecanismos para indicar:
● La información hay que ingresar
● Procesar
● Para mostrar resultados.
Nota que el programa no se escribe en orden de procesamiento, sino asignando valor a las propiedades
de los objetos involucrados y el código para procesar eventos.
1.11.1. Ventana.

1 import java.awt.GridLayout;
2 import java.awt.event.ActionEvent;
3 import java.awt.event.ActionListener;
4 import javax.swing.JButton;
6 import javax.swing.JLabel;
7 import javax.swing.JPanel;
8 import javax.swing.JTextField;
10
11 /**
12 * Ejemplo de como crear un panel. Implementa la interfaz ActionListener pues
13 * procesa eventos de acción
8
14 */
15 public class Interfaz1 extends JPanel implements ActionListener {
16 /**
17 * Referencia constante llamada lblNombre que apunta a una etiqueta cuyo
18 * texto es "Nombre".
19 */
20 private final JLabel lblNombre = new JLabel("Nombre:");
21 /**
22 * Referencia constante llamada txtNombre que apunta a un cuadro de texto
23 * sin formato que debe mostrar al menos 10 caracteres.
24 */
25 private final JTextField txtNombre = new JTextField(10);
26 private final JLabel lblSaludo = new JLabel("Saludo:");
27 private final JTextField txtSaludo = new JTextField(17);
28 /**
29 * Referencia constante llamada btnSaludo que apunta a un botón cuyo
30 * texto es "Saludo".
31 */
32 private final JButton btnSaludo = new JButton("Saludo");
33 {
34 /*
35 * Notifica a este objeto cada vez que se hace clic en btnSaludo.
36 */
37 btnSaludo.addActionListener(this);
38 }
39 public Interfaz1() {
40 /*
41 * Asigna al panel una disposición en rejilla de 3 renglones y 2
42 * columnas.
43 */
44 setLayout(new GridLayout(3, 2));
45 /*
46 * Agrega las referencias a los objetos que se despliegan en el
47 * panel. Los objetos van llenando el primer renglón de izquierda a
48 * derecha, luego el segundo, y así sucesivamente.
49 */
50 add(lblNombre);
51 add(txtNombre);
52 add(lblSaludo);
53 add(txtSaludo);
54 add(btnSaludo);
55 }
56 /**
57 * Método invocado cada vez que se hace clic en btnSaludo.
58 *
59 * @param evt
60 * referencia al objeto que describe lo que sucedió al hacer
61 * clic
62 */
63 public void actionPerformed(ActionEvent evt) {
64 /*
65 * Obtiene el texto que está capturado en txtNombre usando el método
66 * getText y elimina los espacios en blanco al inicio y al final
67 * usando el método trim.
9
68 */
69 String saludo = "Hola " + txtNombre.getText().trim();
70 /*
71 * Asigna el texto a mostrar en txtSaludo con el método setText.
72 */
73 txtSaludo.setText(saludo);
74 }
76 /*
81 */
84 // Crea una ventana principal con título "Interfaz 1"
85 JFrame ventana = new JFrame("Interfaz 1");
86 /*
87 * Asigna como contenida de la ventana una instancia de
88 * Interfaz1.
89 */
90 ventana.setContentPane(new Interfaz1());
91 /*
92 * Indica que la aplicación termina cuando se cierre la
93 * ventana desde la barra de título.
94 */
95 ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
96 /*
97 * Calcula la apariencia, coordenadas y posición de la
98 * ventana y sus componentes.
99 */
100 ventana.pack();
101 // Muestra la ventana.
102 ventana.setVisible(true);
103 }
104 });
105 }
106 }
En la práctica, las ventanas de aplicación se manejan usando barras de menú.
10
1.12. Interfaz2.
1.12.1. Ventana.

1 import java.awt.*;
2 import java.awt.event.*;
3 import javax.swing.*;
4
5 public class Interfaz2 extends JFrame implements ActionListener {
8 private final JLabel lblSaludo = new JLabel("Saludo:");
9 private final JTextField txtSaludo = new JTextField(17);
10 /**
11 * Referencia a un elemento de un menú desplegable cuyo texto es
12 * "Saludo".
13 */
14 private final JMenuItem itmSaludo = new JMenuItem("Saludo");
15 {
16 itmSaludo.addActionListener(this);
17 }
18 private final JMenuItem itmSalir = new JMenuItem("Salir");
19 {
20 itmSalir.addActionListener(this);
21 }
22 /**
23 * Referencia a un menú desplegable cuyo texto es "Archivo".
24 */
25 private final JMenu menuArchivo = new JMenu("Archivo");
26 {
27 // Agrega los elementos al menú desplegable.
28 menuArchivo.add(itmSaludo);
29 menuArchivo.add(itmSalir);
30 }
31 /**
32 * Referencia a una barra de menú.
33 */
34 private final JMenuBar menuBar = new JMenuBar();
35 {
11
36 // Agrega los menús desplegables a la barra de menú.
37 menuBar.add(menuArchivo);
38 }
39 /*
40 * Crea un panel que tendrá 2 renglones X 2 columnas, 10 pixeles de
41 * separación horizontal entre componentes y 12 pixeles de separación
42 * vertical.
43 */
44 private final JPanel panel = new JPanel(new GridLayout(2, 2, 10, 12));
45 {
46 /*
47 * Crea un borde sin adornos de 10 pixeles arriba, 11 pixeles a la
48 * izquierda, 12 pixeles abajo y 13 pixeles a la derecha.
49 */
50 panel.setBorder(BorderFactory.createEmptyBorder(10, 11, 12, 13));
51 panel.add(lblNombre);
52 panel.add(txtNombre);
53 panel.add(lblSaludo);
54 panel.add(txtSaludo);
55 }
56 public Interfaz2() {
57 // Asigna el título de la ventana.
58 setTitle("Interfaz 2");
59 // Asigna la barra de menú.
60 setJMenuBar(menuBar);
61 // Asigna el panel a mostrar en la ventana.
62 setContentPane(panel);
63 setDefaultCloseOperation(EXIT_ON_CLOSE);
64 pack();
65 }
67 // Obtiene la referencia al objeto que origina el evento.
68 Object origen = evt.getSource();
69 if (origen == itmSaludo) {
70 saludo();
71 } else if (origen == itmSalir) {
72 System.exit(0);
73 }
74 }
75 private void saludo() {
76 String saludo = "Hola " + txtNombre.getText().trim();
77 txtSaludo.setText(saludo);
78 }
80 /*
85 */
88 // Crea una instancia de Interfaz2 y la muestra.
89 new Interfaz2().setVisible(true);
12
90 }
91 });
92 }
93 }
13
2. Componenentes Básicos.
2.1. Cuadros de Texto Con Formato (Enteros).
2.1.1. Ventana.

4 import javax.swing.BorderFactory;
7 import javax.swing.JMenu;
8 import javax.swing.JMenuBar;
9 import javax.swing.JMenuItem;
10 import javax.swing.JOptionPane;
14
15 public class Números extends JFrame implements ActionListener {
14
16 private final JLabel lblNúmero = new JLabel("Número:");

17 private final JTextField txtNúmero = new JTextField(10);
18 {
19 // Como es número se justifica a la derecha
20 txtNúmero.setHorizontalAlignment(JTextField.TRAILING);
21 }
22 private final JLabel lblResultado = new JLabel("Resultado:");
23 private final JTextField txtResultado = new JTextField(10);
24 {
25 // txtResultado no se puede editar
26 txtResultado.setEditable(false);
27 }
28 private final JMenuItem itmConvertir = new JMenuItem("Convertir");
29 {
30 itmConvertir.addActionListener(this);
31 }
33 {
35 }
37 {
38 menuArchivo.add(itmConvertir);
40 }
42 {
44 }
46 {
48 panel.add(lblNúmero);
49 panel.add(txtNúmero);
50 panel.add(lblResultado);
51 panel.add(txtResultado);
52 }
53 public Números() {
54 setTitle("Ejemplo con Números");
58 pack();
59 // Centra la ventana
60 setLocationRelativeTo(null);
61 }
64 if (origen == itmConvertir) {
65 convierte();
67 System.exit(0);
68 }
69 }
15
70 private void convierte() {
71 try {
72 int a = Integer.parseInt(txtNúmero.getText());
73 String resultado = "Ese no lo Conozco";
74 switch (a) {
75 case 0 :
76 resultado = "Cero";
77 break;
78 case 1 :
79 resultado = "Uno";
80 break;
81 case 10 :
82 resultado = "diez";
83 break;
84 }
85 txtResultado.setText(resultado);
86 } catch (NumberFormatException e) {
87 // Muestra un mensaje de Error:
88 JOptionPane.showMessageDialog(this,
89 "El formato del número es incorrecto.", "Error",
90 JOptionPane.ERROR_MESSAGE);
91 }
92 }
96 new Números().setVisible(true);
97 }
98 });
99 }
100 }
16
2.2. Texto con Formato (Números en General)
2.2.1. Ventana.

14
15 public class Calculadora extends JFrame implements ActionListener {
16 private final JLabel lblA = new JLabel("A:");
17 private final JTextField txtA = new JTextField(10);
18 {
20 txtA.setHorizontalAlignment(JTextField.TRAILING);
21 }
22 private final JLabel lblB = new JLabel("B:");
23 private final JTextField txtB = new JTextField(10);
24 {
26 txtB.setHorizontalAlignment(JTextField.TRAILING);
27 }
28 private final JLabel lblResultado = new JLabel("Resultado:");
29 private final JTextField txtResultado = new JTextField(10);
30 {
17
31 // txtResultado no se puede editar
32 txtResultado.setEditable(false);
34 txtResultado.setHorizontalAlignment(JTextField.TRAILING);
35 }
36 private final JMenuItem itmSumar = new JMenuItem("Sumar");
37 {
38 itmSumar.addActionListener(this);
39 }
40 private final JMenuItem itmRestar = new JMenuItem("Restar");
41 {
42 itmRestar.addActionListener(this);
43 }
45 {
47 }
49 {
50 menuArchivo.add(itmSumar);
51 menuArchivo.add(itmRestar);
53 }
55 {
57 }
59 {
61 panel.add(lblA);
62 panel.add(txtA);
63 panel.add(lblB);
64 panel.add(txtB);
65 panel.add(lblResultado);
66 panel.add(txtResultado);
67 }
68 public Calculadora() {
69 setTitle("Calculadora");
73 pack();
76 }
79 if (origen == itmSumar) {
80 suma();
81 } else if (origen == itmRestar) {
82 resta();
84 System.exit(0);
18
85 }
86 }
87 private void suma() {
88 try {
89 double a;
90 try {
91 a = Double.parseDouble(txtA.getText().trim());
93 throw new NumberFormatException("Formato de A Incorrecto");
94 }
95 double b;
96 try {
97 b = Double.parseDouble(txtB.getText().trim());
99 throw new NumberFormatException("Formato de B Incorrecto");
100 }
101 txtResultado.setText(String.valueOf(a + b));
104 JOptionPane.showMessageDialog(this, e.getMessage(), "Error",
106 }
107 }
108 private void resta() {
109 try {
110 double a;
111 try {
112 a = Double.parseDouble(txtA.getText().trim());
114 throw new NumberFormatException("Formato de A Incorrecto");
115 }
116 double b;
117 try {
118 b = Double.parseDouble(txtB.getText().trim());
120 throw new NumberFormatException("Formato de B Incorrecto");
121 }
122 txtResultado.setText(String.valueOf(a - b));
125 JOptionPane.showMessageDialog(this, e.getMessage(), "Error",
127 }
128 }
132 new Calculadora().setVisible(true);
133 }
134 });
135 }
136 }
19
2.3. Texto con Formato (Fechas)
2.3.1. Ventana.

4 import java.text.DateFormatSymbols;
5 import java.text.ParseException;
6 import java.text.SimpleDateFormat;
7 import java.util.Calendar;
8 import java.util.Date;
10 import javax.swing.JFormattedTextField;
20
21 public class Fechas extends JFrame implements ActionListener {
22 private final JLabel lblFecha = new JLabel("Fecha de Nacimiento:");
23 // Crea un formateador de fechas que va a manejael formato: dia -
24 // mes(dos
25 // dígitos) - Año (4 dígitos)
26 private final SimpleDateFormat fmtFecha = new SimpleDateFormat(
27 "dd-MM-yyyy");
28 // Crea un cuadro de texto formateado que utiliza el formato
20
29 // anterior
30 // para manejar fechas
31 private final JFormattedTextField txtFecha = new JFormattedTextField(
32 fmtFecha);
33 private final JLabel lblDia = new JLabel("Dias:");
34 private final JTextField txtDia = new JTextField(2);
35 {
36 txtDia.setEditable(false);
37 txtDia.setHorizontalAlignment(JTextField.TRAILING);
38 }
39 private final JLabel lblMes = new JLabel("Mes:");
40 private final JTextField txtMes = new JTextField(10);
41 {
42 txtMes.setEditable(false);
43 }
44 private final JLabel lblAnio = new JLabel("Año:");
45 private final JTextField txtAño = new JTextField(4);
46 {
47 txtAño.setEditable(false);
48 txtAño.setHorizontalAlignment(JTextField.TRAILING);
49 }
50 private final JMenuItem itmSeparar = new JMenuItem("Separar");
51 {
52 itmSeparar.addActionListener(this);
53 }
55 {
57 }
59 {
60 menuArchivo.add(itmSeparar);
62 }
64 {
66 }
68 {
70 panel.add(lblFecha);
71 panel.add(txtFecha);
72 panel.add(lblDia);
73 panel.add(txtDia);
74 panel.add(lblMes);
75 panel.add(txtMes);
76 panel.add(lblAnio);
77 panel.add(txtAño);
78 }
79 public Fechas() {
80 setTitle("Fechas");
21
84 pack();
87 }
90 if (origen == itmSeparar) {
91 calcula();
93 System.exit(0);
94 }
95 }
96 private void calcula() {
97 try {
98 Date fecha = fmtFecha.parse(txtFecha.getText());
99 // Crea un objeto de la clase calendario con la fecha de
100 // hoy
101 Calendar calendario = Calendar.getInstance();
102 // Asigna la fecha al calendario
103 calendario.setTime(fecha);
104 txtDia.setText(String.valueOf(calendario
105 .get(Calendar.DAY_OF_MONTH)));
106 txtAño.setText(String.valueOf(calendario.get(Calendar.YEAR)));
107 int mes = calendario.get(Calendar.MONTH);
108 // Crea una instancia de DateFormatSymbols
109 DateFormatSymbols simbolos = DateFormatSymbols.getInstance();
110 // Crea un arreglo con los nombres de los meses de acuerdo
111 // a la configuración de idioma del sistema operativo
112 String[] meses = simbolos.getMonths();
113 // Muestra el nombre del mes mostrado por el calendario
114 txtMes.setText(meses[mes]);
115 } catch (ParseException e) {
116 JOptionPane.showMessageDialog(this, "Formato Incorrecto",
117 "Error", JOptionPane.ERROR_MESSAGE);
118 }
119 }
123 new Fechas().setVisible(true);
124 }
125 });
126 }
127 }
22
2.4. Cuadros Combinados
2.4.1. Ventana.

5 import javax.swing.JComboBox;
13
14 public class CuadrosCombinados extends JFrame implements ActionListener {
15 /**
16 * Arreglo con los valores a mostrar en cmbOrigen. Desde Java 5.0 se
17 * puede omitir la invocación new Double(3.4) y poner 3.4; el compilador
18 * atomáticamente añade la conversión. La información mostrada en el
19 * combo se obtiene al invocar el mátodo toString() en cada elemento del
20 * arreglo.
21 */
22 private static final Object[] datos = {"Jirafa", "Tigre",
23
23 new Double(3.4)};
24 private final JLabel lblOrigen = new JLabel("Origen");
25 /**
26 * Crea un cuadro combinado que muestra los datos del arreglo.
27 */
28 private final JComboBox cmbOrigen = new JComboBox(datos);
29 {
30 // Indica que no hay opción seleccionada.
31 cmbOrigen.setSelectedItem(null);
32 // Notifica cada vez que se selecciona una opción.
33 cmbOrigen.addActionListener(this);
34 }
35 private final JLabel lblDestino = new JLabel("Destino");
36 /**
37 * Crea un cuadro combinado sin opciones.
38 */
39 private final JComboBox cmbDestino = new JComboBox();
40 private final JMenuItem itmLimpiar = new JMenuItem("Limpiar Destino");
41 {
42 itmLimpiar.addActionListener(this);
43 }
45 {
47 }
49 {
50 menuArchivo.add(itmLimpiar);
52 }
54 {
56 }
58 {
60 panel.add(lblOrigen);
61 panel.add(cmbOrigen);
62 panel.add(lblDestino);
63 panel.add(cmbDestino);
64 }
65 public CuadrosCombinados() {
66 setTitle("Cuadros Combinados");
70 pack();
72 }
75 if (origen == itmLimpiar) {
76 limpia();
24
77 } else if (origen == cmbOrigen) {

78 copia();
80 System.exit(0);
81 }
82 }
83 private void limpia() {
84 // Elimina todas las opciones de cmbDestino.
85 cmbDestino.removeAllItems();
86 cmbOrigen.setSelectedItem(null);
87 }
88 private void copia() {
89 // Recupera el valor seleccionado en cmbOrigen.
90 Object obj = cmbOrigen.getSelectedItem();
91 if (obj != null) {
92 // Agrega una opción a cmbDestino.
93 cmbDestino.addItem(obj);
94 // Selecciona el objeto agregado.
95 cmbDestino.setSelectedItem(obj);
96 }
97 }
101 new CuadrosCombinados().setVisible(true);
102 }
103 });
104 }
105 }
2.5. Listas
2.5.1. Ventana.
25
2 import javax.swing.JList;
4 import javax.swing.JScrollPane;
5 import javax.swing.ListSelectionModel;
7 import javax.swing.event.ListSelectionEvent;
8 import javax.swing.event.ListSelectionListener;
9
10 public class Listas extends JFrame implements ListSelectionListener {
11 private static Object[] datos = {"Perro", "Lobo", "Gato", "Delfín",
12 "Ballena", "Perico", "Zopilote", "Gallo", "Ganso", "Cisne"};
13 private final JList lstAnimales = new JList(datos);
14 {
15 // Solo permite seleccionar un elemento a la vez
16 lstAnimales.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
17 lstAnimales.addListSelectionListener(this);
18 }
19 private final JScrollPane scrlAnimales = new JScrollPane(lstAnimales);
20 public Listas() {
21 super("Listas");
22 setContentPane(scrlAnimales);
23 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
24 pack();
26 }
27 public void valueChanged(ListSelectionEvent e) {
28 if (e.getValueIsAdjusting()) {
29 return;
30 }
31 Object seleccion = lstAnimales.getSelectedValue();
32 if (seleccion != null) {
33 JOptionPane.showMessageDialog(this, seleccion.toString());
34 }
35 }
39 new Listas().setVisible(true);
40 }
26
41 });
42 }
43 }
27
3. Tablas.
Se utilizan para mostrar información tabular.
3.1. Tablas con Arreglos Bidimensionales.
3.1.1. Ventana.
Las la información contenida por las tablas se almacena en objetos que implementan la interfaz
javax.swing.TableModel.
28
3.1.2. Código Fuente del Modelo.

4 import javax.swing.table.AbstractTableModel;
5
6 public class Modelo1 extends AbstractTableModel {
7 private final SimpleDateFormat fmt = new SimpleDateFormat("dd/MM/yyyy");
8 private final Object[][] datos = {
9 {1, "Zoila Vaca", "01-800-MUU", "zoila@vaca.com.mx",
10 "Establos #23", fmt.parse("3/10/2003")},
11 {2, "Rolando Mota", "01-800-VIAJE", "rolando@viajes.com",
12 "Misterios #12", fmt.parse("6/11/2005")},
13 {3, "Armando Pacheco", "01-800-TQUILA", "armando@tquila.com",
14 "Noche de Ronda #99", fmt.parse("23/2/2007")}};
15 public Modelo1() throws ParseException {}
16 /**
17 * Devuelve el tipo de información de cada columna. De esta forma la
18 * tabla puede desplegar la información con la apariencia adecuada.
19 */
20 @Override
21 public Class<?> getColumnClass(int columna) {
22 switch (columna) {
23 case 0 : return Integer.class;
24 case 5 : return Date.class;
25 default : return String.class;
26 }
27 }
28 /**
29 * Devuelve el número de columnas.
30 */
31 public int getColumnCount() {
32 return 6;
33 }
34 /**
35 * Devuelve el encabezado de cada columna.
36 */
37 @Override
38 public String getColumnName(int columna) {
40 case 0 : return "Clave";
41 case 1 : return "Nombre";
42 case 2 : return "Teléfono";
43 case 3 : return "Correo Electrónico";
44 case 4 : return "Dirección";
45 default : return "Fecha de Inicio";
46 }
47 }
48 /**
49 * Devuelve el número de columnas.
50 */
51 public int getRowCount() {
52 return datos.length;
29
53 }
54 /**
55 * Devuelve una referencia al objeto almacenado en una columna. La clase
56 * del objeto debe coincidir con lo devuelto por getColumnClass.
57 */
58 public Object getValueAt(int renglón, int columna) {
59 return datos[renglón][columna];
60 }
61 /**
62 * Indica si una celda se puede o no modificar en la tabla.
63 */
64 @Override
65 public boolean isCellEditable(int renglón, int columna) {
67 case 0 : return false;
68 default : return true;
69 }
70 }
71 /**
72 * Modifica el valor almacenado en una celda.
73 */
74 @Override
75 public void setValueAt(Object dato, int renglón, int columna) {
76 datos[renglón][columna] = dato;
77 // Notifica a la tabla que los datos valor cambiaron.
78 fireTableDataChanged();
79 }
80 }
3.1.3. Código Fuente de la Interfaz.

1 import java.awt.Dimension;
2 import java.awt.print.PrinterException;
7 import javax.swing.JTable;
12
13 /**
14 * Las tablas utilizan objetos que implementen la interfaz TableModel, los
15 * cuales proporcionan a la tabla la información a desplegar. La clase
16 * AbstractTableModel se puede usar como base.
17 *
18 * La interfaz ListSelectionListener se utiliza para detectar cambios en el
19 * renglón seleccionado de la tabla.
20 */
21 public class Tablas1 extends JFrame implements ListSelectionListener {
30
22 /*
23 * Modelo de tabla que contiene los datos a mostrar en la tabla. Define
24 * algunos métodos que proporcionan los datos almacenados y la forma de
25 * desplegarlos.
26 */
27 private final Modelo1 modelo = new Modelo1();
28 /**
29 * Datos a mostrar.
30 */
31 private final JTable tabla = new JTable();
32 {
33 // Enlaza la tabla con el modelo.
34 tabla.setModel(modelo);
35 // Solo se puede seleccionar un renglón a la vez.
36 tabla.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
37 // Detecta cuando se selecciona un renglón.
38 tabla.getSelectionModel().addListSelectionListener(this);
39 }
40 // Se tiene que poner en un JScrollPane si quieres ver los encabezados.
41 private final JScrollPane scroll = new JScrollPane(tabla);
42 {
43 // Tamaño del área donde se muestra.
44 scroll.setPreferredSize(new Dimension(500, 100));
45 }
46 public Tablas1() throws ParseException {
47 setTitle("Tablas1");
48 setContentPane(scroll);
50 pack();
52 }
53 @Override
54 public void valueChanged(ListSelectionEvent evt) {
55 // Verifica que la selección se haya detectado correctamente.
56 if (evt.getValueIsAdjusting()) {
57 return;
58 }
59 // Obtiene el renglón seleccionado. Si no hay selección, devuelve -1.
60 int selección = tabla.getSelectedRow();
61 if (selección != -1) {
62 JOptionPane.showMessageDialog(this, "Seleccionaste el renglón "
63 + selección);
64 }
65 // Si se selecciona el renglón 0, manda una impresión
66 if (selección == 0) {
67 try {
68 tabla.print();
69 } catch (PrinterException e) {
70 JOptionPane.showMessageDialog(this, e.getMessage(),
71 "Error de Impresión", JOptionPane.ERROR_MESSAGE);
72 }
73 }
74 }
31
78 try {
79 Tablas1 frame = new Tablas1();
80 frame.setVisible(true);
82 e.printStackTrace();
83 }
84 }
85 });
86 }
87 }
3.2. Tablas con Arreglos de referencias.

Este código hace lo mismo que el anterior, pero utiliza objetos para almacenar el contenido de cada
renglón.
3.2.1. Código Fuente de “Proveedor.java”.

2
3 public class Proveedor {
4 private int clave;
5 private String nombre;
6 private String teléfono;
7 private String email;
8 private String dirección;
9 private Date fechaInicial;
10 public Proveedor() {}
11 public Proveedor(int clave, String nombre, String teléfono,
12 String email, String dirección, Date fechaInicial) {
13 this.clave = clave;
14 this.nombre = nombre;
15 this.teléfono = teléfono;
16 this.email = email;
17 this.dirección = dirección;
18 this.fechaInicial = fechaInicial;
19 }
20 public int getClave() {
21 return clave;
22 }
23 public void setClave(int clave) {
24 this.clave = clave;
25 }
26 public String getNombre() {
27 return nombre;
28 }
29 public void setNombre(String nombre) {
30 this.nombre = nombre;
31 }
32
32 public String getTeléfono() {

33 return teléfono;
34 }
35 public void setTeléfono(String teléfono) {
36 this.teléfono = teléfono;
37 }
38 public String getEmail() {
39 return email;
40 }
41 public void setEmail(String email) {
42 this.email = email;
43 }
44 public String getDirección() {
45 return dirección;
46 }
47 public void setDirección(String dirección) {
48 this.dirección = dirección;
49 }
50 public Date getFechaInicial() {
51 return fechaInicial;
52 }
53 public void setFechaInicial(Date fechaInicial) {
54 this.fechaInicial = fechaInicial;
55 }
56 }
3.2.2. Código Fuente del Modelo.

4 import javax.swing.table.AbstractTableModel;
5
6 public class Modelo2 extends AbstractTableModel {
7 private final SimpleDateFormat fmt = new SimpleDateFormat("dd/MM/yyyy");
8 /**
9 * Datos a mostrar.
10 */
11 private final Conocido[] datos = {
12 new Conocido(1, "Zoila Vaca", "01-800-MUU", "zoila@vaca.com.mx",
13 "Establos #23", fmt.parse("3/10/2003")),
14 new Conocido(2, "Rolando Mota", "01-800-VIAJE",
15 "rolando@viajes.com", "Misterios #12",
16 fmt.parse("6/11/2005")),
17 new Conocido(3, "Armando Pacheco", "01-800-TQUILA",
18 "armando@tquila.com", "Noche de Ronda #99",
19 fmt.parse("23/2/2007"))};
20 public Modelo2() throws ParseException {}
21 @Override
22 public Class<?> getColumnClass(int columna) {
24 case 0 : return Integer.class;
25 case 5 : return Date.class;
33
26 default : return String.class;
27 }
28 }
29 public int getColumnCount() {
30 return 6;
31 }
32 @Override
33 public String getColumnName(int columna) {
35 case 0 : return "Clave";
36 case 1 : return "Nombre";
37 case 2 : return "Teléfono";
38 case 3 : return "Correo Electrónico";
39 case 4 : return "Dirección";
40 default : return "Fecha de Inicio";
41 }
42 }
43 public int getRowCount() {
44 return datos.length;
45 }
46 public Object getValueAt(int renglón, int columna) {
48 case 0 : return datos[renglón].getClave();
49 case 1 : return datos[renglón].getNombre();
50 case 2 : return datos[renglón].getTeléfono();
51 case 3 : return datos[renglón].getEmail();
52 case 4 : return datos[renglón].getDirección();
53 default : return datos[renglón].getFechaInicial();
54 }
55 }
56 @Override
57 public boolean isCellEditable(int renglón, int columna) {
59 case 0 : return false;
60 default : return true;
61 }
62 }
63 @Override
64 public void setValueAt(Object dato, int renglón, int columna) {
66 case 0 :
67 datos[renglón].setClave((Integer) dato);
68 break;
69 case 1 :
70 /*
71 * Cuando los datos son de tipo String es más eficiente
72 * invocar el método toString().
73 */
74 datos[renglón].setNombre(dato.toString());
75 break;
76 case 2 :
77 datos[renglón].setTeléfono(dato.toString());
78 break;
79 case 3 :
34
80 datos[renglón].setEmail(dato.toString());
81 break;
82 case 4 :
83 datos[renglón].setDirección(dato.toString());
84 default :
85 datos[renglón].setFechaInicial((Date) dato);
86 }
87 fireTableDataChanged();
88 }
89 }
3.2.3. Código Fuente de la interfaz.

1 import java.awt.Dimension;
3 import java.text.MessageFormat;
8 import javax.swing.JTable;
11 import javax.swing.JTable.PrintMode;
14
15 /**
16 * Esta versión maneja arreglos de objetos pertenecientes a la clase
17 * Proveedor.
18 */
19 public class Tablas2 extends JFrame implements ListSelectionListener {
20 private final Modelo2 modelo = new Modelo2();
21 private final JTable tabla = new JTable();
22 {
23 tabla.setModel(modelo);
24 tabla.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
25 tabla.getSelectionModel().addListSelectionListener(this);
26 }
27 private final JScrollPane scroll = new JScrollPane(tabla);
28 {
29 scroll.setPreferredSize(new Dimension(500, 100));
30 }
31 public Tablas2() throws ParseException {
32 setTitle("Tablas2");
35 pack();
37 }
38 @Override
39 public void valueChanged(ListSelectionEvent evt) {
40 if (evt.getValueIsAdjusting()) {
35
41 return;
42 }
43 int selección = tabla.getSelectedRow();
44 if (selección != -1) {
45 JOptionPane.showMessageDialog(this, "Seleccionaste el renglón "
46 + selección);
47 }
48 // Si se selecciona el renglón 0, manda una impresión.
49 if (selección == 0) {
50 // Define el encabezado de la impresión.
51 MessageFormat encabezado = new MessageFormat("Ejemplo");
52 /*
53 * Define el pie de página. {0} muestra el número de página y
54 * también se puede poner en el encabezado.
55 */
56 MessageFormat pie = new MessageFormat("Página {0}");
57 try {
58 tabla.print(PrintMode.NORMAL, encabezado, pie);
62 }
63 }
64 }
68 try {
69 Tablas2 frame = new Tablas2();
72 e.printStackTrace();
73 }
74 }
75 });
76 }
77 }
36
4. Cuadros de Diálogo.
Nos permiten implementar ventanas secundarias.
4.1. Cuadros de Diálogo Predefinidos.
4.1.1. Ventana.
37
14
15 public class DiálogosPredefinidos extends JFrame implements ActionListener {
16 private final JLabel lblTexto = new JLabel("Texto:");
17 private final JTextField txtTexto = new JTextField(10);
18 private final JMenuItem itmConfirmar = new JMenuItem("Confirmar");
19 {
20 itmConfirmar.addActionListener(this);
21 }
22 private final JMenuItem itmLeer = new JMenuItem("Leer");
23 {
24 itmLeer.addActionListener(this);
25 }
26 private final JMenuItem itmMensaje = new JMenuItem("Mensaje");
27 {
28 itmMensaje.addActionListener(this);
29 }
30 private final JMenuItem itmError = new JMenuItem("Error");
31 {
32 itmError.addActionListener(this);
33 }
35 {
37 }
39 {
40 menuArchivo.add(itmConfirmar);
38
41 menuArchivo.add(itmLeer);
42 menuArchivo.add(itmMensaje);
43 menuArchivo.add(itmError);
45 }
47 {
49 }
51 {
53 panel.add(lblTexto);
54 panel.add(txtTexto);
55 }
56 public DiálogosPredefinidos() {
57 setTitle("Dialogos Predefinidos");
61 pack();
63 }
66 if (origen == itmConfirmar) {
67 confirma();
68 } else if (origen == itmLeer) {
69 lee();
70 } else if (origen == itmMensaje) {
71 mensaje();
72 } else if (origen == itmError) {
73 error();
75 System.exit(0);
76 }
77 }
78 private void confirma() {
79 /*
80 * Muestra un diálogo de confirmación con las opciones Yes, No y
81 * Cancel, con el mensaje indicado y el título "Seleccionar una
82 * Opción".
83 */
84 int respuesta = JOptionPane.showConfirmDialog(this,
85 "¿Te gusta Java?");
86 if (respuesta == JOptionPane.YES_OPTION) {
87 txtTexto.setText("SI");
88 } else if (respuesta == JOptionPane.NO_OPTION) {
89 txtTexto.setText("NO");
90 } else if (respuesta == JOptionPane.CANCEL_OPTION) {
91 txtTexto.setText("CANCELADO");
92 } else if (respuesta == JOptionPane.CLOSED_OPTION) {
93 txtTexto.setText("SE CERRÓ");
94 }
39
95 }
96 private void lee() {
97 // Muestra un diálogo que solicita un valor.
98 String respuesta = JOptionPane.showInputDialog(this, "Teclea Algo");
99 txtTexto.setText(respuesta);
100 }
101 private void mensaje() {
102 // Abre un diálogo que muestra un mensaje informativo.
103 JOptionPane.showMessageDialog(this, txtTexto.getText());
104 }
105 private void error() {
106 // Abre un diálogo que muestra un mensaje de error.
107 JOptionPane.showMessageDialog(this, txtTexto.getText(), "Error",
109 }
113 new DiálogosPredefinidos().setVisible(true);
114 }
115 });
116 }
117 }
4.2. Cuadros de Selección de Color.
4.2.1. Ventana.
40

1 import java.awt.Color;
5 import javax.swing.JColorChooser;
8
9 public class ColorChoosers extends JFrame implements ActionListener {
10 private final JButton botón = new JButton("Seleccionar Color");
11 {
12 botón.addActionListener(this);
13 }
14 public ColorChoosers() {
15 super("ColorChoosers");
16 setContentPane(botón);
18 pack();
20 }
22 /*
23 * Muestra un cuadro de diálogo que permite seleccionar el color,
24 * cuyo padre es este JFrame, su título es "Selecciona el color del
25 * botón" y toma como valor inicial el color actual del botón.
26 */
27 Color c = JColorChooser.showDialog(this,
28 "Selecciona el color del botón", botón.getBackground());
41
29 /*
30 * Define el color de fonde del botón. Esta instrucción funciona para
31 * cualquier componente gráfico. Para cambia el color de letra se
32 * usaría botón.setForeground(c);
33 */
34 botón.setBackground(c);
35 }
39 ColorChoosers frame = new ColorChoosers();
41 }
42 });
43 }
44 }
4.3. Areas de Texto y Diálogos de Impresión.
4.3.1. Ventana.
42

4 import java.text.MessageFormat;
11 import javax.swing.JTextArea;
13
14 public class AreasDeTexto extends JFrame implements ActionListener {
15 // Área de texto que muestra 5 renglones y 10 columnas.
16 private final JTextArea texto = new JTextArea(5, 10);
17 {
18 // Asigna contentido al área de texto.
19 texto.setText("Hola\n"); // \n es un salto de línea.
20 // Agrega contentido al final del área de texto.
21 texto.append("Amigos\n");
22 }
23 private final JScrollPane scroll = new JScrollPane(texto);
24 private final JMenuItem itmContar = new JMenuItem("Contar Caracteres");
25 {
26 itmContar.addActionListener(this);
27 }
28 private final JMenuItem itmImprimir = new JMenuItem("Imprimir");
29 {
30 itmImprimir.addActionListener(this);
31 }
43
33 {
35 }
37 {
38 menuArchivo.add(itmContar);
39 menuArchivo.add(itmImprimir);
41 }
43 {
45 }
46 public AreasDeTexto() {
47 super("Areas de Texto");
51 pack();
53 }
56 if (origen == itmContar) {
57 contar();
58 } else if (origen == itmImprimir) {
59 imprimir();
61 System.exit(0);
62 }
63 }
64 private void contar() {
65 String contenido = texto.getText();
66 JOptionPane.showMessageDialog(this, contenido.length()
67 + " caracteres");
68 }
69 private void imprimir() {
70 // Define el encabezado de la impresión
71 MessageFormat encabezado = new MessageFormat("Ejemplo");
72 /*
73 * Define el pie de página. {0} muestra el número de página y también
74 * se puede poner en el encabezado.
75 */
76 MessageFormat pie = new MessageFormat("Página {0}");
77 try {
78 texto.print(encabezado, pie);
82 }
83 }
44
87 new AreasDeTexto().setVisible(true);
88 }
89 });
90 }
91 }
45
5. Layouts.
Los layouts nos permiten controlar la forma en que los componentes gráficos se despliegan.
5.1. FlowLayout.
Este layout permite colocar los componentes horizontalmente para idiomas occidentales.
Hay diferentes constructores.
public FlowLayout()
Descripción:
Justifica los componentes a la izquierda, dejando 5 pixeles de separación vertical y horizontal entre sus
componentes.
public FlowLayout(int alineación)

Descripción:
Permite indicar la alineación de los componentes, dejando 5 pixeles de separación vertical y horizontal
entre sus componentes. Los valores para la alineación son:
FlowLayout.LEADING - Alineación al inicio del componente.
FlowLayout.CENTER - Centrado.
FlowLayout.TRAILING - Alineación al final del componente.
public FlowLayout(int alineación, int separaciónHorizontal, int separaciónVertical)
46
Este es el layout predeterminado para JPanel; es decir que la instrucción

new JPanel()
crea un panel que emplea como layout el resultado de la expresión

new FlowLayout()
5.1.1. Ventana.
1 import java.awt.FlowLayout;
6
7 public class FlowLayouts extends JPanel {
8 public FlowLayouts() {
9 /*
10 * Crea un panel indicando explícitamente el uso de FlowLayout. Como
11 * es el layout por predeterminado, se puede simplemente omitir la
12 * invocación a super.
13 */
14 super(new FlowLayout());
15 add(new JButton("Hola"));
16 add(new JButton("Mundo"));
17 }
21 JFrame frame = new JFrame("FlowLayout");
22 frame.setContentPane(new FlowLayouts());
23 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
24 frame.pack();
26 }
27 });
28 }
29 }
47
5.2. BorderLayout.
El BorderLayout maneja las siguientes posiciones en occidente.
PAGE_START
LINE_START CENTER LINE_END
PAGE_END
Al aumentar el tamaño de la ventana, el centro crece en altura y anchura, mientras que las posiciones
LINE_START y LINE_END crecen en altura. Estas posiciones se adecuan a las convenciones
utilizadas por otros idiomas.
Están los siguientes constructores:
public BorderLayout()
Descripción:
Crea una distribución de borde que no deja separación entre los componentes.
public BorderLayout(int separacionHorizontal, int separacionVertical)
5.2.1. Ventana.

1 import java.awt.BorderLayout;
6
7 public class BorderLayouts extends JPanel {
8 public BorderLayouts() {
9 // Crea un panel que usa BorderLayout.
10 super(new BorderLayout());
11 add(new JButton("PAGE_START"), BorderLayout.PAGE_START);
48
12 add(new JButton("LINE_START"), BorderLayout.LINE_START);

13 add(new JButton("CENTER"), BorderLayout.CENTER);
14 add(new JButton("LINE_END"), BorderLayout.LINE_END);
15 add(new JButton("PAGE_END"), BorderLayout.PAGE_END);
16 }
20 JFrame frame = new JFrame("BorderLayout");
21 frame.setContentPane(new BorderLayouts());
23 frame.pack();
24 frame.setLocationRelativeTo(null);
26 }
27 });
28 }
29 }
5.3. GridBagLayout.
Permite dar un formato versatil a las ventanas. A cada componente le asocia una instancia de la clase
GridBagConstraints que describe como colocar el componente en el panel y tiene los siguientes
campos:
gridx Número de columna donde está colocado el componente, siendo gridx = 0 la posición más
a la izquierda.
gridy Número renglón donde está colocado el componente, siendo gridy = 0 el renglón superior.
gridwidth Número de columnas del componente. Si no se especifica, el valor es 1.
gridheight Número de renglones del componente. Si no se especifica, el valor es 1.
fill Se usa cuando el área donde se desplegará el componte es más grande que el tamaño
preferido del mismo. Determina como recacular su tamaño. Los valores posibles son:
● GridBagConstraints.NONE (default) - no lo cambia
● GridBagConstraints.HORIZONTAL - Hace que el componente llene toda el área

horizontal, pero no cambia su altura.
● GridBagConstraints.VERTICAL - Hace que el componente llene toda el área
vertical, pero no cambia su ancho.
● GridBagConstraints.BOTH - Ocupa toda el área.
ipadx Indican el relleno horizontal que se agrega dentro de la celda del componente.
ipady Indican el relleno vertical que se agrega dentro de la celda del componente.
49
insets Borde alrededor del componente. Se utiliza un componente de la clase java.awt.Insets, euq
tiene los siguientes campos:
left – Número de pixeles en el borde izquierdo.
top – Número de pixeles en el borde superior.
right – Número de pixeles en el borde derecho.
bottom – Número de pixeles en el borde inferior.
anchor Alinea el componente cuando el área donde se desplegará es más grande que su tamaño y
el valor de fill no es BOTH. Los valores posibles se esquematizan a continuación:
FIRST_LINE_START PAGE_START FIRST_LINE_END
LINE_START CENTER LINE_END
LAST_LINE_START PAGE_END LAST_LINE_END
El valor predeterminado es CENTER.
weightx Crecimiento horizontal. Determina como distribuir espacio cuando la ventana crece a lo
ancho. Si este valor es cero para todos los componentes, estos se centran dentro de la
ventana. Si es mayor a cero para algunos componentes, el espacio horizontal que falta por
asignar se reparte de forma ponderada. Es decir, el valor más grande toma más espacio.
weighty Crecimiento vertical. Determina como distribuir espacio cuando la ventana crece a lo alto.
Si este valor es cero para todos los componentes, estos se centran dentro de la ventana. Si
es mayor a cero para algunos componentes, el espacio vertical que falta por asignar se
reparte de forma ponderada. Es decir, el valor más grande toma más espacio.
Hay otras formas de usar la clase GridBagConstraints, pero esta es la más directa.
50
5.3.1. Ventana.

1 import java.awt.Component;
2 import java.awt.GridBagConstraints;
3 import java.awt.GridBagLayout;
8
9 /**
10 * Este ejemplo crea la siguente distribución:
11 * 0 1 2 - x
12 * +---+---+---+
13 * 0 | | 1 | |
14 * +---+---+---+
15 * 1 | 2 | 3 | 4 |
16 * +---+---+---+
17 * 2 | 5 | |
18 * +---+ 6 |
19 * 3 | 7 | |
20 * +---+-------+
21 * 4 | 8 |
22 * | +-----------+
23 * y
24 */
25 public class GridBagLayouts extends JPanel {
26 private final GridBagConstraints g = new GridBagConstraints();
27 {
28 g.fill = GridBagConstraints.BOTH;
29 }
30 public GridBagLayouts() {
31 super(new GridBagLayout());
32 add(0, 1, 1, 1, new JButton("1"));
33 add(1, 0, 1, 1, new JButton("2"));
34 add(1, 1, 1, 1, new JButton("3"));
35 add(1, 2, 1, 1, new JButton("4"));
36 add(2, 0, 1, 1, new JButton("5"));
51
37 add(2, 1, 2, 2, new JButton("6"));
38 add(3, 0, 1, 1, new JButton("7"));
39 add(4, 0, 1, 3, new JButton("8"));
40 }
41 private void add(int y, int x, int alto, int ancho, Component c) {
42 g.gridy = y;
43 g.gridx = x;
44 g.gridheight = alto;
45 g.gridwidth = ancho;
46 add(c, g);
47 }
51 JFrame frame = new JFrame("GridBagLayout");
52 frame.setContentPane(new GridBagLayouts());
54 frame.pack();
56 frame.setLocationRelativeTo(null);
57 }
58 });
59 }
60 }
5.4. Clase de Ayuda para GridBagLayout.

En este ejemplo, el área de texto crece a lo largo y a lo ancho.
5.4.1. Ventana.
52
5.4.2. Código Fuente de “GBC.java”.

1 import java.awt.GridBagConstraints;
2
3 /**
4 * Esta clase está hecha para simplificar el uso de GridBag Constraints.
5 */
6 public class GBC extends GridBagConstraints {
7 /**
8 * Crea un objeto de GBC alineado a la esquina superior izquierda de la
9 * celda.
10 */
11 public GBC() {
12 anchor = FIRST_LINE_START;
13 }
14 /**
15 * Crea un objeto de GBC de una celda de alto y ancho. El componente que
16 * contiene está alineado a la esquina superior izquierda de la celda.
17 *
18 * @param y
19 * Renglón de la celda.
20 * @param x
21 * Columna de la celda.
22 */
23 public GBC(int y, int x) {
24 gridy = y;
25 gridx = x;
27 }
28 /**
29 * Crea una instancia de GBC. El componente que contiene está alineado a
30 * la esquina superior izquierda de la celda.
31 *
32 * @param y
33 * Renglón de la celda.
34 * @param x
35 * Columna de la celda.
36 * @param alto
37 * Número de renglones que abarca el componente.
38 * @param ancho
39 * Número de columnas que abarca el componente.
40 */
41 public GBC(int y, int x, int alto, int ancho) {
42 gridy = y;
43 gridx = x;
44 gridheight = alto;
45 gridwidth = ancho;
47 }
48 /**
49 * Asigna la alineación del componente
50 *
51 * @param anchor
52 * Alineación del componente.
53
53 *
54 * @return El mismo objeto de GBC que recibió el mensaje.
55 */
56 public GBC anchor(int anchor) {
57 this.anchor = anchor;
58 return this;
59 }
60 /**
61 * Asigna la forma de llenar la celda cuando el componente que contiene
62 * es más pequeño que esta:
63 *
64 * @param fill
65 * Forma de llenar la celda.
66 *
68 */
69 public GBC fill(int fill) {
70 this.fill = fill;
71 return this;
72 }
73 /**
74 * Asigna el ancho del borde de la celda.
75 *
76 * @param arriba
77 * Número de pixeles del borde superior.
78 * @param izquierda
79 * Número de pixeles del borde izquierdo.
80 * @param abajo
81 * Número de pixeles del borde inferior.
82 * @param derecha
83 * Número de pixeles del borde derecho.
85 */
86 public GBC insets(int arriba, int izquierda, int abajo, int derecha) {
87 insets.top = arriba;
88 insets.left = izquierda;
89 insets.bottom = abajo;
90 insets.right = derecha;
91 return this;
92 }
93 /**
94 * Asigna la forma de crecer de la celda.
95 *
96 * @param x
97 * Forma de crecer horizontalmente.
98 * @param y
99 * Forma de crecer verticalmente.
101 */
102 public GBC weight(double x, double y) {
103 weightx = x;
104 weighty = y;
105 return this;
106 }
54
107 }
5.4.3. Código Fuente de “GridBagLayout2.java”.

1 import java.awt.GridBagLayout;
4 import javax.swing.JFormattedTextField;
10 import javax.swing.JTextArea;
13
14 /**
15 * Este ejemplo crea la siguente distribución:
16 * (La letra B significa borde de separación)
17 * (La letra C indica que el componente crece)
18 * 0 1 - x
19 * +-----------------------+----------------+
20 * |BBBBBBBBBBBBBBBBBBBBBBB|BBBBBBBBBBBBBBB |
21 * 0 |B Clave: B| |__________| B |
23 * +-----------------------+----------------+
24 * 1 |B Nombre: B| |____CX____| B |
26 * +-----------------------+----------------+
27 * 2 |B Teléfono: B| |__________| B |
29 * +-----------------------+----------------+
30 * 3 |B Correo Electrónico: B| |__________| B |
32 * +-----------------------+----------------+
33 * 4 |B Fecha Inicial: B| |__________| B |
35 * +-----------------------+----------------+
36 * 5 |B Dirección: B| |___CXY____| B |
38 * | +-----------------------+----------------+
39 * y
40 */
41 public class GridBagLayout2 extends JFrame implements ActionListener {
42 private final JLabel lblClave = new JLabel("Clave:");
43 private final JTextField txtClave = new JFormattedTextField(11);
44 {
45 txtClave.setHorizontalAlignment(JTextField.TRAILING);
46 }
49 private final JLabel lblTeléfono = new JLabel("Teléfono:");
55
50 private final JTextField txtTeléfono = new JTextField(50);
51 private final JLabel lblEmail = new JLabel("Correo Electrónico:");
52 private final JTextField txtEmail = new JTextField(50);
53 private final JLabel lblFecha = new JLabel("Fecha Inicial:");
54 private final JTextField txtFecha = new JTextField(10);
55 private final JLabel lblDirección = new JLabel("Dirección:");
56 private final JTextArea txtDirección = new JTextArea(3, 50);
58 {
60 }
61 private final JPanel panel = new JPanel(new GridBagLayout());
62 {
63 panel.add(lblClave, new GBC(0, 0).insets(12, 12, 12, 12));
64 panel.add(txtClave, new GBC(0, 1).insets(12, 0, 12, 12));
65 panel.add(lblNombre, new GBC(1, 0).insets(0, 12, 12, 12));
66 panel.add(txtNombre, new GBC(1, 1).insets(0, 0, 12, 12)
67 .weight(1.0, 0.0).fill(GBC.HORIZONTAL));
68 panel.add(lblTeléfono, new GBC(2, 0).insets(0, 12, 12, 12));
69 panel.add(txtTeléfono, new GBC(2, 1).insets(0, 0, 12, 12)
70 .weight(1.0, 0.0));
71 panel.add(lblEmail, new GBC(3, 0).insets(0, 12, 12, 12));
72 panel.add(txtEmail, new GBC(3, 1).insets(0, 0, 12, 12)
73 .weight(1.0, 0.0));
74 panel.add(lblFecha, new GBC(4, 0).insets(0, 12, 12, 12));
75 panel.add(txtFecha, new GBC(4, 1).insets(0, 0, 12, 12));
76 panel.add(lblDirección, new GBC(5, 0).insets(0, 12, 12, 12));
77 panel.add(new JScrollPane(txtDirección), new GBC(5, 1)
78 .insets(0, 0, 12, 12).fill(GBC.BOTH).weight(1.0, 1.0));
79 }
80 public GridBagLayout2() {
81 setTitle("Ejemplo mejorado de GridBagLayout");
82 setContentPane(new JScrollPane(panel));
84 pack();
85 }
87 System.exit(0);
88 }
92 new GridBagLayout2().setVisible(true);
93 }
94 });
95 }
96 }
56

Java Grafico

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Java Grafico

Загружено:

Авторское право:

Доступные форматы

Introducción a

Por: Gilberto Pacheco Gallegos

Copyright © 2008 Gilberto Pacheco Gallegos

El escritorio también nos da acceso a programas de aplicación y herramientas para manipular la

1.1. Objetos y Propiedades.

pantallas de bienvenida, que se muestran brevemente mientras la aplicación inicia y despliega la

1.3. Construcción de Interfaces Gráficas en Java.

1.4. Componentes Gráficos.

1.9. Primer Programa.

1.9.2. Salida de Texto

public GridLayout(int renglones, int columnas)

public GridLayout(int renglones, int columnas, int sepHorizontal, int sepVertical)

1.11.2. Código Fuente.

En la práctica, las ventanas de aplicación se manejan usando barras de menú.

1.12.2. Código Fuente.

2.1. Cuadros de Texto Con Formato (Enteros).

2.1.2. Código Fuente.

16 private final JLabel lblNúmero = new JLabel("Número:");

2.2. Texto con Formato (Números en General)

2.2.2. Código Fuente.

2.3.2. Código Fuente.

2.4. Cuadros Combinados

2.4.2. Código Fuente.

77 } else if (origen == cmbOrigen) {

3.1. Tablas con Arreglos Bidimensionales.

3.1.2. Código Fuente del Modelo.

3.1.3. Código Fuente de la Interfaz.

3.2. Tablas con Arreglos de referencias.

3.2.1. Código Fuente de “Proveedor.java”.

32 public String getTeléfono() {

3.2.2. Código Fuente del Modelo.

3.2.3. Código Fuente de la interfaz.

4.1. Cuadros de Diálogo Predefinidos.

4.2. Cuadros de Selección de Color.

4.2.2. Código Fuente.

4.3. Areas de Texto y Diálogos de Impresión.

4.3.2. Código Fuente.

public FlowLayout(int alineación)

public FlowLayout(int alineación, int separaciónHorizontal, int separaciónVertical)

Este es el layout predeterminado para JPanel; es decir que la instrucción

crea un panel que emplea como layout el resultado de la expresión

5.1.2. Código Fuente.

LINE_START CENTER LINE_END

public BorderLayout(int separacionHorizontal, int separacionVertical)

5.2.2. Código Fuente.

12 add(new JButton("LINE_START"), BorderLayout.LINE_START);

gridwidth Número de columnas del componente. Si no se especifica, el valor es 1.

gridheight Número de renglones del componente. Si no se especifica, el valor es 1.

● GridBagConstraints.HORIZONTAL - Hace que el componente llene toda el área

LINE_START CENTER LINE_END

LAST_LINE_START PAGE_END LAST_LINE_END

El valor predeterminado es CENTER.

5.3.2. Código Fuente.

5.4. Clase de Ayuda para GridBagLayout.

5.4.2. Código Fuente de “GBC.java”.

5.4.3. Código Fuente de “GridBagLayout2.java”.

Вам также может понравиться