Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
Introducción a la programación JAVA
Introducción a la programación JAVA 1
Prólogo 2
Pedagogía 2
Iconos 2
3 Fundamentos de Java 2
3.14 Constantes 2
Constantes nombradas 2
6 Programación orientada a objetos 3
6.2 Introducción a la programación orientada a objetos 3
16 Fundamentos de programación GUI 3
16.2 Fundamentos de programación de manejo de eventos 3
16.3 Un sencillo programa de ventanas 3
16.4 Clase JFrame 4
Fundamentos de la clase JFrame 4
Métodos JFrame 4
16.5 Componentes en Java 5
16.6 Componente JLabel 5
Interfaz de usuario 5
Implementación 5
Métodos 5
16.7 Componente JTextField 5
Interfaz de usuario 5
Implementación 6
Métodos 6
16.8 Programa Saludo 6
16.9 Componente oyentes 8
Cómo implementar un oyente 9
La interfaz ActionListener 9
public void actionPerformed(ActionEvent e) 9
16.10 Clases internas 9
16.11 Clases internas anónimas 10
16.12 Componente JButton 12
Interfaz de usuario 12
Implementación 12
Métodos 12
Programa FactorialButton 13
16.16 Color 15
Métodos Color 15
Constantes Color nombradas 15
Objetos Color 15
Color de fondo JFrame 15
Programa ColorChooser 15
Resumen 15
Preguntas de revisión 1
Soluciones a las preguntas de revisión 1
Referencias: 1
16 Fundamentos de programación GUI
16.2 Fundamentos de programación de manejo de eventos
16.3 Un sencillo programa de ventanas
16.4 Clase JFrame
16.5 Componentes en Java
16.6 Componente JLabel
16.8 Programa Saludo
16.7 ComponenteJTextField
16.9 Componente oyentes
16.12 ComponenteJButton
(55) 6878 0924 https://ccienciasti.github.io/Web/
1
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
16.16 Color
Resumen
Preguntas de revisión
17 Programación GUI: distribución de componentes, componentes
GUI adicionales
17.9 ClaseJPanel
17.12 ComponenteJCheckBox
17.13 ComponenteJRadioButton
17.16 Más componentes de Swing
Resumen
Preguntas de revisión
Prólogo
Pedagogía
Iconos
Elegancia de programa.
Indica que el texto asociado se relaciona con estilo de
codificación del programa, legibilidad, mantenimiento,
robustez y escalabilidad. La elegancia en un programa
comprende estas cualidades.
Resolución de problema.
Indica que el texto asociado tiene que ver con temas de
resolución de problemas. Los comenta- rios asociados con el
icono intentan generalizar el material realzado en el texto
adyacente.
Errores comunes.
Indica que el texto asociado se relaciona con errores
comunes.
Hipervínculo meta.
Indica la meta final del hipervínculo.
Eficiencia de programa.
Indica que el texto asociado se refiere a problemas de
eficiencia en el programa.
3 Fundamentos de Java
3.14 Constantes
Constantes nombradas
Una constante nombrada es una que tiene un nombre asociado. Por
ejemplo, en este fragmento de código, VELOCIDAD_DE_LUZ es una
constante nombrada.
final double VELOCIDAD_DE_LUZ = 299792458.0; // en
metros/seg
...
retrasoPropagacion = distancia / VELOCIDAD_DE_LUZ;
La palabra reservada final es un modificador: modifica
VELOCIDAD_DE_LUZ para que su valor quede como fijo o “final”. Y al ser
fijado es el punto completo de una constante nombrada final. El
modificador final le indica a la computadora que genere un error si el
(55) 6878 0924 https://ccienciasti.github.io/Web/
2
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
programa intenta cambiar el valor de la variable final en un momento
posterior.
Las convenciones de codificación estándar sugieren que se
pongan en mayúsculas todos los caracteres en una constante
nombrada y que se utilice un guión bajo para separar las
palabras en una constante de múltiples palabras. Ejemplo:
VELOCIDAD_DE_LUZ. La razón de que se usen mayúsculas es
que re- saltan las cosas. Y lo que se desea es que las
constantes nombradas llamen la atención porque represen-
tan valores especiales.
6 Programación orientada a objetos
6.2 Introducción a la programación orientada a objetos
Las variables de instancia de una clase especifican el tipo de dato que
un objeto puede almacenar. Por ejemplo, se tiene un objeto computadora
que almacena el valor del tamaño del disco duro de la computadora.
16 Fundamentos de programación GUI
16.2 Fundamentos de programación de manejo de
eventos
● Un oyente es un objeto que espera la ocurrencia de eventos.
● Un manipulador de eventos es un método que responde a un
evento.
Figura 16.2 Lo que ocurre cuando se oprime un botón.
16.3 Un sencillo programa de ventanas
import javax.swing.*; // for JFrame, JLabel
import java.awt.*; // for FlowLayout
public class SimpleWindow extends JFrame{
private static final int WIDTH = 250;
private static final int HEIGHT = 100;
public SimpleWindow() {
setTitle("Simple Window");
setSize(WIDTH, HEIGHT);
setLayout(new FlowLayout());
setDefaultCloseOperation(EXIT_ON_CLOSE);
createContents();
setVisible(true);
} // end SimpleWindow constructor
private void createContents() {
JLabel label = new JLabel("Hi! I'm Larry the
label!");
add(label);
} // end createContents
(55) 6878 0924 https://ccienciasti.github.io/Web/
3
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
public static void main(String[] args) {
System.out.println("Hello World!");
new SimpleWindow();
}
}
Figura 16.4 Sencillo programa de ventanas y su salida.
16.4 Clase JFrame
Fundamentos de la clase JFrame
La clase JFrame implementa las características estándar de las ventanas
que llegan a conocerse y quererse.
Para que extends JFrame funcione, es necesario importar la clase
JFrame o importar el paquete javax.swing de JFrame.
La clase JFrame se denomina contenedor porque contiene componentes
(como etiquetas, botones, menús, etc.). Hereda la capacidad de contener
componentes de su superclase, la clase Container.
Métodos JFrame
● El método setTitle muestra una cadena especificada en la barra
de título de la ventana actual.
● El método setSize asigna el ancho y la altura de la ventana actual.
resolución de la pantalla. Dos valores de resolución comunes son de 800
por 600 y de 1024 por 768.
El método setLayout asigna un gestor de disposición a la ventana actual.
FlowLayout: Provoca que los componentes se ubiquen en la parte central
superior.
CloseOperation(EXIT_ON_CLOSE) cuando el usuario hace clic en el
botón para cerrar la ventana, ésta se cierra y el programa termina.
El método add agrega un componente especificado a la ventana actual.
private void createContents()
{
JLabel label = new JLabel("Hi! I'm Larry the label!");
(55) 6878 0924 https://ccienciasti.github.io/Web/
4
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
add(label);
} // end createContents
Las ventanas son invisibles por defecto. Para hacer visibles una ventana y
su contenido, es necesario agregar los componentes a la ventana y
después llamar setVisible (true).
16.5 Componentes en Java
● JLabel, JTextField, JButton,
● JTextArea, JCheckBox, JRadioButton, JComboBox
● JMenuBar, JMenu, JMenuItem
Todas las clases de los componentes anteriores están en el paquete
javax.swing, por lo que es necesario importar este paquete a fin de
usarlo.
Junto con muchos otros métodos, la clase JComponent contiene métodos
que manejan estas características de los componentes:
• colores en primer plano y de fondo
• fuente de texto
• apariencia de los límites
• sugerencias de herramientas
• foco
16.6 Componente JLabel
Interfaz de usuario
Muestra una sola línea de texto que se ha especificado.
Implementación
Para crear un objeto JLabel, el constructor JLabel se llama así:
JLabel <JLabel-reference> = new JLabel(<label-text>);
La clase JLabel requiere el paquete javax.swing
Métodos
Los métodos de acceso y regulador getText y el setText.
public String getText()
Devuelve el texto de la etiqueta.
public void setText(String text)
Asigna el texto de la etiqueta.
16.7 Componente JTextField
Interfaz de usuario
JTextField muestra un rectángulo y permite que el usuario introduzca
texto en el rectángulo.
(55) 6878 0924 https://ccienciasti.github.io/Web/
5
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
Implementación
constructor JTextField se llama así:
JTextField <JTextField-reference> = new
JTextField(<default-text>, <width>);
opcional: default, width
El default-text es el texto que aparece en la ventana de diálogo por
defecto. El ancho es el número de caracteres que es posible mostrar.
Si se omite el texto por defecto, entonces la cadena vacía se usa como el
valor por defecto. Si se omite el argumento del ancho, entonces el ancho
de la ventana es ligeramente mayor que el ancho del texto por defecto.
Para agregar un objeto JTextField a la ventana JFrame, se usa esta
sintaxis:
add(<JTextField-reference>);
La clase JTextField requiere el paquete javax.swing.
Métodos
public String getText()
Devuelve el contenido de la ventana de texto.
public void setText(String text)
Asigna el contenido de la ventana de texto.
public void setEditable(boolean flag)
Hace editable o no editable la ventana de texto.
public void setVisible(boolean flag)
Hace visible o invisible la ventana de texto.
public void addActionListener(ActionListener listener)
Agrega un oyente a la ventana de texto.
JTextField llama a addActionListener, la JVM vincula un objeto oyente
a la ventana de texto, lo cual permite que el programa responda cuando el
usuario presiona Enter dentro de la ventana de texto.
16.8 Programa Saludo
Lee el nombre del usuario de una ventana de texto (componente
JTextField) y muestra el nombre introducido en una etiqueta (un
componente JLabel).
Constructor que contiene llamadas a setTitle, setSize, setLayout,
setDefaultCloseOperation y setVisible.
Nuevo: Ventana de texto y un manipulador de eventos.
Ventana de texto nameBox .Se ha declarado como una variable de
instancia en la parte superior de la clase.
Es necesario acceder a nameBox no sólo en createContents, sino
también en el manipulador de eventos actionPerformed
nameBox se declara como una variable de instancia. El mismo
razonamiento es válido para la etiqueta greeting.
El manipulador de eventos actionPerformed del programa Saludo
especifica lo que ocurre cuando el usuario oprime Enter dentro de la
ventana de texto.
Observe que el método actionPerformed está dentro de la clase
Listener.
(55) 6878 0924 https://ccienciasti.github.io/Web/
6
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
package com.mycompany.greeting;
/**
*
* @author evja4
*/
/*********************************************************
****
* Greeting.java
* Dean & Dean
*
* Este programa muestra ventanas de texto y etiquetas.
Cuando el usuario
* oprime Enter después de escribir algo en la ventana de
diálogo, el valor
* de la ventana de diálogo muestra la etiqueta que se
muestra a continuación.
**********************************************************
***/
import javax.swing.*; // for JFrame, JLabel, JTextField
import java.awt.*; // for FlowLayout
import java.awt.event.*; // for ActionListener,
ActionEvent
public class Greeting extends JFrame {
private static final int WIDTH = 325;
private static final int HEIGHT = 100;
private JTextField nameBox; // contiene el nombre del
usuario private
JLabel greeting; // saludos personalizados
//********************************************************
**
public Greeting() {
setTitle("Greeting");
setSize(WIDTH, HEIGHT);
setLayout(new FlowLayout());
setDefaultCloseOperation(EXIT_ON_CLOSE);
createContents();
setVisible(true);
} // end constructor
//********************************************************
**
// Create components and add them to window.
private void createContents()
{
JLabel namePrompt = new JLabel("¿Cómo te
llamas?");
nameBox = new JTextField(15);
greeting = new JLabel();
add(namePrompt);
add(nameBox);
add(greeting);
nameBox.addActionListener(new Listener());
} // end createContents
//********************************************************
**
// Inner class for event handling.
(55) 6878 0924 https://ccienciasti.github.io/Web/
7
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
private class Listener implements ActionListener {
public void actionPerformed(ActionEvent e) {
String message; // the personalized greeting
message = "Glad to meet you, " +
nameBox.getText()+ "!";
nameBox.setText("");
greeting.setText(message);
} // end actionPerformed
}// end class Listener
public static void main(String[] args) {
new Greeting();
System.out.println("Hello World!");
}
}
Figura 16.5a-b Programa Saludo
4. Este paquete se importa para manipulación de eventos:
import java.awt.event.*; // for ActionListener, ActionEvent
3. Registra un oyente:
nameBox.addActionListener(new Listener());
1. encabezado de la clase interna.
private class Listener implements ActionListener
2. manipulador de eventos
public void actionPerformed(ActionEvent e) {
String message; // the personalized greeting
message = "Glad to meet you, " + nameBox.getText()+
"!";
nameBox.setText("");
greeting.setText(message);
} // end actionPerformed
Después de oprimir Enter en la ventana de diálogo:
16.9 Componente oyentes
Cuando el usuario interactúa con un componente (por ejemplo, cuando el
usuario hace clic en un botón u oprime Enter mientras está en una
ventana de texto), el componente activa un evento.
(55) 6878 0924 https://ccienciasti.github.io/Web/
8
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
Cómo implementar un oyente
Estos pasos corresponden a las llamadas numeradas en las figura
16.5a-b:
1. Definir una clase con una cláusula ActionListener agregada a la
derecha del encabezado de la clase.
2. Incluir un método manipulador de eventos actionPerformed en su
clase oyente. Ésta es una estructura de un método actionPerformed
dentro de una clase oyente:
private class Listener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
<do-something>
}
}
Inclusive si su método actionPerformed no usa un parámetro
ActionEvent (e, arriba), sigue siendo necesario incluir ese parámetro en
el encabezado del método para hacer que su método se ajuste a los
requerimientos de un oyente.
Listener no es una palabra reservada.
3. Registre su clase oyente
<text-box-component>.addActionListener(new <listener-class>());
4. Importe el paquete java.awt.event.
interfaz ActionListener y de la clase ActionEvent.
La interfaz ActionListener
En el programa Saludo, implements ActionListener se implementó en
el encabezado de la clase oyente.
Una interfaz es algo así como una clase que contiene variables y métodos.
Pero a diferencia de una clase, sus variables deben ser constantes (es
decir, variables final) y sus métodos deben estar vacíos (es decir,
encabezados de métodos).
Todos los oyentes de eventos de acción implementarán un método de
ActionListener: el método actionPerformed. Y al implementar ese
método, están obligados a usar este encabezado prescrito:
public void actionPerformed(ActionEvent e)
16.10 Clases internas
Ejemplo:
public class Greeting extends JFrame
{
...
private class Listener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
String message; // el mensaje de saludo
personalizado
message = "Mucho gusto, " +
nameBox.getText();
nameBox.setText("");
(55) 6878 0924 https://ccienciasti.github.io/Web/
9
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
greeting.setText(message);
} // end actionPerformed
} // end class Listener
...
} // end class Greeting
¡La clase Listener está dentro de la clase Greeting!
Clase interna (una clase que está dentro de otra clase). Puesto que un
escucha normalmente está limitado a escuchar justo una clase, los
oyentes usualmente se implementan como clases internas.
Aunque no es necesario para el compilador, las clases internas
normalmente deben ser private. Prosigue el objetivo del
encapsulamiento
Clase de nivel superior (una clase de nivel superior es la
expresión formal de una clase regular: una clase que no está
definida dentro de otra clase). Una clase interna puede acceder
directamente a sus variables de instancia de la clase que la
contiene.
16.11 Clases internas anónimas
En el programa Greeting se implementó una clase oyente denominada
Listener, usando este código:
private class Listener implements ActionListener
{
Ese código se omitió en el programa GreetingAnonymous: no hay clase
denominada Listener. Pero sigue siendo necesario un objeto oyente de
modo que el evento de entrada en la ventana de texto sea acep- tado y se
actúe sobre él. Esta vez, en lugar de declarar una clase oyente con un
nombre (por ejemplo, Listener), se implementa una clase oyente en
forma anónima (sin nombre).
Los objetos anónimos son cuando se instancia un objeto sin almacenar su
referencia en una variable. En el programa Greeting previo, se instanció un
objeto anónimo Listener con esta línea:
nameBox.addActionListener(new Listener());
Evita que se enrede el código con el nombre de una variable cuando se
requiere usar un objeto sólo una vez.
/*********************************************************
** * GreetingAnonymous.java
* Dean & Dean
*
* Este programa demuestra una clase interna anónima.
**********************************************************
*/
import javax.swing.*; // for JFrame, JLabel, JTextField
import java.awt.*; // for FlowLayout
import java.awt.event.*; // for ActionListener,
ActionEvent
public class GreetingAnonymous extends JFrame
{
private static final int WIDTH = 325;
private static final int HEIGHT = 100;
(55) 6878 0924 https://ccienciasti.github.io/Web/
10
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
private JTextField nameBox; // contiene el nombre del
usuario
private JLabel greeting; // saludo personalizado
//********************************************************
public GreetingAnonymous() {
setTitle("Greeting Anonymous"); setSize(WIDTH, HEIGHT);
setLayout(new FlowLayout());
setDefaultCloseOperation(EXIT_ON_CLOSE);
createContents();
setVisible(true);
} // end constructor
//********************************************************
*
// Crea componentes y las agrega a la ventana.
private void createContents()
{
JLabel namePrompt = new JLabel("¿Cómo te llamas?");
nameBox = new JTextField(15);
greeting = new JLabel();
add(namePrompt);
add(nameBox);
add(greeting);
nameBox.addActionListener(
// anonymous inner class for event handling
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
String message; // the personalized greeting
message = "Mucho gusto, " + nameBox.getText();
nameBox.setText("");
greeting.setText(message);
} // end actionPerformed
} // end anonymous inner class
); // end addActionListener call
} // end createContents
//********************************************************
*
public static void main(String[] args)
{
new GreetingAnonymous();
} // end main
} // end class GreetingAnonymous
ActionListener es una interfaz:
new ActionListener()
nameBox.addActionListener(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
…
} // end actionPerformed
} // end anonymous inner class
); // end addActionListener call
clase interna (no anónima):
(55) 6878 0924 https://ccienciasti.github.io/Web/
11
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
private void createContents()
{
...
nameBox.addActionListener(new Listener());
} // end createContents
private class Listener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
...
} // end actionPerformed
} // end class Listener
Entre los dos fragmentos de código sólo hay dos diferencias sintácticas: la
llamada a addActionListener y el encabezado de la clase oyente.
16.12 Componente JButton
Interfaz de usuario
Si un componente botón GUI se oprime o se hace clic en él, normalmente
ocurre algo.
Implementación
constructor JButton se llama así:
JButton helloButton = new JButton("Oprímeme");
Texto de la etiqueta del botón:
"Oprímeme"
Si se omite, la etiqueta obtiene la cadena vacía por defecto.
Después que se crea el botón helloButton, debe agregarse a la ventana
como se muestra a continuación:
add(helloButton);
Los oyentes botón deben implementar la interfaz ActionListener.
private class Listener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
<do-something>
}
}
Se está usando una clase interna nombrada en lugar de una clase
interna anónima porque las clases internas nombradas son ligeramente
más flexibles. Permiten crear un oyente que se utiliza en más de un
componente.
Para registrar el oyente
helloButton.addActionListener(new Listener());
La clase JButton necesita el paquete javax.swing
Métodos
Encabezados y las descripciones API (Application Programming Interface):
(55) 6878 0924 https://ccienciasti.github.io/Web/
12
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
public String getText()
Devuelve la etiqueta del botón.
public void setText(String text)
Asigna la etiqueta del botón.
public void setVisible(boolean flag)
Hace visible o invisible el botón.
public void addActionListener(ActionListener listener)
Agrega un oyente al botón. El oyente “escucha” cuando se hace clic en el
botón.
Programa FactorialButton
Programa FactorialButton usa un componente JButton para calcular el
factorial de un número introducido por el usuario.
Después de oprimir Enter en la ventana x o hacer clic en el botón
Factorial:
Figura 16.7 Sesión muestra para el programa FactorialJButton.
(55) 6878 0924 https://ccienciasti.github.io/Web/
13
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
/****************************************************
* FactorialButton.java
* Dean & Dean
* Cuando el usuario hace clic en el botón u oprime Enter en la ventana
de texto de
* entrada, el factorial del número introducido aparece en la ventana de
texto de salida.
************************************************************/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class FactorialButton extends JFrame
{
private static final int WIDTH = 300;
private static final int HEIGHT = 100;
private JTextField xBox; // contiene la entrada del usuario
private JTextField xfBox; // contiene el factorial generado
//*********************************************************
public FactorialButton() {
setTitle("Factorial Calculator"); setSize(WIDTH, HEIGHT);
setLayout(new FlowLayout());
setDefaultCloseOperation(EXIT_ON_CLOSE);
createContents();
setVisible(true);
} // end FactorialButton constructor
//*********************************************************
private void createContents()
{
JLabel xLabel = new JLabel("x:");
JLabel xfLabel = new JLabel("x!:");
JButton btn = new JButton("Factorial");
Listener listener = new Listener();
xBox = new JTextField(2);
xfBox = new JTextField(10);
xfBox.setEditable(false); add(xLabel);
add(xBox);
add(xfLabel);
add(xfBox);
add(btn);
xBox.addActionListener(listener);
btn.addActionListener(listener);
} // end createContents
//****************************************************
// Clase interna para manipulación de eventos.
private class Listener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
int x; // valor numérico para x introducido por el usuario
int xf; // x factorial
try
{
x = Integer.parseInt(xBox.getText());
}
catch (NumberFormatException nfe)
{
x = -1; // indica una x inválida
}
if (x < 0)
{
xfBox.setText("undefined");
}
else
{
(55) 6878 0924 https://ccienciasti.github.io/Web/
14
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
if (x == 0 || x == 1)
{
xf = 1;
}
else
{
xf = 1;
for (int i=2; i<=x; i++)
{
xf *= i;
}
} // end else
xfBox.setText(Integer.toString(xf)); } // end else
} // end actionPerformed
} // end class Listener
//****************************************************
public static void main(String[] args) {
new FactorialButton();
} // end main
} // end class FactorialButton
Figura 16.8a Programa FactorialButton, parte A y B.
Aquí se registra el mismo oyente con dos componentes distintos.
16.16 Color
.
Métodos Color
.
Constantes Color nombradas
.
Objetos Color
.
Color de fondo JFrame
.
Programa ColorChooser
.
Resumen
• La clase JFrame debe usarse como la superclase para casi todas las
ventanas de aplicación GUI.
• La clase JFrame implementa todas las características de las ventanas,
como límites, barra de título, botón para minimizar, botón de cierre (la “X”),
la capacidad de ajustar la ventana, etcétera.
• JLabel es un componente de sólo lectura; el usuario simplemente lee el
mensaje de la etiqueta.
• El componente JTextField permite que el usuario introduzca texto en
una ventana de texto.
• Cuando el usuario interactúa con un componente (por ejemplo, al hacer
clic en un botón u oprimir Enter mientras está en una ventana de texto), el
componente activa un evento.
• Si un componente tiene conectado un oyente, el evento activado es
“escuchado” por el oyente y en consecuencia, es manipulado por el
oyente.
• Un oyente manipula un evento al ejecutar su método actionPerformed
manipulador de eventos.
(55) 6878 0924 https://ccienciasti.github.io/Web/
15
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
• A menudo, los oyentes se implementan con la interfaz ActionListener.
Una interfaz es un ente semejante a una clase cuyos métodos, todos,
están vacíos. Si un programador usa una clase para derivar una nueva
clase, el compilador requiere que la nueva clase implemente métodos para
todos los métodos de la interfaz.
• Si una clase está limitada en su alcance de modo que sólo es necesaria
para otra clase, entonces es necesario definir la clase como una clase
interna (una clase dentro de otra clase).
• Una clase interna anónima es una clase interna sin nombre.
• Para mostrar una simple ventana con un mensaje, es necesario llamar al
método showMessageDialog de JOptionPane.
• Para identificar el componente cuyo evento fue activado, utilice el
parámetro ActionEvent del método actionPerformed para llamar a
getSource o a getActionCommand.
• Para ajustar el color del texto de un componente GUI, llame a
setForeground. Para ajustar el color detrás del texto, llame a
setBackground.
• Para ajustar el color de fondo de una ventana, llame al método
setBackground del panel de contenido.
• Para detectar y manipular eventos de ratón, es necesario usar las clases
MouseAdapter y MouseMotionAdapter, que implementan las interfaces
MouseListener y MouseMotionListener, respectivamente.
Preguntas de revisión
§16.2 Fundamentos de programación de manejo de eventos
1. ¿Qué es un oyente?
2. ¿Qué es un manipulador de eventos?
§16.3 Un sencillo programa de ventanas
3. Escriba una declaración que agregue funcionalidad a un botón de cierre
de una ventana de modo que al hacer clic en ese botón se provoque la
terminación del programa.
§16.4 Clase JFrame
4. ¿Cuál es el nombre de la superclase para las clases que contienen
componentes?
§16.5 Componentes en Java
5. ¿Cuántos otros componentes tienen prefijo J?
§16.6 Componente JLabel
6. Proporcione una declaración de inicio que declare una variable de
referencia nombrada hello y que asigne "Hello World" a la variable de
referencia.
§16.7 Componente JTextField
7. Proporcione una declaración de inicio que instancie un objeto en una
ventana de texto de 10 caracteres de ancho. Como parte de la iniciación,
asigne el objeto de la ventana de texto a una variable de referencia
denominada input.
§16.9 Componente oyentes
8. Escriba una declaración que registre una variable de referencia oyente
denominada responder con un componente nombrado component.
9. Si se desea que una clase manipule un evento,¿qué cláusula debe
agregarse al lado derecho del encabezado de la clase?
10.¿Cuál es el encabezado de un método especificado por la interfaz
ActionListener?
§16.12 Componente JButton
13. En el método createContents del programa FactorialButton de la
figura 16.8a, ¿qué tipo de objeto llama a los métodos add?
14. En el programa FactorialButtom de las figuras 16.8a y 16.18b, ¿qué
componente activa el evento que manipula el oyente?
§16.16 Color
19. Escriba una declaración que establezca el color del texto en azul para
un objeto JButton denominado button1.
20. ¿Cómo se obtiene una referencia al contenedor que rodea todos los
componentes en un objeto JFrame?
(55) 6878 0924 https://ccienciasti.github.io/Web/
16
Centro de Ciencias Tecnología e Idiomas | Java | Diciembre 2023
Soluciones a las preguntas de revisión
1. Un oyente es un objeto que espera la ocurrencia de eventos.
2. Un manipulador de eventos es un método que responde a un evento.
3. setDefaultCloseOperation(EXIT_ON_CLOSE);
4. La superclase para objetos que contienen otros objetos es la clase
Container.
5. Muchos componentes que tienen el prefijo J están definidos en el
paquete javax.swing.
6. JLabel hello = new JLabel("Hello World!");
7. JTextField input = new JTextField(10);
8. component.addActionListener(responder);
9. Para que una clase manipule un evento, es necesario agregar esto al
lado derecho del encabezado de la clase: implements ActionListener
10. El encabezado del método especificado por la interfaz
ActionListener es:
public void actionPerformed(ActionEvent e)
13. El objeto que llama a los métodos add es un objeto JFrame.
14. Es ambiguo. Puede ser xBox o btn.
19. button1.setForeground(Color.BLUE);
20. Llamando al método getContentPane de JFrame.
Referencias:
1. John S. Dean, Raymond H. Dean Introducción a la programación
JAVA, McGrawHill
2. Java Tutorial https://www.w3schools.com/java/default.asp
3. Java™ Platform, Standard Edition 6 API Specification
https://docs.oracle.com/javase/6/docs/api/
(55) 6878 0924 https://ccienciasti.github.io/Web/
17
