POO Unidad 3: Interfaz gráfica de usuario e hilos

Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
0
07/06/2022
Material docente compilado por el profesor Ph.D. Franklin Parrales Bravo
para uso de los cursos de Programación Orientada a Objetos
Interfaz gráfica de usuario e
hilos
Unidad 3

Carrera de Software
1
07/06/2022
Objetivo general de la Unidad 3
Utilizar componentes gráficos, eventos, manejadores de
eventos y animaciones sencillas, a través de librerías
gráficas e hilos con el fin de permitir la interacción del
usuario con la aplicación y comprender el procesamiento
en paralelo.

Carrera de Software
2
07/06/2022
Contenido
▪ Librerías de interfaz gráfica de usuario y aspectos de
diseño
▪ Contenedores y Componentes
▪ Layouts managers
▪ Tipos y manejo de eventos.
▪ Uso de clases internas y anónimas
▪ Hilos y aplicaciones con hilos

Ph.D. Franklin Parrales 3
07/06/2022
Programación Orientada a Objetos Carrera de Software
Las interfaces gráficas de usuario
Hasta ahora hemos desarrollado programas que usan la consola
para interactuar con el usuario. Esa forma de interfaz de usuario
es muy simple y nos ha permitido centrarnos en todo aquello
que tiene que ver tan sólo con la programación orientada a
objetos con el lenguaje Java, sin tener que tratar al mismo tiempo
con ventanas, botones y otros elementos similares.
Ahora aprenderemos todo lo que tiene que ver con el desarrollo
de interfaces gráficas de usuario, las interfaces que los programas
profesionales tienen que ofrecer.
Las interfaces gráficas de usuario (GUI) ofrecen al usuario
ventanas, cuadros de diálogo, barras de herramientas, botones,
listas desplegables y muchos otros elementos con los que ya
estamos muy acostumbrados a tratar.
Las aplicaciones son conducidas por eventos y se desarrollan
haciendo uso de las clases que para ello nos ofrece la API de Java.

07/06/2022
La API de Java para desarrollo de GUI
La interfaz de usuario es la parte del programa que permite
al usuario interaccionar con él.
La API de Java proporciona una biblioteca de clases para el
desarrollo de Interfaces gráficas de usuario (en realidad son dos).
La biblioteca proporciona un conjunto de herramientas para
la construcción de interfaces gráficas que tienen
una apariencia y se comportan de forma semejante
en todas las plataformas en las que se ejecuten.
La estructura básica de la biblioteca gira en torno a componentes
y contenedores. Los contenedores contienen componentes y
son componentes a su vez, de forma que los eventos pueden
tratarse tanto en contenedores como en componentes.
La API está constituida por clases, interfaces y derivaciones.

07/06/2022
Las bibliotecas disponibles
Cuando apareció Java, los componentes gráficos disponibles para
el desarrollo de GUI se encontraban en una biblioteca conocida
como Abstract Window Toolkit (AWT).
AWT es adecuada para interfaces gráficas sencillas,
pero no para proyectos más complejos.
Al aparecer Java 2 la biblioteca AWT se reemplazó por otra
biblioteca más robusta, versátil y flexible: Swing.
Aunque AWT aún sigue estando disponible, e incluso es usada
por los componentes de Swing.

07/06/2022
Algunos componentes de AWT
TextArea
Canvas
Label
List
TextField Button
CheckBox
Frame

07/06/2022
Paquete de Java para la generación del GUI en aplicaciones
reales de gran tamaño. Disponible como paquete externo
en Java 1.1 e integrado desde Java 1.2.
Es una de las API de JFC (Java Foundation Classes):
AWT, Java 2D, Accessibility, Drag and Drop, Swing, ...
Escrito totalmente en Java. No reemplaza a AWT.
Se apoya sobre AWT y añade JComponents.
Utiliza el modelo de eventos de Java 1.1.
Elección entre diferentes aspectos (look & feel).
Arquitectura Model-View-Controller (MVC).
Nuevos componentes (árboles, tablas, frames internos, iconos,
bordes, tooltips, beans, etcétera).
Swing

07/06/2022
Jerarquía de clases para las GUI
Dimension
Font
FontMetrics
Component
Graphics
Object Color
Container
Panel Applet
Frame
Dialog
Window
JComponent
JApplet
JFrame
JDialog
Swing Components
in the javax.swing package
Lightweight
Heavyweight
Classes in the java.awt
package
1
LayoutManager
*
Las clases de AWT reemplazadas por Swing
se llaman igual pero con una J delante.

07/06/2022
Component: superclase de todas las clases de interfaz gráfica.
Container: para agrupar componentes.
JComponent: superclase de todos los componentes de Swing
que se dibujan directamente en los lienzos (canvas).
Sus subclases son los elementos básicos de la GUI.
JFrame: ventana que no está contenida en otras ventanas.
JDialog: cuadro de diálogo.
JApplet: subclase de Applet para crear applets tipo Swing.
JPanel: contenedor invisible que mantiene componentes
de interfaz y que se puede anidar, colocándose en otros paneles
o en ventanas. También sirve de lienzo.
Graphics: clase abstracta que proporciona contextos gráficos
donde dibujar cadenas de texto, líneas y otras formas sencillas.

07/06/2022
Color: color de los componentes gráficos.
Font: aspecto de los caracteres.
FontMetrics: clase abstracta para propiedades de las fuentes.
Categorías de clases:
✓ Contenedores:
JFrame, JApplet, JWindow, JDialog
✓ Componentes intermedios:
JPanel, JScrollPane
✓ Componentes:
JLabel, JBbutton, JTextField, JTextArea, ...
✓ Clases de soporte:
Graphics, Color, Font, ...

07/06/2022
.
JButton
JMenuItem
JCheckBoxMenuItem
AbstractButton
JComponent
JMenu
JRadioButtonMenuItem
JToggleButton JCheckBox
JRadioButton
JComboBox
JInternalFrame JLayeredPane
JList JMenuBar JOptionPane
JPopupMenu
JProgressBar
JPane
JFileChooser
JScrollBar JScrollPane
JSeparator
JSplitPane
JSlider
JTabbedPane
JTable
JTableHeader
JTextField
JTextComponent
JEditorPane
JTextArea
JToolBar
JToolTip
JTree
JRootPane
JPanel
JPasswordField
JColorChooser
JLabel
Jerarquía de clases para las GUI: JComponent

07/06/2022
AWTEvent
Font
FontMetrics
Component
Graphics
Object Color
Canvas
Button
TextComponent
Label
List
CheckBoxGroup
CheckBox
Choice
Container Panel Applet
Frame
Dialog FileDialog
Window
TextField
TextArea
MenuComponent MenuItem
MenuBar
Menu
Scrollbar
LayoutManager
Jerarquía de clases para las GUI: AWT

07/06/2022
import javax.swing.*;
public class Gui00 extends JFrame {
// Constantes y componentes (objetos)
public Gui00(){
super("Ejemplo 00");
// Configurar Barra Menu ;
// Configurar Layout y Componentes ;
// Configurar Manejadores Eventos ;
setSize(200,100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
} // Terminar la aplicación al cerrar la ventana.
public static void main(String args[]){
Gui00 ventana = new Gui00();
}
}
Método main()
GUI00.java
Esquema de aplicación en Swing

07/06/2022
Esquema de applet con Swing
import javax.swing.*
public class MiApplet0 extends JApplet {
// Constantes y componentes (objetos)
public void init(){
// Configurar componentes
// Configurar layout;
// Configurar Manejadores Eventos;
}
}
Sustituye
al constructor.
No hay main().

Carrera de Software
15
07/06/2022
Contenido
diseño

07/06/2022
JFrame
Frame o JFrame (Swing) es una ventana que no está contenida en
otra ventana. Suele contener otros componentes.
Frame Menus
Componentes (UI)
Panel
Panel
Panel
UI
Panel
UI
Panel
UI
Applet
Panel
Componentes
Panel
Componentes
Panel
Componenets
Panel
Componentes
panel
Menus

07/06/2022
Para mostrar una ventana en una posición concreta disponemos
del método setLocation(x, y) de la clase JFrame.
Cuando se crea un objeto JFrame, se crea un objeto Container
(AWT). El objeto JFrame usa el panel de contenido (Container)
para albergar los componentes del frame.
1. Obtenemos el panel de contenido del frame:
Container panel = this.getContentPane();
2. Añadimos componentes a dicho panel:
panel.add(unComponente);
JFrame

07/06/2022
Componentes en el JFrame
import java.awt.*;
Container panel;
JButton miboton;
public Gui01() {
super("Ejemplo 01 con botón");
// Configurar componentes ;
miboton = new JButton("Aceptar");
panel = this.getContentPane();
panel.add(miboton);
setSize(200,100);
setVisible(true);
}
public static void main(String args[]) {
}
}
Gui01.java

Carrera de Software
19
07/06/2022
Contenido
diseño

07/06/2022
Administradores de disposición
Los componentes se agregan al contenedor con el método add().
JButton unBoton = new JButton("Texto del botón");
panel.add(unBoton);
El efecto de add() depende del esquema de colocación o
disposición (layout) del contenedor que se use.
Existen diversos esquemas de disposición: FlowLayout,
BorderLayout, GridLayout, ...
Los objetos contenedores se apoyan en objetos LayoutManager
(administradores de disposición).
Clases más usadas que implementa la interfaz LayoutManager:
FlowLayout: un componente tras otro de izquierda a derecha.
BorderLayout: 5 regiones en el contenedor (North, South, ...).
GridLayout: contenedor en filas y columnas.

07/06/2022
Administradores de disposición
Para organizar el contenedor se utiliza el método setLayout():
public void setLayout(LayoutManager mgr)
setLayout(new BorderLayout());
setLayout(new FlowLayout());
setLayout(new GridLayout(3,4));
El layout manager elige la mejor posición y tamaño de cada
componente de acuerdo al espacio disponible.
Crea una disposición para
el contenedor actual
Tipo de disposición
(BorderLayout, ...)

07/06/2022
Organización de contenedores
BorderLayout organiza
el contenedor en 5 zonas:
FlowLayout coloca los
componentes de izquierda a
derecha y de arriba hacia
abajo:
Para distribuciones más complejas podemos insertar paneles
(JPanel) en los contenedores y obtener el tamaño de un
componente con el método getSize().

07/06/2022
FlowLayout
import java.awt.*;
Container panel;
public Gui02() {
super("Ejemplo de Layout");
// Configurar componentes ;
// Configurar layout ;
panel.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 20));
for(int i = 1; i <= 10; i++)
panel.add(new JButton("Componente " + i));
setSize(200,200);
setVisible(true);
}
}
} Gui02.java
Cambiando el tamaño
se redistribuyen los componentes

07/06/2022
BorderLayout
import java.awt.*;
Container panel;
public Gui03() {
// Configurar componentes:
// BorderLayout
panel.setLayout(new BorderLayout(5, 10));
panel.add(new JButton("1"), BorderLayout.EAST);
panel.add(new JButton("2"), BorderLayout.SOUTH);
panel.add(new JButton("3"), BorderLayout.WEST);
panel.add(new JButton("4"), BorderLayout.NORTH);
panel.add(new JButton("5"), BorderLayout.CENTER);
setSize(200,200);
setVisible(true);
}
...
Gui03.java

07/06/2022
setLayout(new GridLayout(filas, columnas))
Crea una zona de filas x columnas componentes y éstos
se van acomodando de izquierda a derecha y de arriba a abajo.
GridLayout tiene otro constructor que permite establecer
la separación (en pixels) ente los componentes,
que es cero con el primer constructor.
Así, por ejemplo:
new GridLayout(3, 4, 2, 2)
crea una organización de 3 filas y 4 columnas donde los
componentes quedan a dos pixels de separación.
Ejemplo:
setLayout(new GridLayout(3, 4, 2, 2);
for(int i = 0; i < 3 * 4; i++) {
add(new JButton(Integer.toString(i + 1)));
}
GridLayout

07/06/2022
import java.awt.*;
public class Gui03b extends JFrame {
Container panel;
public Gui03b() {
// Configurar componentes:
// GridLayout
panel.setLayout(new GridLayout(4, 3, 5, 5));
// Add buttons to the frame
for(int i = 1; i <= 10; i++)
panel.add(new JButton(Integer.toString(i)));
setSize(200,200);
setVisible(true);
}
... Gui03b.java
GridLayout

07/06/2022
Los paneles actúan como pequeños contenedores para agrupar
componentes. Colocamos los componentes en paneles y
los paneles en el frame o incluso en otros paneles.
boton
textfield
12
botones
frame
p2
p1
Paneles como contenedores

07/06/2022
// Extraído de "Introduction to Java Programming"
// de Y. Daniel Lang (Prentice Hall, 2001)
import java.awt.*;
public Gui04() {
Container container = getContentPane();
container.setLayout(new BorderLayout());
// Create panel p1 for the buttons and set GridLayout
JPanel p1 = new JPanel();
p1.setLayout(new GridLayout(4, 3));
// Add buttons to the panel
for(int i = 1; i <= 9; i++) {
p1.add(new JButton("" + i));
}
p1.add(new JButton("" + 0));
p1.add(new JButton("Start"));
p1.add(new JButton("Stop"));
boton
textfield
12
botones
frame
p2
p1

07/06/2022
// Create panel p2 to hold a text field and p1
p2.setLayout(new BorderLayout());
p2.add(new JTextField("Aquí el tiempo"),
BorderLayout.NORTH);
p2.add(p1, BorderLayout.CENTER);
// Add p2 and a button to the frame
container.add(p2, BorderLayout.EAST);
container.add(new Button("Aquí la comida"),
BorderLayout.CENTER);
}
/** Main method */
public static void main(String[] args) {
Gui04 frame = new Gui04();
frame.setTitle("Horno microondas");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 250);
frame.setVisible(true);
}
} Gui04.java

07/06/2022
JPanel se puede usar para dibujar.
Para dibujar en un panel se crea una clase derivada de JPanel
y se redefine el método paintComponent() que le indica al panel
como dibujar.
La clase Graphics es una clase abstracta para todos
los contextos gráficos.
Una vez obtenido el contexto gráfico podemos llamar desde este
objeto a las funciones gráficas definidas en la clase Graphics.
Graphics contiene información acerca de la zona que necesita
ser redibujada: el objeto donde dibujar, un origen de traslación,
el color actual, la fuente actual, etcétera.
Dibujo de gráficos en paneles

07/06/2022
Ejemplo de dibujo
import java.awt.*;
class MiPanel extends JPanel {
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawString("Interfaz gráfica", 40, 40);
}
}
Container panel;
public Gui05() {
super("Ejemplo de dibujo");
panel.add(new MiPanel());
setSize(200, 100);
setVisible(true);
}
...
Método a redefinir
Gui05.java

07/06/2022
Dibujo de gráficos en paneles
Cuando utilizamos el método paintComponent() para dibujar
en un contexto gráfico g, ese contexto es un ejemplar de
una subclase concreta de la clase Graphics para la plataforma
específica.
El método paintComponent() es llamado la primera vez y
cada vez que es necesario redibujar el componente.
Al hacer super.paintComponent(g) nos aseguramos de que
el área visualizada se limpia antes de volver a dibujar.
super.paintComponent(g);
g.drawString("Interfaz gráfica", 40, 40);
}
}

07/06/2022
import java.awt.*;
Color c = new Color(180, 10, 120);
g.setColor(c);
g.drawString("Dibujar en el panel", 90, 90);
g.fillOval(1, 1, 90, 90);
}
}
Container panel;
public Gui06(){
setSize(300, 200);
setVisible(true);
}
...
Creación de un color RGB
Gui06.java
Ejemplo de dibujo

07/06/2022
Algunos métodos de Graphics
Graphics g;
...
g.setColor(Color.blue);
g.setBackground(Color.red);
g.drawLine(int x1, int y1, int x2, int y2);
g.drawRect(int x, int y, int ancho, int alto);
g.drawRoundedRect(int x, int y, int ancho, int alto,
int arcWidth, int arcHeight);
g.fillRect(int x, int y, int ancho, int alto);
g.fillRoundedRect(int x, int y, int ancho, int alto,
int arcWidth, int arcHeight);
g.drawOval(int x, int y, int ancho, int alto);
g.fillOval(int x, int y, int ancho, int alto);
g.drawArc(int x, int y, int ancho, int alto, int ang1,
int ang2);
g.drwaString(String cadena, int x, int y);
g.setFont(Font f);
...

07/06/2022
Fuentes
Las fuentes de letras se representan con objetos de la clase
java.awt.Font que tiene un sólo constructor:
Font(String nombre, int estilo, int tamaño)
En este constructor todos los parámetros tienen un conjunto
limitado de posiblidades.
Nombre Estilo
Font.PLAIN
Font.BOLD
Font.ITALIC
Font.BOLD + Font.ITALIC
"Helvetica"
"TimesNewRoman"
"Courier"
"Dialog"
"DialogInput"
"ZapfDingbats"

07/06/2022
Ejemplo
import java.awt.*;
g.setFont(new Font("Helvetica", Font.PLAIN, 18));
g.drawString("Hola", 70, 50);
g.setFont(new Font("TimesRoman", Font.BOLD, 18));
g.setFont(new Font("DialogInput", Font.ITALIC, 18));
}
}
Container panel;
public Gui07() {
setSize(200, 200);
setVisible(true);
} ... Gui07.java

Carrera de Software
37
07/06/2022
Contenido
diseño

07/06/2022
Interacción con el usuario
Al interactuar con la aplicación, el usuario:
✓ Acciona componentes (ActionEvent).
El usuario pulsa un botón.
El usuario termina de introducir un texto en un campo y
presiona Intro.
El usuario selecciona un elemento de una lista pulsando el
preferido (o de un menú).
Pulsa o suelta botones del ratón (MouseEvent).
✓ Minimiza, cierra o manipula una ventana (WindowEvent).
✓ Escribe con el teclado (KeyEvent).
✓ Descubre porciones de ventanas (PaintEvent).

07/06/2022
Interacción con el usuario
Cuando el usuario de un programa o applet mueve el ratón,
presiona un pulsador o pulsa una tecla, genera un evento
(actionEvent).
Los eventos son objetos de ciertas clases. Normalmente
un objeto de alguna subclase de EventObject que indica:
✓ El elemento que accionó el usuario.
✓ La identificación del evento que indica la naturaleza
del evento.
✓ La posición del ratón en el momento de la interacción.
✓ Teclas adicionales pulsadas por el usuario, como la tecla
Control, la tecla de Cambio a mayúsculas, etcétera.

07/06/2022
Acciones del usuario
Acción Objeto origen Tipo de evento
Pulsar un botón JButton ActionEvent
Cambio del texto JTextComponent TextEvent
Pulsar Intro en un campo de texto JTextField ActionEvent
Selección de un nuevo elemento JCombobox ItemEvent
ActionEvent
Selección de elemento(s) JList ListSelection-
Event
Pulsar una casilla de verificación JCheckBox ItemEvent
ActionEvent
Pulsar un botón de radio JRadioButton ItemEvent
ActionEvent
Selección de una opción de menú JMenuItem ActionEvent
Mover la barra de desplazamiento JScrollBar AdjustmentEvent
Abrir, cerrar, minimizar,
maximizar o cerrar la ventana JWindow WindowEvent
. . .

07/06/2022
Responder a eventos
Para que un componente (applet, ventana, ...) responda a los
eventos generados por el usuario sobre ese componente,
convertimos el componente en un oyente (listener) de ciertos
eventos generados por él o por otros componentes.
Convertir un componente en oyente de un tipo de eventos
consiste en implementar la interfaz correspondiente, codificando
sus métodos, y agregar el componente a la lista de oyentes
de ese tipo de eventos.
Por ejemplo, si queremos que la GUI responda a las pulsaciones
sobre un botón colocado en la ventana:
1 La ventana (oyente) ha de implementar la interfaz
ActionListener
2 El método actionPerformed() de dicha interfaz estará
preparado para responder a un evento e.
3 El oyente se añade a la lista de eventos de acción de botón.

07/06/2022
public class MiGUI extends JFrame implements ActionListener {
public void MiGui() { (1)
...
boton.addActionListener(this); (3)
}
public void actionPerformed(ActionEvent e) { (2)
// Código a ejecutar como respuesta al evento ...
}
}
(1) La ventana (oyente) indica que implementa la interfaz
ActionListener (hay otras para diferentes eventos).
(2) Se implementa el método ActionPerformed() de la interfaz
para responder a un evento e.
(3) Se agrega la ventana (oyente) a la lista de oyentes de eventos
ActionEvent desde el botón.
Responder a eventos

07/06/2022
Ejemplo
Al pulsar el botón Copiar, se debe copiar el valor del cuadro "valor"
en el cuadro "Copia".
Origen del evento:
Botón Copiar
Objeto evento:
ActionEvent e
Objeto oyente:
La ventana

07/06/2022
class MiGui extends JFrame implements ActionListener {
...
public void MiGui(){
// Registro los componentes interesados
// en responder a eventos ...
componente.addActionListener(this);
}
...
public actionPerformed(ActionEvent e) {
... // Aquí se responde el evento
}
}
Este método añade el oyente especificado (frame) a la lista
de oyentes para recibir eventos de acción (ActionEvent)
desde este componente.
Responder a eventos

07/06/2022
Responder a eventos
1. En el constructor del frame (oyente), registro el botón y
añado el oyente (frame) para recibir eventos de acción
desde el botón.
botonCopiar.addActionListener(this);
2. El usuario pulsa el botón.
3. El botón crea el objeto ActionEvent.
4. El botón envía el mensaje actionPerformed() al frame,
con el argumento ActionEvent.
Cada vez que el componente produzca el evento, se invocará
automáticamente el método actionPerformed().
El código de este método se ejecutará cada vez que se pulse
el botón.
La ventana (oyente)

07/06/2022
Otro modelo para responder a eventos
Creamos un manejador de eventos en dos pasos:
Definimos una clase específica que haga de oyente de eventos y
que implemente el método actionPerformed().
class MiOyente implements ActionListener {
public void actionPerformed() {
código ...
Registramos un ejemplar como oyente de componentes:
componente.addActionListener(ejemplar_de_MiOyente);

07/06/2022
class MiGui extends JFrame {
...
public void MiGui() {
// Registro los componentes interesados
// en responder a eventos ...
componente.addActionListener(new MiOyente());
}
...
class MiOyente implements ActionListener {
public actionPerformed(ActionEvent e) {
... // Aqui se responde el evento
}
}
Se añade el oyente especificado (ejemplar de MiOyente)
a la lista de oyentes para recibir eventos de acción
(ActionEvent) desde ese componente.
Otro modelo para responder a eventos

07/06/2022
import java.awt.*;
import java.awt.event.*;
public class Gui08 extends JFrame implements ActionListener {
JButton boton;
Container panel;
public Gui08() {
super("Ejemplo de eventos");
boton = new JButton("Pulsa!");
panel.add(boton);
boton.addActionListener(this);
setSize(100, 100);
setVisible(true);
}
public void actionPerformed(ActionEvent e) {
Toolkit.getDefaultToolkit().beep();
}
...
Ejemplo: botón con pitido (modelo 1)
Gui08.java

07/06/2022
import java.awt.*;
JButton boton;
Container panel;
public Gui09() {
boton = new JButton("Pulsa!");
panel.add(boton);
boton.addActionListener(new OyenteBoton());
setSize(100, 100);
setVisible(true);
}
...
}
class OyenteBoton implements ActionListener {
Toolkit.getDefaultToolkit().beep();
}
}
Una clase
de oyente
específica
Gui09.java
Ejemplo: botón con pitido (modelo 2)

07/06/2022
Ejemplo: reproducir un valor
import java.awt.*;
Container panel;
JButton botonCopiar;
JTextField campoValor, resultado;
public Gui10() {
panel = getContentPane();
panel.setLayout(new FlowLayout());
panel.add(new JLabel("Valor "));
campoValor = new JTextField(5);
panel.add(campoValor);
botonCopiar = new JButton("Copiar");
panel.add(botonCopiar);
botonCopiar.addActionListener(new OyenteBoton());
panel.add(new JLabel(" Copia "));
resultado = new JTextField(6);
...

07/06/2022
Ejemplo: reproducir un valor
setSize(400, 100);
setVisible(true);
}
}
public void actionPerformed(ActionEvent e){
String valor = campoValor.getText();
resultado.setText(valor);
}
}
}
Gui10.java

07/06/2022
Ejemplo: contador de pulsaciones
Una aplicación que muestre el número de pulsaciones que se
realizan sobre su botón.
...
public Gui11() {
boton1 = new JButton("PULSA");
label1 = new JLabel("Pulsaciones: 0");
panel.add(boton1);
panel.add(label1);
boton1.addActionListener(new OyenteBotonPulsaciones());
...
}
...
class OyenteBotonPulsaciones implements ActionListener {
public void actionPerformed(ActionEvent e){
contador++;
label1.setText("Pulsaciones: " + contador);
} ...
Gui11.java

07/06/2022
Ejemplo: cambio de color
...
import java.awt.*;
JButton red = new JButton("Rojo");
JButton blue = new JButton("Azul");
Container panel;
public Gui12() {
super("Color de fondo");
panel.add(red);
panel.add(blue);
red.addActionListener(new ColorActionListener(Color.red));
blue.addActionListener(new ColorActionListener(Color.blue));
setSize(200, 200);
setVisible(true);
}

07/06/2022
Ejemplo: cambio de color
}
class ColorActionListener implements ActionListener {
Color fondo;
public ColorActionListener(Color unColor) {
fondo = unColor;
}
public void actionPerformed(ActionEvent evento) {
panel.setBackground(fondo);
}
}
}
Gui12.java

07/06/2022
ActionEvent
El objeto ActionEvent ofrece un método getActionCommand()
que devuelve un objeto con la información sobre el origen
del evento (el botón en nuestro caso).
Con un botón, devuelve la etiqueta del botón.
Para identificar botones individuales:
String s = (String)e.getActionCommand();
if(s.equals("Aceptar")) {
// Tratamiento del botón Aceptar
}
...

07/06/2022
ActionEvent
El método getSource() indica el objeto en el que se ha
originado el evento:
if(e.getSource() == lista) {
campo1.setText("En la lista.");
}
else if(e.getSource() == texto) {
campo2.setText("En el campo de texto.");
}
else if(e.getSource() == boton) {
campo3.setText("En el botón.");
}
}

07/06/2022
Un conversor Euros-Pesetas
import java.awt.*;
Container panel;
TextField cantidad;
JButton boton1, boton2;
public Gui13(){
super("Conversor Euros-Pesetas");
boton1 = new JButton("A euros");
boton2 = new JButton("A pesetas");
cantidad = new TextField(10);
JLabel eti2 = new JLabel(new ImageIcon("logo.gif"));
panel.add(eti2);
panel.add(cantidad);
panel.add(boton1);
panel.add(boton2);
boton1.addActionListener(new OyenteBoton());
boton2.addActionListener(new OyenteBoton());
setSize(300, 250);
...

07/06/2022
Un conversor Euros-Pesetas
setVisible(true);
}
}
public void actionPerformed(ActionEvent ae) {
Float f = new Float(cantidad.getText());
float valor = f.floatValue();
String s = (String)ae.getActionCommand();
if(s.equals("A euros")) {
valor = (float) (valor / 166.321);
panel.setBackground(Color.green);
}
else if(s.equals("A pesetas")) {
valor = (float) (valor * 166.321);
panel.setBackground(Color.blue);
}
cantidad.setText(Float.toString(valor));
}
}
}
Gui13.java

07/06/2022
Interfaces para procesar eventos
Para facilitar la tarea del programador se han creado una serie de
interfaces que deben implementarse cuando se quieren procesar
algunos de estos eventos. Algunas interfaces y sus métodos son:
ActionListener
Escucha eventos de tipo ActionEvent
actionPerformed(ActionEvent)
KeyListener
Escucha eventos de teclado
keyPressed(KeyEvent)
keyReleased(KeyEvent)
keyTyped(KeyEvent)
MouseListener
Escucha eventos de acción del ratón
(botones)
mouseClicked(MouseEvent)
mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
MouseMotionListener
Escucha eventos de movimiento del ratón
mouseDragged(MouseEvent)
mouseMoved(MouseEvent)

07/06/2022
Componentes (JavaBeans): JButton
Constructores:
JButton(String text)
JButton(String text, Icon icon)
JButton(Icon icon)
Respuesta a botones:
✓ Implementar la interfaz ActionListener
✓ Implementar el método actionPerformed(ActionEvent e)
// Obtenemos la etiqueta
String actionCommand = e.getActionCommand();
if(e.getSource() instanceof JButton)
if("Aceptar".equals(actionCommand))
System.out.println("Pulsó Aceptar");
}

07/06/2022
Ejemplos
boton1 = new JButton("A Euros ");
boton1.setIcon(new ImageIcon("flag1.gif"));
boton2 = new JButton(new ImageIcon("flag2.gif"));
boton3 = new JButton("Botón",new ImageIcon("flag8.gif"));

07/06/2022
Componentes (JavaBeans): JLabel
Para texto, una imagen o ambos:
JLabel(String text,
int horizontalAlignment)
JLabel(String text)
JLabel(Icon icon)
JLabel(Icon icon,
int horizontalAlignment)
eti1 = new JLabel("Etiqueta de texto...");
eti2 = new JLabel(new ImageIcon("flag8.gif"));
Gui14.java

07/06/2022
Componentes (JavaBeans): JTextField
Campos de texto para introducir caracteres:
JTextField(int columns)
JTextField(String text)
JTextField(String text, int columns)
JTextField text1 = new JTextField("hola", 10);
Poner texto: text1.setText("Adios");
Obtener texto: String str = text1.getText();
Agregar al Panel: p1.add(text1);

07/06/2022
Componentes (JavaBeans): JComboBox
Listas de elementos para seleccionar un solo valor:
Creación: JComboBox ch1 = new JComboBox();
Agregar opciones: ch1.addItem(Object elemento);
Registrar Evento: ch1.addItemListener( objeto);
Obtener selección: val = ch1.getSelectedIndex();
ch1.getItem()
Implementar la interfaz ItemListener
Implementar el método itemStateChanged(ItemEvent e)
ch1.addItemListener(new OyenteItem());
. . .
class OyenteItem implements ItemListener {
public void itemStateChanged(ItemEvent e) {
...
}}

07/06/2022
Componentes (JavaBeans): JList
Listas de elementos para seleccionar uno o varios valores:
JList l1 = new JList();
JList l2 = new JList(Object[] elements);
String[] cosas = {"Opción 1", "Opción 2", "Opción 3"};
Jlist l2 = new Jlist(cosas);
Registrar evento: l2.addListSelectionListener(oyente);
Obtener selección:
int[] indices = l2.getSelectedIndices();

07/06/2022
Componentes (JavaBeans): JList
Implementar la interfaz ListSelectionListenner
Implementar el método valueChanged(ListSelectionEvent e)
l.addListSelectionListener(new OyenteLista());
...
class OyenteLista implements ListSelectionListener {
public void valueChanged(ListSelectionEvent e) {
int[] indices = l.getSelectedIndices();
int i;
for(i = 0; i < indices.length; i++) {
...
}
}
}

07/06/2022
Componentes (JavaBeans): JScrollBar
Creación:
bar1 = new Scrollbar(Scrollbar.HORIZONTAL,0,0,0,100);
Registrar evento:
bar1.addAdjustmentListener(oyente);
Implementar la interfaz AdjustmentListener
Implementar el método
adjustmentValueChanged(AdjustmentEvent e)
bar1.addAdjustmentListener(new OyenteBarra());
...
class OyenteBarra implements AdjustmentListener {
public void adjustmentValueChanged(AdjustmentEvent e) {
... }
}
Obtener valor:
int val = bar1.getValue(); // val entre 0 y 100

07/06/2022
Componentes: JScrollBar y JComboBox
Container panel;
JPanel p1, p2;
JLabel l1, msg;
JComboBox ch1;
String[] lista = {"Opción 1", "Opción 2", "Opción 3"};
JScrollBar bar1;
public Gui15() {
super("Controles");
panel.setLayout(new BorderLayout());
p1 = new JPanel(new GridLayout(1, 3, 10, 10));
p1.setBackground(Color.lightGray);
l1 = new JLabel("Elegir:", Label.RIGHT);
l1.setBackground(Color.yellow);
p1.add(l1);
ch1 = new JComboBox();
for(int i = 0; i < lista.length; i++)
ch1.addItem(lista[i]); ...

07/06/2022
ch1.addItemListener(new OyenteCombo());
p1.add(ch1);
bar1 = new JScrollBar(Scrollbar.HORIZONTAL, 0, 0, 0, 100);
/* scroll de 0 a 100*/
bar1.addAdjustmentListener(new OyenteBarra());
p1.add(bar1);
p2 = new JPanel(new BorderLayout());
p2.setBackground(Color.lightGray);
msg = new JLabel("Msg:", Label.LEFT);
msg.setForeground(Color.blue);
p2.add("North", msg);
panel.add(p1, "North");
panel.add(p2, "South");
setSize(300, 100);
setVisible(true);
}
...

07/06/2022
}
class OyenteCombo implements ItemListener {
public void itemStateChanged(ItemEvent e) {
int ind = ch1.getSelectedIndex();
msg.setText((String)ch1.getSelectedItem());
}
}
class OyenteBarra implements AdjustmentListener {
public void adjustmentValueChanged(AdjustmentEvent e) {
int valor = bar1.getValue();
String cad = "Valor : " + valor;
msg.setText(cad);
}
}
} Gui15.java

07/06/2022
Movimientos de ratón
JButton boton;
List lista;
Container panel;
public Gui17() {
...
this.addMouseMotionListener(new OyenteMover());
...
}
...
class OyenteMover implements MouseMotionListener {
public void mouseDragged(MouseEvent e) {
lista.add("arrastrando..");
}
public void mouseMoved(MouseEvent e) {
lista.add("moviendo..");
}
}
}
Gui17.java

07/06/2022
Pulsaciones de ratón
class OyenteRaton implements MouseListener {
public void mouseClicked(MouseEvent e) {
lista.add("click..");
}
public void mouseEntered(MouseEvent e) {
lista.add("enter..");
}
public void mouseExited(MouseEvent e) {
lista.add("exit..");
}
public void mousePressed(MouseEvent e) {
lista.add("pulsar..");
}
public void mouseReleased(MouseEvent e) {
lista.add("soltar..");
}
}

07/06/2022
Jerarquía de componentes (repaso)
Graphics (java.awt)
Component (funcionalidad básica de componentes gráficos)
Button, Canvas, CheckBox, Choice, Label, List, ScrollBar
TextComponent
TextField, TextArea
Container (permite agrupar, añadir y eliminar componentes)
(también definir diseño o disposición (layout managers))
ScrollPane
Panel
Applet (java.applet)
JApplet (javax.swing)
Window
Frame
JFrame (javax.swing)
Dialog
FileDialog
JDialog (javax.swing)
JWindow (javax.swing)
JComponent (javax.swing)

07/06/2022
Contenedores
Contenedores de alto nivel:
JFrame
Habitualmente la clase JFrame se emplea para crear
la ventana principal de una aplicación en Swing.
JDialog
Ventanas de interacción con el usuario.
Contenedores intermedios:
JPanel
Agrupa a otros componentes.
JScrollPanel
Incluye barras de desplazamiento.

07/06/2022
Ejemplo de cuadro de mensaje
Container p;
public Gui18() {
super("Título de la ventana");
p = getContentPane();
p.setLayout(new FlowLayout());
setSize(200, 100); // pack();
setVisible(true); // show();
// if ocurre algo
JOptionPane.showMessageDialog(null,
"Debe introducir datos en todos los campos",
"Error de entrada ",
JOptionPane.ERROR_MESSAGE);
}
Gui18 f = new Gui18();
}
} Gui18.java

07/06/2022
Ejemplo de cuadro de opciones
Container p;
public Gui19() {
setSize(200, 100);
setVisible(true);
Object[] textoOpciones = {"Si adelante", "Ahora no", "No
sé"};
int opcion = JOptionPane.showOptionDialog(null,
"¿Desea continuar?", "mensaje",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE, null, textoOpciones,
textoOpciones[0]);
}
... Gui19.java

07/06/2022
Ejemplo de cuadro de entrada de datos
class PanelDatos extends JPanel {
public PanelDatos() {
setLayout(new GridLayout(4, 2));
JLabel etiquetaNombre = new JLabel("Nombre: ", JLabel.RIGHT);
JTextField campoNombre = new JTextField();
add(etiquetaNombre);
add(campoNombre);
JLabel etiquetaApellidos = new JLabel("Apellidos:", JLabel.RIGHT);
JTextField campoApellidos = new JTextField();
add(etiquetaApellidos);
add(campoApellidos);
JLabel etiquetaNP = new JLabel("Número Personal:", JLabel.RIGHT);
JTextField campoNP = new JTextField();
add(etiquetaNP);
add(campoNP);
ButtonGroup grupoBotones = new ButtonGroup();
JRadioButton mañana = new JRadioButton("Grupo Mañana", true);
JRadioButton tarde = new JRadioButton("Grupo Tarde");
grupoBotones.add(mañana);
grupoBotones.add(tarde);
add(mañana);
add(tarde);
}
}

07/06/2022
Ejemplo de cuadro de entrada de datos
Container p;
public Gui20() {
// Cuando necesitamos el cuadro de diálogo...
PanelDatos pd = new PanelDatos();
if(JOptionPane.showConfirmDialog(this, pd, "Introduzca datos",
JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE)
== JOptionPane.OK_OPTION) {
// ... tratamiento
}
}
Gui20 f = new Gui20();
}
}
Gui20.java

07/06/2022
Menús
Java ofrece varias clases para poner menús en una ventana:
JMenuBar
JMenu
JMenuItem
JCheckBoxMenuItem
JRadioButtonMenuItem
Un JFrame o JApplet puede guardar un barra de menú donde
se cuelgan menús desplegables.
Los menús tienen elementos de menú que puede seleccionar
el usuario.
Las barras de menús se pueden contemplar como una estructura
que soporta menús.

07/06/2022
Menús
Una ventana (frame) sólo puede tener una barra de menús
(objeto MenuBar), que se sitúa en la parte de arriba del mismo.
Los submenús son botones JMenu.
Los elementos de los menús son botones JMenuItem.
Cuando se activa un menú se despliegan automáticamente
las opciones del menú.

07/06/2022
Menús

07/06/2022
Ejemplo de menú

07/06/2022
Ejemplo de menú
JMenuBar barraMenu = new JMenuBar();
setJMenuBar(barraMenu); // La barra de menús de este frame
// El menú:
JMenu menuOpciones = new JMenu("Menú de opciones");
barraMenu.add(menuOpciones); // Añadimos el menú a la barra
// Un elemento de menú:
JMenuItem listar = new JMenuItem("Listar los alumnos");
menuOpciones.add(listar); // Añadimos el elemento al menú
// Inserción de una línea separadora en el menú:
menuOpciones.add(new JSeparator());
// Un menú que será un submenú del anterior:
JMenu subMenu = new JMenu("Submenú");
// Un elemento de menú para el submenú:
JMenuItem opcionSubmenu = new JMenuItem("Opción de submenú");
subMenu.add(opcionSubmenu); // La añadimos al submenú
// Añadimos el submenú como elemento del menú:
menuOpciones.add(subMenu);

07/06/2022
Ejemplo de menú
// Establecemos oyentes para las opciones elegibles:
listar.addActionListener(new OyenteMenu());
opcionSubmenu.addActionListener(new OyenteMenu());
...
class OyenteMenu implements ActionListener {
if(e.getSource() instanceof JMenuItem) {
if("Listar los alumnos".equals(actionCommand)) {
texto.setText("Listar los alumnos");
}
if("Opción de submenú".equals(actionCommand)) {
texto.setText("Opción de submenú");
}
}
}
}
Gui21.java

07/06/2022
Otro ejemplo
Aplicación que permite realizar operaciones aritméticas.
La interfaz contiene etiquetas y campos de texto para los
operandos y el resultado. La operación se selecciona en el menú:

07/06/2022
Otro ejemplo
import java.awt.*;
Container panel;
JTextField jtfNum1, jtfNum2, jtfResult;
JMenuItem jmiSuma, jmiResta, jmiMul, jmiDiv, jmiCerrar;
public Gui22() {
super("Menús");
JMenuBar jmb = new JMenuBar();
setJMenuBar(jmb);
JMenu operationMenu = new JMenu("Operación");
operationMenu.setMnemonic('O'); // Letra distinguida
jmb.add(operationMenu);
operationMenu.add(jmiSuma = new JMenuItem("Suma", 'S'));
operationMenu.add(jmiResta = new JMenuItem("Resta", 'R'));
operationMenu.add(jmiMul = new JMenuItem("Multiplica",'M'));
operationMenu.add(jmiDiv = new JMenuItem("Divide", 'D'));
...

07/06/2022
Otro ejemplo
JMenu exitMenu = new JMenu("Salir");
jmb.add(exitMenu);
exitMenu.add(jmiCerrar = new JMenuItem("Cerrar", 'C'));
p1.setLayout(new FlowLayout());
p1.add(new JLabel("Número 1"));
p1.add(jtfNum1 = new JTextField(3));
p1.add(new JLabel("Número 2"));
p1.add(jtfNum2 = new JTextField(3));
p1.add(new JLabel("Resultado"));
p1.add(jtfResult = new JTextField(4));
jtfResult.setEditable(false);
getContentPane().setLayout(new BorderLayout());
getContentPane().add(p1, BorderLayout.CENTER);
// Registramos oyentes
jmiSuma.addActionListener(new OyenteMenu());
jmiResta.addActionListener(new OyenteMenu());
jmiMul.addActionListener(new OyenteMenu());
jmiDiv.addActionListener(new OyenteMenu());
jmiCerrar.addActionListener(new OyenteMenu());
} ...

07/06/2022
Otro ejemplo
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ventana.pack();
ventana.setVisible(true);
}
private void calculate(char operator) {
int num1 = (Integer.parseInt(jtfNum1.getText().trim()));
int num2 = (Integer.parseInt(jtfNum2.getText().trim()));
int result = 0;
switch (operator) {
case '+': result = num1 + num2; break;
case '-': result = num1 - num2; break;
case '*': result = num1 * num2; break;
case '/': result = num1 / num2;
}
jtfResult.setText(String.valueOf(result));
}
...

07/06/2022
Otro ejemplo
class OyenteMenu implements ActionListener {
if(e.getSource() instanceof JMenuItem) {
if("Suma".equals(actionCommand)) calculate('+');
else if("Resta".equals(actionCommand)) calculate('-');
else
if("Multiplica".equals(actionCommand)) calculate('*');
else if("Divide".equals(actionCommand)) calculate('/');
else if("Cerrar".equals(actionCommand)) System.exit(0);
}
}
}
}
Gui22.java

07/06/2022
Arquitectura MVC (Modelo-Vista-Controlador)
La arquitectura MVC es una arquitectura típica de diseño de GUI.
✓ El modelo representa la estructura lógica de la GUI,
independientemente de su representación visual.
✓ La vista constituye la representación visual de la GUI.
✓ El controlador constituye la lógica de interacción con el usuario.
Un primer paso hacia esta arquitectura consiste en la separación
entre la aplicación y la interfaz o vista:
Aplicación aplicación = new Aplicación();
GUI gui = new GUI(aplicación); }
Aunque el mejor modelo separa en las tres partes:
Modelo modelo = new Modelo();
Controlador controlador = new Controlador(modelo);
GUI gui = new GUI(controlador); }

Carrera de Software
91
07/06/2022
Contenido
diseño

07/06/2022
Anidamiento de clases
◼ Es posible definir clases dentro de otras clases, las mismas que son
conocidas como clases anidadas (nested classes).
◼ La clase que contiene a la inner class se la conoce como clase externa
(outer class).
◼ Fueron introducidas en el JDK 1.1.
◼ Se puede declarar una clase dentro de otra clase o dentro de una
interfase.

07/06/2022
◼ Se puede declarar una interfase dentro de otra interfase o dentro de
una clase.
◼ Se puede declarar una clase dentro de un método.
◼ Se pueden tener varios niveles de anidamiento.
◼ El alcance de éstas clases esta dado por la clase que las contiene, es
decir solo es reconocida por ella.

07/06/2022
Clases internas o clases anidadas
Una clase interna o anidada es una clase que está definida dentro
de otra clase (como si fuera otro atributo):
public class Clase {
private int dato;
public void metodo() {
Interna ejemplar = new Interna();
}
class Interna {
public void otro() {
dato++; // Puede acceder a los atributos
metodo(); // y a los métodos de la externa.
}
}
}
La clase interna sólo es conocida en aquella en la que se encuentra.
Si la clase interna es anónima (sin nombre)
se crea automáticamente un ejemplar suyo.
Es una clase auxiliar

07/06/2022
◼ Una clase anidada puede acceder a todos los miembros (hasta
privados) de la clase que la contiene, pero la clase que la contiene no
tiene los mismos permisos.
◼ Los tipos de clases anidadas son:
1. static nested (inner) class
2. non static nested (inner) class
3. Anonymous inner class (clases anónimas)

07/06/2022
1. Static nested class: no puede acceder a los miembros de la clase que
la contiene directamente, sino a través de un objeto, de aquí que
estas clases son raramente usadas.

07/06/2022
Ejemplo
de
static
nested
class
class OuterStatic {
int x = 100;
void test() {
StaticNested obSta = new StaticNested();
obSta.display();
}
static class StaticNested {
int y = 30;
int z = 20;
void display() {
System.out.println("display: z = " + z);
System.out.println("display: y = " + y);
OuterStatic obO = new OuterStatic();
System.out.println("display: x = " + obO.x);
}
}
}
class StaticNestedClassDemo {
OuterStatic outer = new OuterStatic();
outer.test();
}
}
StaticNestedClassDemo.java

07/06/2022
2. Non static nested class: conocida como Inner class, es la más
importante y utilizada.
◼ Tiene acceso a todas las variables y métodos de la clase que la
contiene (outer class).

07/06/2022
Ejemplo
de
inner
class
class Outer {
int x = 100;
void test() {
Inner obIn = new Inner();
obIn.display();
}
class Inner {
int y = 10;
void display() {
System.out.println("display: x = " + x );
System.out.println("display: y = " + y );
}
}
}
class InnerClassDemo {
public static void main(String args[ ]) {
Outer outer = new Outer();
outer.test();
}
}
Ver también:
InnerClassDemo.java
InnerClassDemo2.java
Outer.java

07/06/2022
◼ Inner class además de ser definida dentro de otra clase, puede
también definirse dentro de un método, o un bloque de código, por
ej. un lazo.
◼ Una clase definida dentro de un método solamente puede acceder
a las variables de este, que tengan el modificador final.
◼ No se pueden definir miembros estáticos dentro de las Non static
inner classes, exceptuando las constantes.
◼ Ver
◼ Estas clases no son muy usadas en el día a día. Pero son muy útiles
cuando se manejan eventos.
InnerClassDemo3.java

07/06/2022
3. Anonymous inner classes
◼ Existen también las clases internas que no tienen nombre, y son
las conocidas anonymous inner classes.
◼ Las clases anónimas pueden extender de una clase o
implementar una interfase.
◼ La sintáxis para crear una clase anónima es la siguiente:
new <nombre de clase de la que hereda o interface que
implementa>
{
//cuerpo de la clase
}

07/06/2022
Ejemplo de clase anónima
interface VideoClip {
void play();
void stop();
}
class TestVideoClip {
void test(VideoClip v)
{
v.play();
v.stop();
}
}
class AnonInnerClassDemo {
public static void main(String args[ ]) {
TestVideoClip t = new TestVideoClip();
t.test ( new VideoClip() {
public void play() { System.out.println(“Reproduciendo el video"); }
public void stop() { System.out.println("Se detiene el video"); }
} );
}
}
AnonInnerClassDemo.java

07/06/2022
Compilando Clases Internas
◼ Cuando usted compila una inner class, obtiene un archivo .class
con el siguiente formato de nombre:
◼ OuterClass$InnerClass.class
◼ Cuando usted compila una clase anónima, obtiene un archivo
.class con el siguiente formato de nombre:
◼ OuterClass$n.class, donde n es un entero que comienza con
1.

Carrera de Software
104
07/06/2022
Contenido
diseño

07/06/2022
Threads
◼ What are Threads?
◼ Two Ways to Obtain a New Thread
◼ The Lifecycle of a Thread
◼ Four Kinds of Thread Programming

07/06/2022
¿Qué son los hilos (Threads)?
◼ Un hilo es una unidad de ejecución de programa que se
ejecuta independientemente de otros hilos.
◼ lightweight process
◼ Los hilos se comportan como si se estuvieran ejecutando
en diferentes CPUs
◼ Extienden el concepto de tiempo compartido.
◼ Los recolectores de basura(Garbage collectors) y los
listeners se ejecutan en hilos separados

07/06/2022
Contexto del hilo
◼ Context switched when JVM switched to a different thread
◼ Not as costly as switching processes
◼ Threads can make a program run faster
◼ Threads allow a program to do more that one thing at a
time
◼ one processor?
◼ the system handles the sharing

07/06/2022
Threads

07/06/2022
Two Ways to Obtain a New Thread
◼ Extend the java.lang.Thread Class
◼ Implement the “Runnable” interface
◼ Applets extend the class Applet by definition.
➔ an applet must always use the second technique;
extends is taken by (J)Applet

07/06/2022
Extension of java.lang.Thread
◼ Create a class extending Thread Class
◼ Put the code for the task into the run method of
the new class
◼ Create an instance of that class
◼ Call the start method for that instance
◼ The start method will call the run method
◼ The thread executes until the run method
terminates.

07/06/2022
Extending the Thread Class
Class AThread extends Thread
{
…
public void run()
{
// your code here
}
}

07/06/2022
Running a Thread
◼ In another thread, create the thread
AThread t1 = new AThread();
◼ Start the thread by calling its start method
t1.start();
◼ The call to start creates and schedules the thread
to execute. The run method is called by the JVM
when it is the thread’s turn to execute
◼ See Java Documentation on Thread
◼ See: NameThread.java
ThreadTest.java

07/06/2022
The Runnable Interface
public interface Runnable
{
// Must write run()
public abstract void run();
}

07/06/2022
Implement Runnable
◼ Create a class ARunnable which implements the
“runnable” interface.
public class ARunnable implements Runnable
{
public void run() { … }
}
◼ Use that class in a call to the Thread constructor
Thread t = new Thread( new ARunnable() );
t.start(); // start the thread
◼ See Java Doc on Runnable
◼ See NameUsingThread.java

07/06/2022
Notes on Runnable
◼ Statements within the Runnable Interface implementation
of run() can’t invoke Thread methods like “sleep()”,
“getName()”, etc. because no “this” object is available in
Runnable.
◼ the object isn’t the thread

07/06/2022
Remarks
◼ A call to currentThread() can appear anywhere in
Java code. Any of the methods of that thread can
be called via the thread returned in
currentThread().
◼ Runnable vs Thread: Use Runnable when only
the “run()” method will be overridden.
Convention holds that a class should not be
extended unless there is a fundamental
enhancement of behavior. YMMV.

07/06/2022
Terminating Threads
◼ A thread terminates when its run method returns – the
normal way
◼ A thread can be interrupted (never stopped) by using the
thread.interrupt() method.
◼ A thread’s run method should occasionally check for the
interrupt signal

07/06/2022
Interrupt Coding
public void run()
{
try // DO NOT PUT try in a loop, but loop in try
{ // do some work
}
catch (InterruptedException e)
{ // do whatever needs to be done
}
// clean up
}

07/06/2022
Parameters to Threads
◼ The run method cannot have parameters
◼ The constructor can have parameters
◼ The Thread constructor can have certain parameters
◼ see API for java.lang.Thread

07/06/2022
Threads

07/06/2022
Thread Lifecycle
◼ A thread is created, then “started”
◼ The thread “dies” when
◼ The run method terminates:
◼ normally
◼ through an exception or return
◼ A thrown exception will cause the thread to terminate
but not the parent

07/06/2022
Priorities
◼ A thread runs at the priority of its parent unless its
priority is changed.
◼ A higher priority executes first if they are both ready
to run
◼ Java threads
◼ can be preempted.
◼ may or may not be time-sliced
◼ Computationally intensive threads should “yield”
periodically
◼ Raising a thread’s priority does not affect other
(heavyweight) processes, only parent, sibling,
children threads (competing lightweight processes)

07/06/2022
Threads

07/06/2022
Four Kinds of Thread Programming
1. Unrelated Threads
2. Related Unsynchronized Threads
3. Mutually-Exclusive Threads
4. Communicating Mutually-Exclusive Threads

07/06/2022
Thread Diagram
A Class
An Object
An Object
An Object has Methods
An Object has Methods
Thread runs in a method

07/06/2022

07/06/2022
Unrelated Threads
◼ The simplest thread programs involves threads that do
different things
◼ Don’t interact with one another
◼ Coffee_Tea Example
◼ run on PC and Suns to see difference in how many
times coffee gets in
◼ Tea can yield periodically to allow Coffee a chance to
execute

07/06/2022

07/06/2022
Related, Unsynchronized Threads
◼ The problem is partitioned into subproblems
◼ A thread solves each subproblem
◼ The threads don’t interact
◼ They don’t work on shared data
◼ Example:
◼ A server connection for each socket connection is a good
example
◼ A “Work-to-order” thread is called a daemon
◼ always on
testPrime.java

07/06/2022

07/06/2022
Mutally-Exclusive Threads
◼ Threads that access common data concurrently need to
be controlled so that the correct state of the data is
preserved at all times. Such a situation occurs
frequently in the real world.

07/06/2022
The Pressure Gauge
Consider reading and setting a pressure gauge. The
gauge should not be set above 20 psi. But the
pressure is set by pressure setting objects,
independent of one another. Each must check the
gauge and if it is safe to do so, increase the pressure
by a fixed amount.
◼ Example:
BadPressure.java

07/06/2022
BadPressure output
>java BadPressure
Gauge reads 150, safe limit is 20
What happened?
◼ code appeared to restrict gauge value, but didn’t
◼ Setting the gauge is a critical section
◼ Mutual exclusion required

07/06/2022
Mutual Exclusion
◼ Simultaneous reading and setting of the pressure
gauge by different threads
◼ set followed check; all did check, THEN did
change
◼ check-change is a read-update-write operation
and must be atomic
◼ one object needs to lock others out until it is finished
◼ can be done at the class level, method level, or on a
block of code

07/06/2022
The keyword synchronized
◼ This keyword obtains a mutex (mutual
exclusion) lock for the executing thread on the
named object. The code is then executed, and
the lock is released.
◼ If another object already holds the lock, the
thread is suspended until the lock is released.
Lock-competing threads are queued.

07/06/2022
Some considerations
◼ Java programmers don’t need to do the low
level details of creating, acquiring, and
releasing locks
◼ Unix semaphores, locks
◼ Specify the portion of code (critical section)
for mutual exclusion, and the object that
must be exclusively locked
◼ The region of code must be as small as
possible

07/06/2022
Mutual Exclusion over an Entire Class
◼ apply the keyword synchronized to a class method.
◼ e.g. static synchronized void RaisePressure()
◼ Only one static synchronized method for a given class can
be running at any given time in the JVM, regardless of
how many objects there are of that class
◼ the class object is used to synchronize the threads
◼ There is one lock for static synchronized methods, and a
different lock for synchronized methods. One thread could
have the static lock while another thread has a method
lock, while other threads could be running other
unsynchronized methods
◼ Example: SetPressure.java

07/06/2022
Class Mutual Exclusion
◼ From
// Only one thread may be executing in here
static synchronized void raisePressure()
{ if(BadPressure.pressureGauge <
BadPressure.SafetyLimit - 15)
{
....
>java SetPressure
Gauge reads 15, safe limit is 20
SetPressure.java

07/06/2022
Mutual Exclusion over a Block
◼ use the keyword synchronized before a block of code
◼ Use a static object for the lock
◼ any available, convenient object will do
◼ cannot be a local object or instance variable

07/06/2022
Block Mutual Exclusion
class pressure extends Thread
{ static Object lock = new Object();
void raisePressure()
{
synchronized(lock);
{ // MUTEX starts here
if(SetPressure.pressureGauge <
SetPressure.SafetyLimit - 15)
{
...
}
} // MUTEX ends here
...
}

07/06/2022
Mutual Exclusion over a Method
◼ use synchronized keyword on the instance
method.
◼ guarantees that only one of the perhaps
many synchronized instance methods will be
executing at any one time on a given
instance of that class
◼ equivalent to synchronized(this) over a block
◼ Examples:
◼ raisePressure
◼ Monitors

07/06/2022
Method Synchronization
synchronized void raisePressure()
{
if(p.pressureGauge <
p.SafetyLimit - 15)
{
...
same as
void raisePressure()
{
synchronized(this) // on this object
{
if(p.pressureGauge < p.SafetyLimit - 15)
{ ...
}
}

07/06/2022

07/06/2022
Communicating Mutually Exclusive Threads
◼ Threads that need to access common data, but
also communicate with one another
◼ the hardest kind of thread programming
◼ Producer/Consumer type of problem
◼ I produce, you consume. Don’t try to produce
until there is something to consume. Don’t
produce too much, until something is consumed
◼ Wait/Notify is the solution

07/06/2022
Wait / Notify
◼ Wait says “I have the lock, but there is nothing to
consume. I give up the lock and wait”
◼ Notify says “I just produced something, I will place it
in common area, release the lock and wait”

07/06/2022
Producer Pseudo-code
// producer thread
enter synchronized code // get lock
while(buffer_full)
wait();
produced_item_to_buffer()
notify() // tell waiting consumers
leave synchronized code // release lock

07/06/2022
consumerPseudo-code
// consumer thread
enter synchronized code // get lock
while(no_items)
wait();
consume_item_from_buffer()
notify() // now, there’s space for new item
leave synchronized code

07/06/2022
Examples
◼ plum.java
◼ inelegant dependant producer-consumer
◼ one producer-multiple consumers
◼ Operator.java
◼ Telephone Game (very inelegant)
◼ Tally Examples
◼ TallyWrong.java
◼ TallyRight.java
◼ Note how inner classes compile
◼ PutGet.java
◼ vary relative wait times and see what happens
◼ use of wait() and notify among cooperating processes
◼ Deadlock.java
◼ oh, oh; somewhat inelegant – works only with single buffer

Carrera de Software
150
07/06/2022
Interfaz gráfica de usuario e
hilos
Unidad 3
Final de la unidad

POO Unidad 3: Interfaz gráfica de usuario e hilos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a POO Unidad 3: Interfaz gráfica de usuario e hilos

Similar a POO Unidad 3: Interfaz gráfica de usuario e hilos (20)

Más de Franklin Parrales Bravo

Más de Franklin Parrales Bravo (20)

Último

Último (6)

POO Unidad 3: Interfaz gráfica de usuario e hilos