Más Crear blog Acceder

APRENDIENDO A PROGRAMAR
JAVA VBA HTML CSS
APUNTES JAVA VBA HTLM5 CSS Cuando empecé a aprender a programar, me dí cuenta que en ocasiones no
era tan fácil como creía encontrar apuntes y deseo compartir lo que voy aprendiendo por si a alguien le resulta de
utilidad. Ahora tengo una meta que es aprender java, empecé desde cero con la programación orientada a
objetos, las herencias de java, que es una clase en java y poco a poco intento sumar conocimientos y
compartirlos con todos vosotros.

martes, 23 de enero de 2018

EVENTOS DE VENTANA JAVA

EVENTOS
Un evento constituye un método para que una clase notifique a los usuarios de un objeto que
algo interesante le sucede, como, por ejemplo, que se ha hecho clic en un control de una interfaz gráfica
de usuario. Esta notificación se denomina provocar un evento, este evento desencadenará una acción.
En este caso el evento es hacer clic, pero dependiendo de en qué botón hagamos clic la acción
que se desencadena es diferente. No es lo mismo hacer clic en el botón de grabar de un formulario que
hacer clic en el de cerrar. Pero el evento sí que es el mismo hacer clic.

Para programar en java eventos nos resultaran necesarios 3 objetos:

1. Que desencadenante de la acción (hacer clic, cerrar ventana, cargar el programa.. )

OBJETO EVENTO

2. Quien desencadena la acción (que botón toco el usuario, que venta cerro, que programa cerro…)

OBJETO FUENTE

3. Quién recibe la acción , cuando hagamos clic en el botón X sobre que objeto se desencadenara la
acción(la ventana, el programa, el formulario, la impresora..)

OBJETO LISTENER implementa la interface ActionListener

Ejemplo. Google+ Followers

Nosotros tenemos un formulario con un botón guardar y el usuario lo clica para cerrar el programa.
DAVID GIMÉNEZ
OBJETO EVENTO = Hacer clic
OBJETO FUENTE = El botón rojo, amarillo o azul Añadir a círculos
OBJETO LISTENER = La lamina
ACCIÓN = Modificar color de la lámina (setBackground)

Crear un botón (button) ActionListener

Para crear el botón en la lámina necesitamos la clase JBuuton, creamos un objeto de la clase JButton y
con el método add() lo cargamos en el constructor;
class Lamina6 extends JPanel{
private Image foto;
JButton PrimerBoton= new JButton ("CERRAR");
// constructor donde hacemos visible el boton
public Lamina6() { 103 me tienen en sus Ver
add(PrimerBoton); círculos. todo
}
Ejercicio:
Es la interface que tenemos que utilizar para realizar acciones de botones, esta
Seguidores
interface nos obliga a implementar el método actionPerformed(ActionEvent e)
import java.awt.*;
import javax.swing.*;
import java.awt.event.*; Seguidores (4)
public class ddd {
public static void main(String[] args) {
Marco10 mimarco10 = new Marco10();
mimarco10.setVisible(true); Seguir
mimarco10.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class Marco10 extends JFrame{ Archivo del blog
public Marco10() {
setTitle("ESTE ES NUESTRO MARCO"); ▼ 2018 (131)
setBounds (700,300,500,300);
Lamina colores = new Lamina(); ► agosto (1)
add(colores);
► junio (3)
}
} ► mayo (3)
class Lamina extends JPanel implements ActionListener{
JButton botonAzul = new JButton("Azul"); ► abril (26)
JButton botonRojo = new JButton("Rojo");
JButton botonAmarillo = new JButton("Amarillo"); ► marzo (43)
public Lamina() {
add(botonAzul); ► febrero (14)
add(botonRojo);
add(botonAmarillo); ▼ enero (41)
botonAzul.addActionListener(this);//el oyente es la lamina (this) OBJETOS DE UN Marco java
botonRojo.addActionListener(this);
botonAmarillo.addActionListener(this); VBA ACCESS CASOS
} PRACTICOS
public void actionPerformed(ActionEvent e) {
Object FUENTE = e.getSource(); EVENTOS DE VENTANA
if (FUENTE == botonAzul) {setBackground(Color.blue);} JAVA
else if (FUENTE == botonRojo) {setBackground(Color.RED);}
EVENTOS JAVA Múltiples
else if (FUENTE == botonAmarillo) {setBackground(Color.YELLOW);}
fuentes para un solo
}
oyente...
}
EVENTOS JAVA
También lo podríamos hacer así: PONER EL FONDO DE
public void actionPerformed(ActionEvent e) { ECLIPSE NEGRO
switch (e.getActionCommand()) {
case "Azul": setBackground(Color.blue); break; diccionario programación
case "Amarillo": setBackground(Color.yellow); break;
case "Rojo": setBackground(Color.red); break; UTILIZAR VARIAS FUENTES
default: break; DE EVENTOS JAVA
}
Eventos de foco en ventana
}
windowFocusListener jav...
_____________________________________________________________________________
CONFIRMAR UN CORREO
PODRIAMOS EJECUTAR EL EJERCICIO ANTERIOR UTILIZANDO UNA CLASE INTERNA Y CON JAVA
CREANDO OBJETOS CON LOS COLORES.
CUADROS DE TEXTO E
import java.awt.*; IMÁGENES EN UN
import javax.swing.*; MARCO DE JAVA
import java.awt.event.*;
public class ddd { Eventos de foco FocusListener
public static void main(String[] args) { java
Marco10 mimarco10 = new Marco10();
mimarco10.setVisible(true); RECORDSET VBA ACCES
mimarco10.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ADO O DAO
}
Eventos de ratón
}
MouseMotionListener
class Marco10 extends JFrame{
public Marco10() { Eventos de ratón
setTitle("ESTE ES NUESTRO MARCO"); MouseListener
setBounds (700,300,500,300);
Lamina colores = new Lamina(); Eventos de teclado con
add(colores); interface KeyListner
}
} NÚMERO FACTORIAL CON
class Lamina extends JPanel{ JAVA
JButton botonAzul = new JButton("Azul");
JButton botonRojo = new JButton("Rojo"); DoCmd.SetWarnings true or
JButton botonAmarillo = new JButton("Amarillo"); false: activa y desactiv...
public Lamina() {
add(botonAzul); TRATAMIENTO DE
add(botonRojo); NÚMEROS PRIMOS JAVA
add(botonAmarillo); CREAR UN RECORDSET EN
ColorFondo2 auzul = new ColorFondo2(Color.BLUE); ACCESS
ColorFondo2 Rojo = new ColorFondo2(Color.red);
ColorFondo2 Amarillo = new ColorFondo2(Color.YELLOW); COMPARAR DOS STRING
botonAzul.addActionListener(auzul);//el oyente CON UN IF VBA ACCES
botonRojo.addActionListener(Rojo); USANDO LIK...
botonAmarillo.addActionListener(Amarillo);
} Controlador de estados de las
///UTIÑIZAMOS UNA CLASE INTERNA DENTRO DE LA LAMINA ventanas java
private class ColorFondo2 implements ActionListener{
private Color ColorDefondo; CREAR UN CONTROLADOR
public ColorFondo2 (Color c) {//constructor DE ESTADOS DE UNA
ColorDefondo=c; VENTANA jav...
}
public void actionPerformed (ActionEvent e) { Eventos de ventanas con
setBackground(ColorDefondo); clases adaptadoras java
}
COMPUTACIÓN CUÁNTICA
}
}
 Eventos de ventanas
Eventos de ventanas WindowListener WindowListener

EVENTOS JAVA

WindiowListener se utiliza para activar acciones de ventana. Nuestro oyente serán acciones que realice INSERTAR UN PDF EN UN
nuestra venta o Frame (maximizar, cerrar, mientras se cierra, mientras se queda en segundo plano, POST DE BLOGGER
restaurar, minimizar, abrir). TEXTAREA

CREAR UN BOTÓN EN UN A
METODOS: La interface WindowListener nos obliga a implementar los siguiente métodos siempre, los LAMINA DE UNA MARCO
utilicemos o no. DE JAV...
1. public void windowActivated(WindowEvent e) {SE DESEMBOCA AL MAXIMIZAR LA CENTA}
APRENDER A PROGRAMAR
2. public void windowClosed(WindowEvent e) {DESEMBOCA AL CERRAR LA VENTANA}
3. public void windowClosing(WindowEvent e) {SE DESEMBOCA MIENTRAS CERRAMOS LA VENTANA"} HACER UN MOSAICO
4. public void windowDeactivated(WindowEvent e) {DESEMBOCA AL DEJAR EN SEGUNDO PLANO O DENTRO DE UNA LAMINA
MINIMIZADA LA VENTANA"} DE UN MARCO ...
5. public void windowDeiconified(WindowEvent e) {DESEMBOCA AL RESTAURAR LA VENTANA}
6. public void windowIconified(WindowEvent e) {MINIMIZAR VENTANA} COPIAR Y PEGAR
7. public void windowOpened(WindowEvent e) {DESEMBOCA AL ABRIR LA VENTANA} IMÁGENES DENTRO DE
UNA LAMINA DE UN...

INCLUIR Y MANIPULAR
IMÁGENES DENTRO DE
UN FRAME
En el siguiente ejemplo crearemos dos marcos situándolos en dos puntos diferentes de la pantalla y
utilizaremos los eventos de pantalla implementado la interface WindowListener, hecho que nos obligara DAR COLOR A TEXTOS Y
a poner todos sus métodos. FONDOS DE UNA MARCO
(FRAME)
import javax.swing.*;
import java.awt.Color; DAR FORMATO A LOS
import java.awt.Font; TEXTOS DE UN FRAME
import java.awt.Graphics; JAVA
import java.awt.Graphics2D;
import java.awt.event.WindowEvent; Como saber los tipos de letras
import java.awt.event.WindowListener; que tenemos en nues...
public class frame1 {
public static void main(String[] args) { MATRICES (ARRAYS O
Marco MARCO_1 = new Marco(); ARREGLOS) java
Marco MARCO_2 = new Marco();
MARCO_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); incluir una lamina dentro de un
marco java
MARCO_1.setTitle("MARCO 1");
MARCO_1.setBounds(200,300,500,350); INTERFACES DE USUARIOS
JAVA
MARCO_2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); ¿POR QUE JAVA?
MARCO_2.setTitle("MARCO 2");
MARCO_2.setBounds(800,300,500,350);
} ► 2017 (32)
}
class Marco extends JFrame{
public Marco() {
setBounds(300,300,500,350);
setVisible(true);
Follow by Email
lamina l = new lamina();
add(l); Email address... Submit
//PONEMOS A NUESTRO MARCO A LA ESPERA DE UNA ACCION DE VENTA
oyente oyenteVentana = new oyente();
addWindowListener(oyenteVentana);
} Páginas
}
Página principal
class lamina extends JPanel{

public void paintComponent(Graphics g) {

super.paintComponent(g);
Datos personales
//refundicion de Graphics2D
Graphics2D g2d = (Graphics2D) g;
Font Letra = new Font("Arial",Font.BOLD,20);

setBackground(Color.darkGray);
g.setFont(Letra);
g.setColor(Color.YELLOW);
g.drawString("TEXTO 1", 100, 100); DAVID GIMÉNEZ
Seguir 103
}
} Empece aprendiendo a programar a
los 38, creo que nunca es tarde si
class oyente implements WindowListener{
//TENEMOS QUE IMPLIMENTAR TODOS LOS MÉTODOS tienes ganas y pones constancia y
public void windowActivated(WindowEvent e) { esfuerzo
System.out.println("SE DESEMBOCA AL MAXIMIZAR LA CENTA");
Ver todo mi perfil
}
public void windowClosed(WindowEvent e) {
System.out.println("SE DESEMBOCA AL CERRAR LA VENTANA");
}
public void windowClosing(WindowEvent e) {
System.out.println("SE DESEMBOCA MIENTRAS CERRAMOS LA VENTANA"); Archivo del blog
}
public void windowDeactivated(WindowEvent e) { agosto 2018 (1)
System.out.println("DESEMBOCA AL DEJAR EN SEGUNDO PLANO O MINIMIZADA LA VENTANA");
} junio 2018 (3)
public void windowDeiconified(WindowEvent e) { mayo 2018 (3)
System.out.println("DESEMBOCA AL RESTAURAR LA VENTANA");
 } abril 2018 (26)
public void windowIconified(WindowEvent e) {//oyente boton minimizar
System.out.println("MINIMIZAR VENTANA"); marzo 2018 (43)
}
public void windowOpened(WindowEvent e) { febrero 2018 (14)
System.out.println("DESEMBOCA AL ABRIR LA VENTANA"); enero 2018 (41)
}
} diciembre 2017 (21)
Eventos de ventanas con clases adaptadoras noviembre 2017 (10)
octubre 2017 (1)
Normalmente cuando deseamos utilizar un interface windowlistener nos obliga a tener que implementar
los 7 métodos.
1. Public void windowActivated(WindowEvent e) {}
2. public void windowClosed(WindowEvent e) {}
3. public void windowClosing(WindowEvent e) {}
4. public void windowDeactivated(WindowEvent e) {}
5. public void windowDeiconified(WindowEvent e) {}
6. public void windowIconified(WindowEvent e) { }
7. public void windowOpened(WindowEvent e) {}

Para evitar esto tenemos las clases adaptadoras, en nuestro caso utilizaremos la
clase WindowAdapter.
Buscar este blog
Buscar
La clase WindowAdapter tiene ya implementadas las interfaces:
* WindowFocusListener

* WindowListener
Páginas vistas en total
* WindowStateListener

* EentListener
1 6 9 7 0

Por lo que si en nuestra clase herea de WindowAdapter tendremos implementados todos

los métodos, evitando así tener que declararlos todos.
Etiquetas
public Marco() {
¿Que conseguimos rellenando
setBounds(300,300,500,350); todos los datos de nuestra imagen?
setVisible(true);
¿Que formato de imagen tengo que
lamina l = new lamina();
poner en mi blog?
add(l);
·
addWindowListner( new oyente()); ArrayIndexOutOfBoundsException.I
} nputMismatchException
}
class oyente extends WindowAdapter{………….} <H1>
<H2>
<H3>
<H4>
EJERCICIO. <iframe>
acces

import javax.swing.*; ACCESS

import java.awt.Color;
actionPerformed
import java.awt.Font;
import java.awt.Graphics; add
import java.awt.Graphics2D;
import java.awt.event.WindowAdapter; addActionListener
import java.awt.event.WindowEvent;
addChangeListener
import java.awt.event.WindowListener;
addItemListener
public class frame1 {
public static void main(String[] args) { addMouseListener
Marco MARCO_1 = new Marco();
ADO
Marco MARCO_2 = new Marco();
MARCO_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); AlignmentAction
MARCO_1.setTitle("MARCO 1");
MARCO_1.setBounds(200,300,500,350); anchor Text
MARCO_2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
aprender a programar
MARCO_2.setTitle("MARCO 2");
MARCO_2.setBounds(800,300,500,350); APRENDER A PROGRMAR
}
} aprendizaje
class Marco extends JFrame{
APUNTES
public Marco() {
setBounds(300,300,500,350); araña de google
setVisible(true);
lamina l = new lamina(); ArithmeticException
add(l);
array
//PONEMOS A NUESTRO MARCO A LA ESPERA DE UNA ACCION DE VENTA
addWindowListener(new oyente()); arrayList
}
} articulo viral
ATAJOS TECLADO
class lamina extends JPanel{
public void paintComponent(Graphics g) { automumérico
 super.paintComponent(g); Back Office
//refundicion de Graphics2D
Graphics2D g2d = (Graphics2D) g; Barra de Herramientas
Font Letra = new Font("Arial",Font.BOLD,20);
BoldAction
setBackground(Color.darkGray); BoldAction()
g.setFont(Letra);
g.setColor(Color.YELLOW); BorderLayout
g.drawString("TEXTO 1", 100, 100);
} botn
} BoxLayout
class oyente extends WindowAdapter{ //TENEMOS QUE IMPLIMENTAR TODOS LOS MÉTODOS
public void windowActivated(WindowEvent e) { bucle
System.out.println("SE DESEMBOCA AL MAXIMIZAR LA CENTA");
} bucle do
public void windowClosed(WindowEvent e) { BUCLE FOR
System.out.println("SE DESEMBOCA AL CERRAR LA VENTANA");
} BUCLE FOR EACH
public void windowClosing(WindowEvent e) {
System.out.println("SE DESEMBOCA MIENTRAS CERRAMOS LA VENTANA"); bucle while
} buffer
public void windowDeactivated(WindowEvent e) {
BufferReader
System.out.println("DESEMBOCA AL DEJAR EN SEGUNDO PLANO O MINIMIZADA LA VENTANA");
} BufferWriter
public void windowDeiconified(WindowEvent e) {
búsquedas para móvil
System.out.println("DESEMBOCA AL RESTAURAR LA VENTANA");
} cajas de texto multilínea
public void windowIconified(WindowEvent e) {//oyente boton minimizar
System.out.println("MINIMIZAR VENTANA"); calculadora
} CALSES ABSTRACTAS
public void windowOpened(WindowEvent e) {
System.out.println("DESEMBOCA AL ABRIR LA VENTANA"); campana extractora
}
} canRead
canWrite
catch
CONTROLADOR DE ESTADOS DE UNA VENTANA char
charAt
Existe una interface que actúa cuando existe una modificación del estado de ventana sea cual sea
clase
(aumentar, minimizar, maximizar, cerrar…). WindowStateListener y recibe por parámetro el método
CLASE ANÓNIMA
WindowStateChanged(Windowevent e). Este método actuará cuando exista una modificación del estado
de nuestra ventana. CLASE INTERNA
Windowevent tiene dos métodos: CLASE INTERNA ANONIMA

* getNewState(): Obtener nuevo estado. clase interna local

CLASE JOptionPane
* getOldState():Obtener anterior estado.
clases adaptadoras
CLASES ANIDADAS

En el siguiente ejercicio vamos a hacer dos marcos, le incluiremos dos botones y un texto, cuando CLASES INTERNAS ANÓNIMAS
realicemos una acción de venta (cerrar, abrir, maximizar…) nos saltara un mensaje avisando de que class
hemos realizado una modificación en nuestra ventana. CLASS FILE
import javax.swing.*;
import java.awt.*; Class Timer
import java.awt.event.*;
clonar
public class practica_frame6 {
public static void main (String[] arg) { Close()
Marco_100 Marco_1 = new Marco_100();
Marco_100 Marco_2 = new Marco_100(); Color)
Marco_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
COLORES
Marco_2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Marco_1.setVisible(true); cómo generar un artículo
Marco_2.setVisible(true);
Marco_1.setBounds(100,300,400,300); comparar dos String en un if
Marco_2.setBounds(500,300,400,300);
COMPRIMIDO
}
} computación cuantica
class Marco_100 extends JFrame{
public Marco_100() { condicional
ModificaEstado cambio = new ModificaEstado();
confirmar correo electronico
Lamina10 l1 = new Lamina10();
add(l1); CONFIRMAR UN CORREO
addWindowStateListener(cambio);
setVisible(true); constructor
}
CONSTRUCTOR DE BOTONES
}
class Lamina10 extends JPanel{ controlador de estados de ventana
public void paintComponent(Graphics g) {
super.paintComponent(g); controles teclado
JButton cerrar = new JButton("CERRAR");
COPIAR
JButton open = new JButton("open");
Font Arial = new Font("Arial",Font.BOLD,20); copyArea
add(cerrar); add(open);
crear método constructor de menú
setBackground(Color.blue);
crear un boton en una lamina
g.setFont(Arial);
g.setColor(Color.WHITE); CREAR UN RECORDSET
g.drawString("texto 1", 100, 100);
 } crear un recorset
}
__________________________________________________________________ crear una propia
///////cuando hagamos algo con nuestra venta ejecutara esto//////
__________________________________________________________________ createGlue
class ModificaEstado implements WindowStateListener { createHorizontalBox
public void windowStateChanged(WindowEvent e) {
JOptionPane.showMessageDialog(null,"VENTANA MODIFICADA"); createHorizontalStrut
}
} createNewFile
createVerticalBox

En el siguiente ejercicio crearemos dos marcos con dos botones, y createVerticarStrut

utilizaremos el método getNewState() de la interface Windowevent para que nos regrese cuadro texto

el estado en que se encuentra nuestra ventana, este estado nos lo regresa como un int que DAO
introduciremos en un array para que nos regrese un output de texto en el que nos indicará el Dar tamaño a un texto
estado de la ventana. debugger
debuggimg
En la siguiente tabla os dejo los diferentes estados: dentro del frame
depuración. try
desactivar mensajes de consultas
desagüe
Constant Field Value descripción de búsqueda
CROSSHAIR_CURSOR 1 diccionario de terninos
DEFAULT_CURSOR 0 DIRECTORIOS
E_RESIZE_CURSOR 11
dl
HAND_CURSOR 12
docmd
ICONIFIED 1
DoCmd.SetWarnings
MAXIMIZED_BOTH 6
ECLIPSE
MAXIMIZED_HORIZ 2
EJECUTABLE
MAXIMIZED_VERT 4
ejercicio
MOVE_CURSOR 13
ejercicio polimorfismo
N_RESIZE_CURSOR 8
ejercicios
NE_RESIZE_CURSOR 7
Encabezado
NORMAL 0
NW_RESIZE_CURSOR 6 ensureCapacity

S_RESIZE_CURSOR 9 enumerados

SE_RESIZE_CURSOR 5 error
SW_RESIZE_CURSOR 4 errores propios
TEXT_CURSOR 2 Escayola
W_RESIZE_CURSOR 10 escribir archivo texto.
WAIT_CURSOR 3 etiqueta
etiquetas
Ejercicio 2
eventos

import javax.swing.*; eventos de foco

import java.awt.*;
EVENTOS DE VENTAN
import java.awt.event.*;
public class practica_frame6 { eventos de ventana
public static void main (String[] arg) {
Marco_100 Marco_1 = new Marco_100(); eventos raton
Marco_100 Marco_2 = new Marco_100();
eventos ratón
Marco_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Marco_2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); exceel
Marco_1.setVisible(true);
Marco_2.setVisible(true); Excel
Marco_1.setBounds(100,300,400,300);
Exists
Marco_2.setBounds(500,300,400,300);
} FICHEROS
}
class Marco_100 extends JFrame{ FileImputStream
public Marco_100() {
FileInputStrem
ModificaEstado cambio = new ModificaEstado();
Lamina1000 l1 = new Lamina1000(); FileOutputStrem
add(l1);
addWindowStateListener(cambio); FileOutpuutStream
setVisible(true);
FileRead
}
} FileWrite
class Lamina1000 extends JPanel{
public void paintComponent(Graphics g) { finally
super.paintComponent(g);
FlowLayot
JButton cerrar = new JButton("CERRAR");
JButton open = new JButton("open"); foco .FocusListener
Font Arial = new Font("Arial",Font.BOLD,20);
add(cerrar); add(open); foco ventana
setBackground(Color.blue);
 g.setFont(Arial); FontSizeAction
g.setColor(Color.WHITE);
g.drawString("texto 1", 100, 100); FontSizeAction(String
}
} FORMATO LETRA
class ModificaEstado implements WindowStateListener { formulas
public void windowStateChanged(WindowEvent e) {
int tipoVentana = e.getNewState();//nos regresa un numero FRAME
String [] estado = {
"Ventana en estado DEFAULT_CURSOR", fuentes
"Ventana en estado espera", get
"Ventana en estado Maximiza horizontal",
"Ventana en estado Minimiza", GetAbsolutPath
"Ventana en estado SW_REDIMENSIONAR_CURSOR",
"Ventana en estado SE_REDIMENSIONAR_CURSOR", getActionCommand
"Ventana en estado S_REDIMENSIONAR_CURSOR", getComponent
"Ventana en estado NORMAL",
"Ventana en estado N_REDIMENSIONAR_CURSOR", getComponentCount
"Ventana en estado W_REDIMENSIONAR_CURSOR",
"Ventana en estado HAND_CURSOR", getItem()
"Ventana en estado MOVE_CURSOR"}; getNewState
JOptionPane.showMessageDialog(null,estado[tipoVentana ]);
} GETTER Y SETTER
}
GRARTIS

Si nosotros necesitamos usar estos estados en un if seguramente no nos acordaremos de los números. gratis

Podemos hacer uso de Frame.Estado. GregorianCalender

Ejem GridLayout
class ModificaEstados implements WindowStateListener {
public void windowStateChanged(WindowEvent e) { h1
if(e.getNewState()== Frame.MAXIMIZED_BOTH) { h2
JOptionPane.showMessageDialog(null,"mawimizada");
} h3
if(e.getNewState()==Frame.NORMAL) {
JOptionPane.showMessageDialog(null,"ventana normal"); H4
} HARINA
hasnext
hipervinculo dinámico
Eventos de teclado con interface KeyListner
htlm
html
Un evento de teclado se desencadena cuando nuestro usuario ejerce sobre el teclado una
determinada combinación de teclas. Cuando estáis en Works y tocáis Control+n el texto se pone en html5
negrita, eso es un evento de teclado. huella de programa
Para programar eventos de teclado necesitaremos la interface KeyListner, esto nos obliga a programar
hyperlink
tres métodos:
ICONO
· KeyPressed (KeyEvent e): Tecla presionada, se puede utilizar para combinaciones le podemos decir
que si mantiene pulsada una tecla y después toca otra, os suena de algo esto (Ctrl+t , Ctrl+x, Ctrl+z…) Iconos en menu
pues si introducimos un if lo tenemos. . if.java.bucle
· KeyReleased (KeyEvent e): Tecla liberada, cuando soltamos la tecla. IMAGEN
· KeyTyped (KeyEvent e): Clave mecanografiada, cuando hemos presionado la tecla y la hemos
imagenes
soltado.
Si no queremos crear todos los métodos porque solo vamos a utilizar uno de ellos tenemos la clase imágenes

adaptadora KeyAdapter. INCLUIR UN JTEXTBOX EN EL

La case keyListener pasa por parámetros la clase KeyEvent por lo que tendremos a nuestra disposición MENÚ

todos los métodos de ella: inodoro

· getKeyChar(): Nos regresa la tecla pulsada. InputEvent
· getKeyChar(): Nos regresa el código que representa para java la tecla pulsada
interface
Podemos crear la clase que implementa e implementar la interface KeyListener, hecho que nos obligará
interface usuaario
a crear los tres métodos.
En el siguiente ejemplo java escribirá en la pantalla de inmediato de nuestro equipo cada tecla que interfaZ
nosotros vallamos pulsando. IOException
class EscuchaTeclado implements KeyListener{//oyente
public void keyPressed(KeyEvent e) { isDirectory
int codice=e.getKeyChar(); ItalicAction
System.out.print(e);
} ItalicAction()
public void keyReleased(KeyEvent e) { }
public void keyTyped(KeyEvent e) {} ItemEvent
} itemStateChanged
Y luego llamarla desde el constructor del frame:
Iterator
class Marco_1000 extends JFrame{
public Marco_1000() { JAR
EscuchaTeclado tecla = new EscuchaTeclado();
addKeyListener(tecla); java
ModificaEstados cambio = new ModificaEstados(); java.ShowOptionDialog
Lamina1000 l1 = new Lamina1000();
add(l1); javaj
addWindowStateListener(cambio);
JButton
setVisible(true); JCheckBox
}
} JCheckBoxMenuItem

Eventos de ratón MouseListener JComboBox

 jframe
La interface MouseListener implementa 5 métodos, por lo que cuando la utilicemos tendremos que
JMenu
crearlos o utilizar una clase adaptadora que los tiene implementados, en nuestro caso sería
MouseAdapter. JMenuBar
JMenueltem
Métodos de MouseListener: jPanel
· mouseCliked (mouseEvent e): El usuario ya ha presionado y soltado el botón.
JPopMenu
· mousePreseed (mouseEvent e): El botón del ratón está siendo presionado
JPopupMenu
· mouseReleased (mouseEvent e): El botón del ratón está regresando a su lugar después de haber
sido presionado (el usuario retira el dedo del botón). JRadioButon
· mouseEntered (mouseEvent e): Cuando el puntero del ratón entra en una zona determinada de la jRadioButton
pantalla JRadioButtonMenuItem
· mouseExited (mouseEvent e): Cuando el puntero del ratón sale en una zona determinada de la
JSlider
pantalla
JSpinner

MousListener en sus métodos para por parámetros mousEvent por lo que tendremos a nuestra JToolBar
disposición los métodos de esta clase. KeyEvent
Métodos MouseEvent:
KeyListener
· getX():posición X del ratón en pantalla en un momento determinado
Keywords
· getY():posición Y del ratón en pantalla en un momento determinado
· gerModifiersEx(): nos indica si el usuario ha tocado el botón derecho, izquierdo o l rueda del ratón. LAMINA
· getClickCount(): Cuenta el número de clics que ha hecho el usuario. laminas
lanzar excepciones
1º. Creamos una clase que implementa la interface MouseListener
Layout

class raton implements MouseListener {// oyente raton Layout libre

public void mouseClicked(MouseEvent e) {
layout(null)
JOptionPane.showMessageDialog(null,"HAS HECHO CLICK CON EL RATON EN EL PUNTO
X; "+e.getX()+ ", Y: "+e.getY()+ " de la lamina"); LayoutManager
}
public void mouseEntered(MouseEvent e) {} lector
public void mouseExited(MouseEvent e) {}
leer archivos de texto
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {} LENGUAJE DE CONSULTAS
ESTRUCTURADO
}
leyenda
list
MARCO
2º. Ahora la cargamos en el constructor del frame. marcos
class Marco_1000 extends JFrame{
public Marco_1000() { math
matrices o arrays
//eventos raton
raton Perez = new raton(); matrices o arrays bidimiensionales
addMouseListener(Perez);
// eventos teclado menu
EscuchaTeclado tecla = new EscuchaTeclado();
MENU EMERGENTE
addKeyListener(tecla);
// eventos de venta (para botones) meta description
ModificaEstados cambio = new ModificaEstados();
addWindowStateListener(cambio); MÉTODO
//lamina del frame
método constructo
Lamina1000 l1 = new Lamina1000();
add(l1); mkdir

setVisible(true); modificadores acceso

}
montaje

Ejercicio: ahora probemos todos los métodos MOSAICO

class raton implements MouseListener {// oyente raton mouse
public void mouseClicked(MouseEvent e) {
System.out.println("HAS HECHO CLICK CON EL RATON EN EL PUNTO X; "+e.getX()+ ", Y: "+e.getY()+ " de MouseListener
la lamina");
MouseMotionListener
System.out.println(e.getClickCount());
} móvil
public void mouseEntered(MouseEvent e) {
System.out.println("x: " +e.getX()+ " Y:"+e.getY()); MULTIFUENTE
}
Múltiples fuentes para un solo
public void mouseExited(MouseEvent e) {}
oyente
public void mousePressed(MouseEvent e) {
String [] Qboton = new String[3]; next
Qboton[0]="BOTON DERECHO DEL RATON";
Qboton[1]="BONTON IZQUIERDO DEL RATON"; Nociones básicas de Seo para blog
Qboton[2]="RUEDA DEL RATON";
NullPointerException
if (e.getModifiersEx() == 4096) { NumberFormatException
System.out.println(Qboton[0]);
} else if (e.getModifiersEx() == 1024) { NÚMEROS FACTORIALES
System.out.println(Qboton[1]);
NÚMEROS PRIMOS
} else if(e.getModifiersEx()==2048) {
System.out.println(Qboton[2]); ObjectInputStream
}
} objeto
 El if anterior también lo podemos hacer así: objetos
class raton implements MouseListener {// oyente raton
public void mouseClicked(MouseEvent e) { OCULTAR MENUS
System.out.println("HAS HECHO CLICK CON EL RATON EN EL PUNTO X; "+e.getX()+ ", Y: off page
"+e.getY()+ " de la lamina");
System.out.println(e.getClickCount()); offimatica
}
public void mouseEntered(MouseEvent e) { OFIMÁTICA
System.out.println("x: " +e.getX()+ " Y:"+e.getY()); on page
}
public void mouseExited(MouseEvent e) {} operadores
public void mousePressed(MouseEvent e) {
if (e.getModifiersEx() == MouseEvent.BUTTON2_DOWN_MASK ) { opinión
System.out.println("has `pulsado el boton izquierdo"); palabra clave
}else if (e.getModifiersEx() == MouseEvent.BUTTON1_DOWN_MASK) {
System.out.println("has pulsado la rueda del raton"); PAN
}else if(e.getModifiersEx()==MouseEvent.BUTTON3_DOWN_MASK) {
System.out.println("has pulsado el boton derecho"); PAN CASERO
} PAN DE MOLDE
}
public void mouseReleased(MouseEvent e) {} PANEL
PANTALLA NEGRA
}
pantalla oscura

Eventos de ratón MouseMotionListener PARÁMETRO DE TIPO

pc
Controla si estamos moviendo o arrastrando el ratón implementaremos esta interface para controlarlos, pdf
se compone de dos métodos. PEGAR
POLIMORFISMO
· mouseDragged (MouseEvent e) : Se invoca cuando se desplaza el ratón con el botón pulsado
poo
· mouseMoved (MouseEvent e) : Se invoca cuando movemos el ratón sin pulsar el botón.
practica procesador Texto
Creamos la clase: PROCESADOR DE TEXTOS CON
class raton2 implements MouseMotionListener{ JAVA

public void mouseDragged(MouseEvent e) { PROCESADOR DE TEXTOS CON

System.out.println("desplazas el ratón con el botón pulsado"); JAVA 2
} procesador textos
public void mouseMoved(MouseEvent e) { programación
System.out.println("desplazas el ratón sin pulsar el botón");
} PROGRAMACIÓN GENÉRICA
r
Ahora la cargamos en el frame: ratón
class Marco_1000 extends JFrame{
public Marco_1000() { read
read()
//eventos raton
raton Perez = new raton(); readLine()
addMouseListener(Perez);
//eventos desplazamiento raton readObject
raton2 desplazaRaton = new raton2();
RECETA
addMouseMotionListener(desplazaRaton);
// eventos teclado recodset
EscuchaTeclado tecla = new EscuchaTeclado();
addKeyListener(tecla); REDIMENSIONAR UNA FOTO
// eventos de venta (para botones)
REDUCIR CODIGO CON MÉTODO
ModificaEstados cambio = new ModificaEstados();
CONSTRUCTOR
addWindowStateListener(cambio);
//lamina del frame refundación de Objetos. casting.
Lamina1000 l1 = new Lamina1000(); java
add(l1);
setVisible(true); retrete
}
seo
Podemos implementar todas las interfaces en una sola clase, así será más rápido y limpio, evitando
cargar clase por clase, todas irán en una única. Seo para blog
class ModificaEstados implements Serializable
WindowStateListener,KeyListener,MouseListener,MouseMotionListener{
serializar
public void mouseDragged(MouseEvent e) {….}
serialVersionUID
public void mouseMoved(MouseEvent e) {……}
public void mouseClicked(MouseEvent e) {……..} Seroalizado
public void mouseEntered(MouseEvent e) {………}
public void mouseExited(MouseEvent e) {……….} set
public void mousePressed(MouseEvent e) {……….}
setLayout (null)
public void mouseReleased(MouseEvent e) {……….}
public void keyPressed(KeyEvent e) {………..} SHA
public void keyReleased(KeyEvent e) {……….}
public void keyTyped(KeyEvent e) {……..} showConfirmDialog
public void windowStateChanged(WindowEvent arg0){……..}
showImputDialog
} showInputDialog
Eventos de foco en componentes FocusListener showMessageDialog
showOptionDialog
size
slip
Un evento de foco es aquel que se desemboca cuando tenemos seleccionado un determinado espacio SpringLayout
de la interface, podemos tener un botón seleccionado, un marco, un archivo. Supongo que alguna vez
SQL
habéis rellenado un formulario en una web, cuando cambias de casilla estas poniendo el foco en la
siguiente casilla. Squl

En este caso vamos a ver cómo hacerlo dentro de un componente. STATIC/FINAL

Para ello u lizaremos la interface FocusListener, por lo que estaremos obligados a implementar 2 métodos: Stream
· focusGained (FocusEvent e): el elemento adquiere el foco.
string
· focusLost (FocusEvent e): el elemento pierde el foco.
StyledEditorKit
SUB CLASE
En caso de no desear implementar los dos disponemos de la clase adaptadora FocusAdapter. subtitulo
0. Necesitaremos dos tex iled , las variables se declaran dentro de la lámina porque serán internas y de
switch
uso interno solo en la lamina
class A_lamina extends JPanel{ tabla
public void paintComponent(Graphics g){//constructor tablet
super.paintComponent(g);
teclado

setBackground(Color.DARK_GRAY); texto
setLayout(null); //establecer diseño por defecto no texto de titulo
cuadro1=new JTextField();
cuadro2=new JTextField(); Texto del alt
cuadro1.setBounds(100,50,150,20);
cuadro2.setBounds(100,90,150,20); throw
add(cuadro1); throws
add(cuadro2);
} tipos comodín
JTextField cuadro1,cuadro2; tipos de datos
}
TIPOS DE VARIABLES
1. Ahora generamos una clase interna con el oyente y ponemos y ponemos el cuadro una como
toma pared
desencadenante.
class A_lamina extends JPanel{ ToString().
public void paintComponent(Graphics g){//constructor
super.paintComponent(g); trabajo administrativo.
setBackground(Color.DARK_GRAY); programadores web
setLayout(null); //establecer diseño por defecto no tratamiento de imágenes
cuadro1=new JTextField();
cuadro2=new JTextField(); tratamiento errores
cuadro1.setBounds(100,50,150,20);
cuadro2.setBounds(100,90,150,20); trimToSize
add(cuadro1); try
add(cuadro2);
cuadro1.addFocusListener(new escucha()); TXTAREA
}
JTextField cuadro1,cuadro2; ul
private Image foto; UnderlineAction
private class escucha implements FocusListener{
public void focusGained(FocusEvent e) {System.out.println("estas dentro del cuadro unir layouts
1");}
public void focusLost(FocusEvent e) {System.out.println("estas fuera del cuadro 1");} URLMalformedException
} } usos de access y excel
En la siguiente práctica realizaremos un marco al que le introduciremos una lámina con una foto de
fondo y en la que pondremos dos cuadros de texto. Para posteriormente generar los eventos de foco, usos del final
ratón, teclado
VABA
import javax.imageio.ImageIO; váter
import javax.swing.*;
import java.awt.*; vba
import java.awt.event.*;
import java.io.File; VENTANA
import java.io.IOException; ventanas emergentes
public class Practica_JText {
public static void main (String[] arg) { vida laboral
A_marco1 cuadro = new A_marco1();
cuadro.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); viga
} vocabulario
}
class A_marco1 extends JFrame{ w.c
public A_marco1() {
setVisible(true); water
setBounds(150, 150, 500, 300); wc
add(new A_lamina());
addWindowListener(new escucha2()); while
addWindowStateListener(new escucha2());
addKeyListener(new escucha2()); WindiowListener
addMouseListener(new escucha2()); Write
}
} write.java
class A_lamina extends JPanel{
public void paintComponent(Graphics g){//constructor
super.paintComponent(g);
try { //tratamineto de excepciones, haz esto y si no catch
foto = ImageIO.read(new
File("C:\\Users\\dagip\\Desktop\\BOGEER\\imagenes\\JAVA2.jpg"));//ruta relativa
} catch(IOException e) {
JOptionPane.showConfirmDialog(null, "no esta la foto");
}
//escribimos la foto en nuestra lamina
g.drawImage(foto, 0, 0, null);
setBackground(Color.DARK_GRAY);
 setLayout(null); //establecer diseño por defecto no
cuadro1=new JTextField();
cuadro2=new JTextField();
cuadro1.setBounds(100,50,150,20);
cuadro2.setBounds(100,90,150,20);
add(cuadro1);
add(cuadro2);
cuadro1.addFocusListener(new escucha());
}
JTextField cuadro1,cuadro2;
private Image foto;
private class escucha implements FocusListener{
public void focusGained(FocusEvent e) {
System.out.println("estas dentro del cuadro 1");
}
public void focusLost(FocusEvent e) {S
ystem.out.println("estas fuera del cuadro 1"); Communicate
} Like A Team
}
}
Grammarly Business
class escucha2 implements
WindowListener,WindowStateListener,MouseListener,ActionListener,KeyListener{
Set Your Team Up For
public void windowStateChanged(WindowEvent e) {} Successful
public void windowActivated(WindowEvent e) {}
public void windowClosed(WindowEvent e) {}
Communication. Get
public void windowClosing(WindowEvent e) {} Grammarly Business.
public void windowDeactivated(WindowEvent e) {}
public void windowDeiconified(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowOpened(WindowEvent e) {}
public void keyPressed(KeyEvent e) {}
public void keyReleased(KeyEvent e) {} LEARN MORE
public void keyTyped(KeyEvent e) {}
public void actionPerformed(ActionEvent e) {}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}

Ejercicio 2. Ahora generamos otro marco con dos botones y dos cuadros de texto, y cuando el usuario
cambie el foco de un cuadro de texto al otro nos confirmará si el correo es correcto.
import java.awt.*;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.*;
public class Practica27_text {
public static void main (String[] arg) {
//cargar el frame
Marco_1111 x =new Marco_1111();
x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class Marco_1111 extends JFrame{
public Marco_1111() {
setVisible(true);
setBounds(150,150,800,390);
add(new Lamina_1111());

}
}
class Lamina_1111 extends JPanel{
public void paintComponent(Graphics g) {
super.paintComponent(g);
//cargar los botones en el frame
JButton Boton1=new JButton ("cerrar");
JButton Boton2=new JButton ("Abrir");
add(Boton1); add(Boton2);
Boton1.setBackground(Color.GREEN);
Boton1.setBounds(600, 20, 80, 30);
Boton2.setBackground(Color.GREEN);
Boton2.setBounds(600, 55, 80, 30);
// colgar imagen, para lo que necesitamos un tratamiento de excepciones
try { Foto1=ImageIO.read(new
File("C:\\Users\\dagip\\Desktop\\BOGEER\\imagenes\\JAVA2.jpg"));
} catch (IOException e) {
JOptionPane.showConfirmDialog(null, "la foto no esta en la ruta");
}
g.drawImage(Foto1,0,0,null);
c_t1= new JTextField(); c_t2= new JTextField();
c_t1.setBounds(50,50,250,40); c_t2.setBounds(50,100,250,40);
add(c_t1); add(c_t2);
c_t1.addFocusListener(new EventosDEfoco());
}
JTextField c_t1,c_t2;
Image Foto1;
private class EventosDEfoco implements FocusListener{
 public void focusGained(FocusEvent e) {}
public void focusLost(FocusEvent e) {
//para capturar el texto del cuadro getText()
String Correo = c_t1.getText();
boolean validador_arroba = false;
boolean validador_punto = false;
//ahora vamos a comprobar si el correo introducido es correcto
for (int i=0;i<Correo.length();i++) {
//recordar que cuando buscamos una letra serán comillas simples
if (Correo.charAt(i) == '@') {validador_arroba =true;}
if(Correo.charAt(i) == '.') {validador_punto = true;}
}
if(validador_punto==false && validador_arroba==false) {
String remplazar=JOptionPane.showInputDialog(null, "le falta un punto en su correo", "ejemplo@eeee.es");
c_t1.setText(remplazar); }
else if (validador_arroba==false && validador_punto == true) {
JOptionPane.showMessageDialog(null, "repasa si has puesto el @");
}
else if (validador_punto==false && validador_arroba == true) {
JOptionPane.showMessageDialog(null, "repasa si has puesto el punto");
}
}
}
}
Eventos de foco en marco windowFocusListener

Una interface gráfica puede estar compuesta por varias ventanas, en este caso puede suceder que una
de las ventanas pierda o gane el foco y se tenga que desencadenar una acción cuando esto suceda.
Para esto tenemos windowFocusListener compuesta por dos métodos.

· windowLostFocus(WindowEvent e) para cuando perdemos el foco de la venta.

· WindowGainedFocus(WindowEvent e) para cando ganamos el foca en la venta.

Ejm. En el siguiente ejemplo cargaremos dos macos cuando seleccionemos uno de ellos saldrá un
mensaje en el titulo, y cuando seleccionemos el otro desaparece el mensaje del primero y aparece en el
segundo.
import java.awt.event.WindowEvent;
import java.awt.event.WindowFocusListener;
import javax.swing.JFrame;
public class Practica28_ extends JFrame implements WindowFocusListener{
public static void main(String[] args) {
Practica28_ dd = new Practica28_();
dd.inicar();
}
public void inicar() {
marco1 = new Practica28_ (); marco2= new Practica28_();
marco1.setVisible(true); marco2.setVisible(true);
marco1.setBounds(100,200,300,300); marco2.setBounds(400,200,350,350);
marco1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//el oyente esta en nuestra clase por eso penemos this ventana
marco1.addWindowFocusListener(this);
marco2.addWindowFocusListener(this);
}
public void windowGainedFocus(WindowEvent e) {
if(e.getSource()==marco1) {
marco1.setTitle("TINES EL FOCO!!!!!!!!!");
marco2.setTitle("");
}if (e.getSource()==marco2) {
marco1.setTitle("");
marco2.setTitle("TINES EL FOCO!!!!!!!!!");
}
}
public void windowLostFocus(WindowEvent e) {}
Practica28_ marco1;
Practica28_ marco2;

UTILIZAR VARIAS FUENTES DE EVENTOS

Imaginemos se desencadene una acción cuando el usuario toco un botón del marco, que esa misma
acción se haga cuando el usuario accione un consunto de teclas y además que esa misma acción se
desencadene cuando haga doble click con el ratón.
Fuentes:

· Ratón
· Botón de marco
· Combinación teclado

Pero todas desencadenan la misma acción sobre un oyente.

 Para esto utilizaremos la interface Action que hereda de ActionPerformed (ActionEvent E) por lo que
dispone de todos sus métodos he implementa propios que nos obliga a implementas al tratarse de una
interface:
actionPerformed(ActionEvent arg0) {}
·
addPropertyChangeListener(PropertyChangeListener arg0) {}
· Escucha de cambio de propiedad, nos permitirá agregar una propiedad al objeto oyente.
Ejm. Seleccionar un texto

Object getValue(String arg0) {return null;}

· Obtener valor. Nos permite obtener la clave previamente almacenada con putValue
Es un método getter tal y como puede ver por el return.

isEnabled() {return false;}

· ¿Está habilitado?
Nos devuelve si está activado o no el objeto fuente de evento. Es un método getter tal y como puede ver por el return.

putValue(String arg0, Object arg1){}

· Poner valor. Almacena parejas de clave y de valor.

removePropertyChangeListener(PropertyChangeListener arg0){}
· Eliminar el cambio de oyente. Elimina la propiedad del objeto oyente.
· Ejm. Dejar de seleccionar un texto seleccionar un texto

etEnabled(boolean arg0){}
· ¿Establece habilitado? Verdadero/falso.
Activa o desactiva un objeto fuente de evento.

En caso de no querer utilizarlas todas podemos heredar de la clase AbstractAction y sobrescribir el

que necesitemos.

ASIGNAR ACCIONES AL TECLADO

1. Crear un mapa de entrada: La acción siempre se realizara sobre el objeto que tiene el foco y crear el
mapa de entrada es indicar a nuestro programa que objeto tiene el foco. Utilizaremos las clase InputMap
y JComponent
2. Crear combinación de teclas: decirle a nuestro programa que combinación de teclas declaramos
Ctrl+R. Utilizaremeos la clase KeyStroke
3. Asignar Combinaciones de teclas a objetos: Crear un objeto para cada una de las asignaciones de
teclas. Utilizaremos la clase InputMap.
4. Asignar objetos a acción: Decirle a los objetos que representan las combinaciones de teclado a los
objetos de acciones. Utilizaremos la clase ActionMap.

Ejercicio. En el siguiente ejercicio crearemos una lámina con fondo negro un texto en blanco con letra
Arial black, tres botones (verde,rojo,azul) y posterior mente vamos a generar dos fuentes para los
eventos. Por una los botones cambiaran los colores del fondo de la página y por otra existirán unas
teclas de acceso rápido que modificaran el color de la lámina:

Ctrl+R (rojo) Ctrl+V (verde) Ctrl+A (Azul)

import java.awt.*;
import java.awt.event.ActionEvent;
import javax.swing.*;
import javax.swing.JPanel;
import javax.swing.KeyStroke;
public class Practica29_eventos {
public static void main(String[] args) {
Marco123 Lamina123455888 = new Marco123();
Lamina123455888.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class Marco123 extends JFrame{
public Marco123() {
add(new Lamina123());
setBounds(100,150,500,300);
setVisible(true);
}
}
class Lamina123 extends JPanel{ //creamos la lamina como inner class.
public Lamina123 () {
//damos color inicial a la lamamina
setBackground(Color.gray);
//redimensionamos las fotos en caso de que no sean del tamaño adecuado para que
entren en el boton
ImageIcon Escala_verde= new ImageIcon("C:\\Users\\ruta\\src/puntoVerde.gif");
Image Escala_verde2 = Escala_verde.getImage().getScaledInstance(10, 10, Image.SCALE_SMOOTH);

ImageIcon Escala_Rojo= new ImageIcon("C:\\Users\\RUTA\\src/puntoRojo.gif");

Image Escala_Rojo2 = Escala_Rojo.getImage().getScaledInstance(10, 10, Image.SCALE_SMOOTH);

ImageIcon Escala_Azul= new ImageIcon("C:\\ruta\\src/puntoAzul.gif");

Image Escala_Azul2 = Escala_Azul.getImage().getScaledInstance(10, 10, Image.SCALE_SMOOTH);

//constres objetos de la clase Cambio color bajo creada

CambioColor oyente_Verde = new CambioColor("Verde",new
ImageIcon(Escala_verde2),Color.GREEN);
CambioColor oyente_Rojo = new CambioColor("Rojo",new
ImageIcon(Escala_Rojo2),Color.RED);
CambioColor oyente_Azul = new CambioColor("Azul",new ImageIcon(Escala_Azul2),
Color.BLUE);
//creamos los tres botones utilizando los objetos de la clase CambioColor
add(new JButton(oyente_Verde));
add(new JButton(oyente_Rojo));
add(new JButton(oyente_Azul));

/*1. Crear un mapa de entrada: La acción siempre se realizara sobre el objeto que
tiene el foco y crear el mapa de entrada es indicar a nuestro programa que objeto
tiene el foco. Utilizaremos las clase InputMap y mponent, le decimos que tiene que
actuar sobre un objeto que esta en la lámina, por eso le indicamos ""cuando está
enfocado en la ventana"" when_in_Focused_Window */

InputMap Crear_mapaEntrada = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);

/*2. Crear combinación de teclas: decirle a nuestro programa que combinación

* de teclas declaramos Ctrl+R. Utilizaremeos la clase KeyStroke*/
KeyStroke Ctrl_Verde = KeyStroke.getKeyStroke("ctrl V");
KeyStroke Ctrl_Rojo = KeyStroke.getKeyStroke("ctrl R");
KeyStroke Ctrl_Azul = KeyStroke.getKeyStroke("ctrl A");

/*3. Asignar Combinaciones de teclas a objetos: Crear un objeto para cada

* una de las asignaciones de teclas. Utilizaremos la clase InputMap.*/
Crear_mapaEntrada.put(Ctrl_Verde, "F_Verde");
Crear_mapaEntrada.put(Ctrl_Rojo, "F_Rojo");
Crear_mapaEntrada.put(Ctrl_Azul, "F_Azul");

/*4.Asignar objetos a acción: Decirle a los objetos que representan las

combinaciones de teclado a los objetos de acciones. Utilizaremos la clase
ActionMap.*/
ActionMap mapa = getActionMap();
mapa.put("F_Verde", oyente_Verde);
mapa.put("F_Rojo", oyente_Rojo);
mapa.put("F_Azul", oyente_Azul);
}
public void paintComponent (Graphics g) {
super.paintComponent(g);

//ACCEDEMOS A GRAPHICS2D PARA HACER UN PUNTERO DE FUENTES

Graphics2D g22 = (Graphics2D)g;
g22.setFont (new Font("Arial black", Font.BOLD,50));
g22.setColor(Color.BLACK);
//Escribimos el texto
g.drawString("TEXTO 1", 100,130);
}
private class CambioColor extends AbstractAction{
public CambioColor (String nombre, ImageIcon icono,Color color_boton) {
//Con putValue damos los valores
putValue(Action.NAME, nombre);
putValue(Action.SMALL_ICON,icono);
putValue(Action.SHORT_DESCRIPTION,"DA COLOR "+ nombre + " A LAMINA");
putValue("COLOR_fONDO", color_boton);
}

public void actionPerformed(ActionEvent e) {

//damos la claves a los colores con los botones
Color c = (Color)getValue("COLOR_fONDO");
setBackground(c);
}
}
}
Múltiples fuentes para un solo oyente
Hasta ahora hemos visto como generar un solo oyente pero múltiples fuentes, imaginemos que
deseamos que un solo oyente tenga varias fuentes.
Ejemplo Realizar un marco con dos botones uno de ellos abrirá una nueva ventana cada vez que le
hagamos click mientras que el segundo cerrará todas las ventanas abiertas (diferentes oyentes).
Una fuente: El botón de cerrar
Diferentes oyentes: Todas las ventanas.
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class Practica30 {
public static void main (String[] args) {
Marco xxx = new Marco();
xxx.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}
}

class Marco extends JFrame{

public Marco() {

add(new Lamina());
setBounds(800,50,500,300);
setVisible(true);

}
}

class Lamina extends JPanel{

public Lamina() {
setBackground(Color.gray);
//creamos los botones
JButton Abrir;
add( Abrir = new JButton("Abrir"));
add(boton_cerrar = new JButton("Cerrar todo"));
//le decimos que cundo se pulse el botón abrir
//llame a actionlistener en la clase oyente_ventan
Abrir.addActionListener(new oyente_ventana());
}

JButton boton_cerrar;

//CREAMOS UNA CLASE INTERNA IMPLEMENTANDO ACTIONLISTENER PARA ABRIR LAS

//LAS NUEVAS VENTANAS
private class oyente_ventana implements ActionListener{

public void actionPerformed(ActionEvent g) {

Nuevo nuevos_marco = new Nuevo(boton_cerrar);

nuevos_marco.setVisible(true);

}
public void paintComponent(Graphics g){
super.paintComponent(g);
Graphics2D g22 = (Graphics2D)g;
g22.setFont(new Font("Arial Black",Font.BOLD,50));
g.setColor(Color.BLUE);
g.drawString("TEXTO", 150, 175);

//CREAMOS UN FRAME PARA LAS NUEVAS VENTANAS

class Nuevo extends JFrame{

public Nuevo(JButton llamar_boton_cierre) {

SUMA_VENTAN++;
desplaza_ventan+=20;
setTitle("VENTANA " +SUMA_VENTAN);
//Para evitar que se superpongan las ventans lo
//sumamos el eje X y el eje Y desplaza_ventan
setBounds(30+desplaza_ventan,30+desplaza_ventan,300,150);

//llamos al boton del constructor de la clase Lamina

//que hemos pasado por parametros
llamar_boton_cierre.addActionListener(new Cerrador());
}
// encapsulamos dos variable para utilizarlas solo en este constructor
private static int SUMA_VENTAN =0;private static int desplaza_ventan=0;
//crearemos una clase interna para cerar los marcos
private class Cerrador implements ActionListener{

public void actionPerformed(ActionEvent e) {

//ultilizamos el metodo dispose() de Jframe para
//cerrar todos los objetos y liberar recursos

dispose();

By DAVID GIMÉNEZ - enero 23, 2018

Reacciones: útil (0) interesante (0) puede mejorar (0)

Etiquetas: EVENTOS DE VENTAN, java