Tópicos Avanzados de Programación

Unidad 2
Componentes y librerías

INSTRUCTOR
M.C. Octavio A. Ríos Tercero
ene-jun 2018
 Introducción a Eventos

– Un evento es algo que desencadena una acción

• Pulsación de una tecla
• Click de un ratón
• Modificación de un texto
• Se cumple determinado tiempo
 Introducción a Eventos

Para que un evento sea gestionado, se requiere la

participación de diferentes elementos
 Introducción a Eventos

• Event Source
– Es la fuente del evento, es decir, el objeto donde se produce el
evento

Cuando ocurre el evento, el objeto fuente envía la notificación a los

objetos listeners (oyentes) que están registrados a esa fuente.

Los “Event Sources” tienen métodos que nos permiten registrar a

los objetos que van a actuar como “Lísteners”.
 Introducción a Eventos

• Event Object
– Un objeto Evento encapsula la información acerca del evento
ocurrido.
– Este objeto se crea automáticamente al ocurrir el evento.

Diferentes “Event
Sources” pueden
producir diferentes
tipos de eventos.
 Introducción a Eventos

• Listener
– Es el objeto que es activado cuando ocurre el evento y recibe al
“Event Object” generado por el “Event Source”.
– El objeto “oyente” es una instancia de una clase que implementa
una interfaz llamada “listener interface”
 Introducción a Eventos
• El modelo de delegación de eventos de AWT
 Introducción a Eventos

• Ejemplo de una menejo de eventos

 Ejercicio: Colores
Programa que muestra un solo botón que al ser pulsado pone el fondo de un color.
 Ejercicio: Colores
• Clase ButtonPanel

import java.awt.Color;
import java.awt.event.*;
import javax.swing.*;

class ButtonPanel extends Jpanel

{
public ButtonPanel()
{
JButton yellowButton = new JButton("Yellow");
add(yeColorActionExt yellowAction = new
ColorActionExt(Color.YELLOW,this);
yellowButton.addActionListener(yellowAction);
llowButton);
}
}

Se crea un Jpanel personalizado (ButtonPanel), que contiene:

• Un objeto JButton que actuará como el Event Source (yellowButton),
• Un objeto ColorActionExt que actuará como Listener (yellowAction).

Se registra el listener a yellowButton mediante el método addActionListener()

 Ejercicio: Colores
• Clase ColorActionExt
public class ColorActionExt implements ActionListener
{
private Color backgroundColor;
private Component comp;

public ColorActionExt(Color c, Component comp)

{
this.backgroundColor = c;
this.comp=comp;
}

public void actionPerformed(ActionEvent event)

{
comp.setBackground(backgroundColor);
}
}

• Se crea la clase que va a actuar como listener

• Esta clase implementa a la interfaz ActionListener
• Su constructor recibe el color con que se pintará el Panel, y la referencia del Panel (tipo
Component).
• Se define el método actionPerformed() el cual será activado cuando ocurra el evento.
Este método recibe el Event Object.
 Ejercicio: Colores
• Clase ButtonFrame
import javax.swing.JFrame;

class ButtonFrame extends Jframe

{
public static final int DEFAULT_WIDTH = 300;
public static final int DEFAULT_HEIGHT = 200;

public ButtonFrame()
{
setTitle("ButtonTest");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

ButtonPanel panel = new ButtonPanel();

add(panel);
}
}

Se crea un Jframe personalizado (ButtonFrame),

En el constructor:
• se asigna un título
• se definen las dimensiones del Frame
• Se crea un objeto ButtonPanel (panel) y se agrega al Frame con add()
 Ejercicio: Colores
• Clase ButtonTest
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ButtonTest{

public static void main(String[] args)
{ ButtonFrame frame = new ButtonFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}

Se crea la clase de control (ButtonTest)

Dentro de main():
• Se crea el Frame
• Se configura el cierre de la ventana
• Se hace visible el Frame.
 Ejercicio: Colores

Ejercicio (fue el 1.4)

a) Modifica el programa para que tenga otros dos botones

que permitan pintar el fondo de Rojo y Azul.
b) Agregar un TexField y un botón para que cuando el botón
sea pulsado, el título de la ventana se cambie al valor del
TextField.
c) Realiza la demostración ante el profesor, explicando los
cambios realizados.
 Ejercicio: Sumador
Programa que realiza la suma de dos números. Utiliza 2 campos TexField para los valores a
sumar, un campo Label para mostrar el operador suma, el botón para realizar la suma, y otro
Label para la respuesta.
 Ejercicio: Sumador
Clase PanelSuma

import javax.swing.*;

public class PanelSuma extends JPanel{

// atributos de la clase
JTextField campo1, campo2;
JLabel mas,resultado;
JButton btnIgual;

public PanelSuma()
{
// creación de los elementos
campo1= new JTextField("0",5);
campo2= new JTextField("0",5);
mas= new JLabel("+");
btnIgual=new JButton("=");
resultado= new JLabel("0");

// se agregan los elementos al panel

add(campo1); add(mas); add(campo2); add(btnIgual); add(resultado);

// creación del objeto Listener

SumaAction listener= new SumaAction(this);

// agregar el Listener al botón

btnIgual.addActionListener(listener);
}
}
 Ejercicio: Sumador
Clase SumaAction

import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class SumaAction implements ActionListener{

private PanelSuma comp;
public SumaAction(PanelSuma comp){
this.comp=comp;
}
public void actionPerformed(ActionEvent e){
// obtiene los valores a sumar
String cad1= comp.campo1.getText();
String cad2= comp.campo2.getText();

// convierte a enteros los valores a sumar

int c1=Integer.parseInt(cad1);
int c2=Integer.parseInt(cad2);

// Realiza la suma, convierte a cadena y deposita en resultado

comp.resultado.setText(String.valueOf(c1+c2));
}
}
 Ejercicio: Sumador
Clase FrameSumador
import java.awt.Container;
import java.awt.Image;
import javax.swing.*;

public class FrameSumador extends JFrame{

public FrameSumador(){
super("Sumador");
setBounds(400,400,400,100);
PanelSuma panel= new PanelSuma();
Container c= getContentPane();
c.add(panel);
}
}

Clase Sumador

import javax.swing.JFrame;

public class Sumador {

public static void main(String[] args) {
FrameSumador frame= new FrameSumador();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
Ejercicio2.1 Sumador
 Ejercicio: A Mayúsculas
Programa que convierte un texto introducido por el usuario a mayúsculas, con solo pulsar un
botón. Utiliza JTextArea para los dos campos de texto. La clase JScrollPane es un
contenedor que permite navegar en el texto cuando éste no cabe en el espacio asignado.
 Ejercicio A Mayúsculas
Clase PanelMayusculas

public class PanelAMayusculas extends JPanel{

JTextArea campo1, campo2;
JScrollPane scrCampo1, scrCampo2;
JButton btnOk;

public PanelAMayusculas() {
// creación de los elementos
campo1= new JTextArea(10,20);
campo1.setLineWrap(true);
scrCampo1 = new JScrollPane(campo1);
campo2= new JTextArea(10,20); campo2.setLineWrap(true);
scrCampo2 = new JScrollPane(campo2);
btnOk= new JButton("Mayusculas");

// se agregan los elementos al panel

setLayout(new BorderLayout());
add(scrCampo1, BorderLayout.WEST);
add(scrCampo2, BorderLayout.EAST);
add(btnOk,BorderLayout.NORTH);

// se asocia el botón con el objeto Listener

AMayusculasAction listener= new AMayusculasAction(this);

// agregar el Listener al botón

btnOk.addActionListener(listener);
}
Clase AMayusculasAction

public class AMayusculasAction implements ActionListener{

private PanelAMayusculas comp;

public AMayusculasAction(PanelAMayusculas comp){

this.comp=comp;
}

public void actionPerformed(ActionEvent e){

//obtiene la cadena de texto y la convierte a mayúsculas
String texto= comp.getCampo1().getText();
String texto2= texto.toUpperCase();

//se coloca el texto en el área2

comp.campo2.setText(texto2);
}

}
Clase FrameAMayusculas

import java.awt.Container;
import javax.swing.*;

public class FrameAMayusculas extends JFrame {

public FrameAMayusculas(){
super("Convierte texto a mayúsculas");
setBounds(400,400,800,600);

// se crea y se agrega el panel

add(new PanelAMayusculas());
pack();
}
}

Clase Principal

import javax.swing.JFrame;

public class Ej.2.2AMayusculas {

public static void main(String[] args) {

FrameAMayusculas frame= new FrameAMayusculas();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
Ejercicio 2.2- Mayúsculas y Minúsculas
 Eventos del teclado

Cada vez que el usuario pulsa una tecla, se produce un evento del
teclado.
Esto activa a un método de la clase oyente.

• si una tecla se ha presionado (key pressed)

• si una tecla se ha liberado (key released)
• Si una tecla se ha pulsado (key typed)
 KeyListener y KeyAdapter

KeyListener Interfaz que debe implementar el oyente del teclado

KeyAdapter Clase para no tener que escribir todos los métodos
 El objeto KeyEvent

Se puede obtener información del evento:

e.getKeyChar() retorna el valor de la tecla pulsada

e.getKeyCode() retorna el código de la tecla pulsada
Ejercicio 2.3 : EventoDeTeclado
Ejercicio 2.4 Evento de Teclado 2
 Sumador con evento de teclado
Clase PanelSuma
import java.awt.event.KeyAdapter;
Import java.awt.event.KeyEvent;
import javax.swing.*; // Clase interna en PanelSuma
public class PresionarTecla extends KeyAdapter {
public class PanelSuma extends JPanel{ public void keyPressed(KeyEvent ke) {
// atributos de la clase if (ke.getKeyCode() == KeyEvent.VK_ENTER) {
JTextField campo1, campo2; btnIgual.doClick();
JLabel mas,resultado; }
JButton btnIgual; }
}
public PanelSuma(){
// creación de los elementos
campo1= new JTextField("0",5);
campo2= new JTextField("0",5);
mas= new JLabel("+");
btnIgual=new JButton("=");
resultado= new JLabel("0");

// se agregan los elementos al panel

add(campo1); add(mas); add(campo2); add(btnIgual); add(resultado);

// creación del objeto Listener

SumaAction listener= new SumaAction(this);

// agregar el Listener al botón

btnIgual.addActionListener(listener);
// para tecla Enter
btnIgual.addKeyListener(new PresionarTecla());
}
// colocar aquí la clase interna
}
 Creación de menús

Para la construcción de un menú se utilizan 3 clases de javax.swing

JMenuBar para crear la barra de menú

Jmenu para crear los menús dentro de la barra
JMenuItem para crear las opciones dentro del menú

JPanel
 Creación de menús

Procedimiento:

• Crear la barra de menú (JMenuBar)

• Agregar la barra de menú al panel
• Crear los menús de la barra menú (JMenu)
• Agregar los menús a la barra de menú
• Crear las opciones para cada menú (JMenuItem)
• Agregar las opciones al menú correspondiente
• Para opciones de submenús también se usan JMenu y JMenuItem
Ejercicio 2.5 Creación de Menús
 Eventos de menús

Para que el programa haga algo cuando es seleccionada una opción de

menú, es necesario asociar el objeto JMenuItem a un objeto Listener.

opcion2=new JMenuItem(”Item2");
listener= new ObjetoListener();
opcion2.addActionListener(listener);

Public class ObjetoListener implements ActionListener{

…
public actionPerformed(ActionEvent e){
// acciones a realizar
}
}
 Ejercicio: Colores con menú
Programa que cambia el color de fondo mediante un menú
 Ejercicio: Colores con menú
Cambiar solamente la clase ButtonPanel por la nueva MenuPanel
En el constructor de ButtonFrame, en vez de crear un ButtonPanel se crea un MenuPanel
Lo demás queda intacto
 Ejercicio: Colores con menú
• Clase ButtonFrame

import javax.swing.JFrame;

class ButtonFrame extends Jframe

{
public static final int DEFAULT_WIDTH = 300;
public static final int DEFAULT_HEIGHT = 200;

public ButtonFrame()
{
setTitle("ButtonTest");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

//ButtonPanel panel = new ButtonPanel();

MenuPanel panel= new MenuPanel();
add(panel);
}
}
 Ejercicio: Colores con menú
• Clase MenuPanel
import java.awt.Color;
import javax.swing.*;

class MenuPanel extends Jpanel

{
public MenuPanel()
{
// barra de menús
JMenuBar barraMenu= new JMenuBar();
add(barraMenu);

// menú de colores
JMenu menuColores= new JMenu("Colores");
barraMenu.add(menuColores);

// opciones del menú de colores

JMenuItem opcAmarillo= new JMenuItem("Amarillo");
menuColores.add(opcAmarillo);
JMenuItem opcRojo= new JMenuItem("Rojo");
menuColores.add(opcRojo);

// creación de los oyentes

ColorActionExt yellowAction = new ColorActionExt(Color.YELLOW,this);
ColorActionExt redAction = new ColorActionExt(Color.RED,this);

// registro de los oyentes

opcAmarillo.addActionListener(yellowAction);
opcRojo.addActionListener(redAction);
}
}
 Clases anónimas
– Son clases que se instancian y se declaran al mismo tiempo
– No tienen nombre
– Son muy útiles para implementar métodos que son pequeños
– En java podemos crear una clase anónima que pueda implementar a
una interfaz.

// oyente para acerca de ..

opcAcercaDe.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
JOptionPane.showMessageDialog(
null,
"Colores con Menú\nTópicos Avanzados de Programación\nene-jun 2018”
);
}
}
);

En el ejemplo, se está instanciando una clase anónima que implementa a ActionListener, y al

mismo tiempo se está asignando como oyente al MenuItem opcAcercaDe
 La clase JColorChooser

Esta clase nos permite mostrar un selector para que el usuario elija uno
entre toda la gama de colores.

Color color=JColorChooser.showDialog(MenuPanel.this, TOOL_TIP_TEXT_KEY, Color.yellow);

 Ejercicio:
Agregar al menú de colores la opción “seleccionar color” para que el
usuario elija un color y el fondo se pinte de ese color.

//** opción para JColorChooser

JMenuItem opcChooser= new JMenuItem("Seleccionar color");
menuColores.add(opcChooser);

//** oyente para JColorChooser

opcChooser.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
Color color=JColorChooser.showDialog(
MenuPanel.this,
TOOL_TIP_TEXT_KEY,
Color.yellow);
setBackground(color);
}
);

En el ejemplo, se está instanciando una clase anónima que implementa a ActionListener, y al

mismo tiempo se está asignando como oyente al MenuItem opcChooser
Ejercicio 2.6 Colores con menú
 Agregar las aplicaciones al menú

Un programa escrito de manera separada puede ser ejecutado mediante

una opción de menú.
 Agregar las aplicaciones al menú

Las aplicaciones se pueden agregar al menú preparando una clase

Oyente que sustituya a la clase principal de la aplicación

public class Sumador {

public static void main(String[] args) {
FrameSumador frame= new FrameSumador();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}

public class SumadorOyente implements ActionListener{

public void actionPerformed(ActionEvent e){
FrameSumador frame= new FrameSumador();
frame.setDefaultCloseOperation(JFrame. DISPOSE_ON_CLOSE);
frame.setVisible(true);
}
}
Ejercicio 2.6b Menu de Aplicaciones