Saltar navegación

2025-05-12-Programacion - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 12 de mayo de 2025 por Jose Manuel M.

20 visualizaciones

Tema 11 - Repaso interfaces gráficas escritorio

Más información Transcripción

Descargar la transcripción

Y listos. ¿Queréis alguna cosilla que comentemos antes de arrancar? 00:00:02
La última clase antes de la semana que viene. 00:00:08
La semana que viene estáis metidos en plena faena de exámenes, ya desde el viernes creo. 00:00:11
No sé si tendréis vosotros en particular algún examen el viernes, pero ya empiezan. 00:00:16
Y luego toda la semana que viene, no sé si hasta el jueves siguen los exámenes, 00:00:21
con lo cual la semana que viene se suspenden las clases normales. 00:00:26
y ya el siguiente lunes, como ya habréis hecho 00:00:29
el examen de la ordinaria, no sé exactamente 00:00:34
qué día nos pondrán las juntas de evaluación. Si nos ponen juntas de evaluación el lunes 00:00:38
no podría estar claro en los dos sitios, pero no sé qué día nos lo van a poner. Os iré 00:00:42
comunicando si estoy disponible o no en función 00:00:45
de las tareas que nos vayan poniendo aquí en el centro para la tutoría 00:00:50
no de la semana que viene, sino de la siguiente. Y en cualquier 00:00:54
claso probablemente lo que haríamos sería 00:00:58
pues habilitar la posibilidad de que 00:01:00
vengáis a ver el examen por aquí por 00:01:02
el centro para ese lunes 00:01:03
y para hoy pues un poquito 00:01:05
si tenéis alguna duda intentamos 00:01:09
abordarla en primer lugar 00:01:11
y si no pues os cuento un poquito 00:01:13
pues como hacer algunas cositas con 00:01:15
interfaz gráfico que es 00:01:17
de los dos temas últimos temas que tenemos 00:01:19
abiertos quizás el que 00:01:21
bueno pues el que nos pilla 00:01:23
un poco más a mano para poder contarlo algo 00:01:25
y nada os comentaba 00:01:27
también en tutorías anteriores de cara al examen 00:01:29
que los contenidos de estos dos últimos temas, interfaz gráfica y base de datos 00:01:33
pues no se puede decir que no entren porque ahí están en la asignatura 00:01:38
pero su presencia en el examen es escasa, vamos 00:01:40
que no tiene prácticamente trascendencia en lo que es la nota 00:01:45
ni consecuencias en otros ejercicios que se tengan que apoyar 00:01:48
en algo que tuvierais que hacer y que os bloquee el poder hacerlo 00:01:53
Así que en ese aspecto no os preocupéis. Si lo leéis, si tenéis la oportunidad de leer los temas, pues bien, por esa mínima puntuación que pueda aparecer en el examen, por si la cogéis y si no, pues nada, no os preocupéis tampoco en exceso. 00:01:56
Si no tenéis tiempo y lo tenéis que dedicar al resto de asignaturas o al resto de contenidos de esta asignatura. 00:02:11
y bueno, lo que me digáis un poco, no sé si queréis que comentemos alguna cosa 00:02:18
o como es habitual, me pongo a contaros 00:02:24
si no me decís lo contrario, me seguís escuchando bien, ¿verdad? 00:02:37
pues me pongo manos a la obra 00:02:44
¿me oís verdad? 00:02:46
no me he quedado... 00:02:49
si, vale, bien, bien, por perfecto 00:02:52
pues nada, os cuento, hacemos alguna cosita con interfaz gráfico 00:02:55
para que veáis cómo funciona, y así cerramos un poco la asignatura con esto. 00:02:59
Mirad, en Java, es un lenguaje que tiene mucha más presencia en el entorno web 00:03:08
que en el entorno de escritorio, aquí en esta asignatura no vemos nada de entorno web, 00:03:17
digamos que lo que pretende es sentar las bases de la programación orientada a objetos, 00:03:23
esta asignatura y como hay que apoyarse en algún lenguaje en particular 00:03:27
para ir desarrollándolo, se ha elegido Java, que aparte de que es un lenguaje 00:03:31
con mucha presencia en el entorno productivo 00:03:35
se entiende que es un lenguaje bastante didáctico 00:03:39
es una buena herramienta para entender los conceptos de programación orientada a objetos 00:03:42
Una vez que coges las bases de esta 00:03:47
metodología de programación y empiezas a coger 00:03:51
un poco el rollo a lo que es la algoritmia, trasladarte a otros lenguajes 00:03:55
es bastante sencillo, porque lo difícil de verdad a la hora de programar 00:03:58
es caer en la cuenta de cómo desarrollar los programas, 00:04:03
la mayor parte de los programas siguen esquemas muy parecidos 00:04:06
y es verdad que tiene una sintaxis un poquito distinta a la que hay que acoplarse 00:04:10
cada vez, pero es mucho más sencillo acoplarte a la sintaxis que aprender la algoritmia. 00:04:15
Esto va a servir de entrenamiento 00:04:20
importante para el lenguaje 00:04:22
que vayáis a utilizar luego en un futuro donde 00:04:26
os toque ir. 00:04:28
Las ventanas, bueno, siguen una filosofía 00:04:31
una pizca, ya os digo, vamos a hacer 00:04:35
interfaz gráfico para aplicaciones 00:04:37
de escritorio, es decir, sin descarga vía navegador ni nada 00:04:40
y el interfaz gráfico, bueno, pues 00:04:44
tiene, digamos, la programación un poco guiada por eventos 00:04:46
¿Esto qué significa? Cuando hasta ahora estamos trabajando 00:04:50
con un programa, pues típicamente empieza en el main 00:04:53
y seguimos una secuencia de instrucciones 00:04:56
digamos de arriba a abajo, si llamamos una función 00:04:59
a un método, ejecuta lo de ese método y luego vuelve 00:05:02
pero tiene una secuencia muy directa. 00:05:05
El año que viene trabajaréis con 00:05:09
multi-hilo, aplicaciones multi-hilo que permitirán 00:05:11
la ejecución de la misma aplicación 00:05:14
en diferentes hilos, diferentes líneas de ejecución 00:05:18
de la misma aplicación, pero también 00:05:21
se tendrá una idea como muy lineal 00:05:24
a la hora de ejecutarse. ¿Qué sucede con 00:05:27
la programación esta que se basa 00:05:30
un poco en eventos? Pues que cuando pasan cosas 00:05:33
se ejecutan trocitos de código. Eclipse 00:05:36
mismo, pues en realidad nosotros tenemos aquí 00:05:39
Eclipse y tendrá 00:05:42
en ejecución el código que corresponda. 00:05:44
pues en este momento estará ahí a la espera de que hagamos cosas. 00:05:47
Y es hacer cosas, es que bien con el ratón pinchemos sobre alguna de sus secciones 00:05:51
o bien con el teclado nos pongamos a escribir cosas. 00:05:56
¿Sigue una secuencia totalmente lineal, única y exclusivamente esta aplicación? 00:06:00
Pues no, porque si de repente yo pulso sobre la opción de menú run, 00:06:06
pues me salta este menú emergente por aquí para ofrecernos hacer cosas. 00:06:10
Es decir, se ha ejecutado un trocito de código en respuesta al evento producido con un clic del ratón sobre la opción run. De la misma forma, en cualquiera de las opciones o si estamos creando un proyecto, pues sobre esta ventana ahora habrá un evento que detectará que pulso unas teclas en el teclado, que pulso unas letras aquí, el nombre del proyecto que estoy creando. 00:06:16
Y, claro, cuando estoy haciendo esto, para que me lo escriba aquí y para que ahora al pulsar Finish pase algo, interfaz gráfico no me deja por aquí, no sé por qué ahora mismo no me deja, a ver, lo doy de nuevo. 00:06:40
Bueno, pues evidentemente se produce un evento a la hora de escribir que me generará, que ejecutará una parte de código. 00:07:07
pues bueno, vamos a ver cómo conseguimos hacer esto. 00:07:15
Vamos a crear el proyecto de nuevo, no sé a qué había dado antes. 00:07:19
Interfaz gráfico, Finish, Crear proyecto. 00:07:24
En la programación orientada en Java, todo, todo, todo, todo son clases. 00:07:32
Incluso cuando dibujemos ahora una ventana o pongamos un botón o cualquier componente, 00:07:37
siempre es una clase. Todo, todo son clases. 00:07:43
en el aula virtual nos habla de que 00:07:45
Eclipse o NetBeans nos da la opción de pintar ventanas a través de un 00:07:50
interfaz gráfico. Esto por detrás lo que hace es de forma automática generarnos 00:07:54
clases de código porque al final todo se tiene 00:07:58
que ejecutar a través de clases. Aquí lo que os voy a enseñar yo 00:08:02
va a ser, ignorando un poco esta herramienta que nos ofrecen 00:08:06
los interfaces gráficos, vamos a crear las aplicaciones 00:08:10
con ventanitas directamente a través de código. 00:08:14
Para facilitarnos el trabajo, como sucede con otras cosas, 00:08:19
en las colecciones, acordaros que teníamos clases que eran los conjuntos, 00:08:23
que eran las listas, unas implementadas, unas cosas que estaban repetidas 00:08:28
y no estaban repetidas, y nos apoyábamos en librerías, 00:08:32
clases que teníamos en librerías de Java, pues para este cometido 00:08:36
también tenemos clases disponibles que podemos incorporar a nuestros proyectos, 00:08:39
que nos facilitan tremendamente la posibilidad de crear este tipo de aplicaciones. 00:08:43
¿Qué dos clases son las que se utilizan tradicionalmente? 00:08:48
Pues la AWT, que ciertamente cayó ya en desuso un poco hace tiempo, 00:08:53
aunque mantiene estructuras en las que se apoya la siguiente librería, 00:08:59
y sobre todo la SWIM, para hacer estas aplicaciones de escritorio. 00:09:03
¿Qué aproximaciones hacemos utilizando estas librerías para hacer nuestros ejercicios? 00:09:08
Lo primero que hacemos es hacer el dibujo de la ventana de escritorio sobre la que trabajamos y luego a continuación darle funcionalidad a cada uno de los eventos que se pueden producir al ir trabajando con ello. 00:09:13
Vamos a ponernos manos a la obra y lo vamos contando según lo vamos haciendo. 00:09:29
Vamos a crear una primera clase, como os digo, aquí, que la vamos a llamar, por ejemplo, BenPrint. 00:09:32
como de ventana principal. 00:09:42
Nuestro proyecto Java, pues nos aparece aquí 00:09:47
la clase BenPrim. Para utilizar, 00:09:49
para que los objetos de la clase BenPrim tengan, 00:09:54
vamos a crear, de hecho, también una, 00:09:58
no sé si crear directamente también una clase, 00:10:04
vamos a crear una clase para que nos llame a las ventanas. En lugar de poner el main aquí, 00:10:08
vamos a crear una clase que sea gráfico 00:10:12
o interfaz gráfico, int graph 00:10:16
y en esta, que es para arrancar el programa, vamos a poner el método main 00:10:19
public void, public static 00:10:26
void main, mirad aquí, en esta clase 00:10:30
vamos a meter el main y en esta otra ya va a ser una ventana, para que tenga 00:10:43
el comportamiento, aquí, como cualquier otra clase con la que trabajamos habitualmente 00:10:47
Podremos definir nuestros métodos y nuestros atributos, pero para que tenga características de clase, vamos a decir que herede Stents de Frame, de la clase JFrame, para que sea de Swim, de la librería Swim. 00:10:51
tenemos las librerías, la librería AWT normalmente tiene componentes o elementos que aparecen pintados 00:11:11
que no incluyen esta J, pues frame, si veis un objeto de la clase frame, normalmente va a venir de objetos 00:11:21
de la clase AWT. Cuando se hizo la librería swing, pues prácticamente mantiene los mismos componentes 00:11:30
que tenía w me parece que menos uno cuenta por ahí en la teoría pero para identificar que es de esa 00:11:40
librería lo que hacen es poner en la jota entonces cuando aparece una jota en algo típicamente va a 00:11:46
ser de la librería swing vamos a importarlo le ofrecemos y fijaros como dice importa jota frame 00:11:50
desde java swing efectiva entonces esto ya va a tener la posibilidad de va a tener por herencia 00:11:59
vent print una serie de métodos y propiedades que están definidos en jota frame y que son los que 00:12:07
nos permiten hacer dibujos de ventanitas propias en ahora continuamos por aquí 00:12:12
normalmente digamos que en lo que se respecta a ventanas tenemos dos bloques de tipos de ventanas 00:12:23
en java en estas librerías disponibles las que vienen de jota frame que son ventanas que vamos 00:12:30
a ir dibujando nosotros con botones con radio buttons con diferentes elementos de los que 00:12:36
típicamente nos aparecen por aquí en las aplicaciones de escritorio 00:12:43
y luego están los j 00:12:47
option pane 00:12:49
que, bueno, pues 00:12:52
completando este tipo de objetos de clase 00:12:55
son las típicas ventanas que nos 00:12:58
aparecen porque nos muestran un mensajito de estas ventanas 00:13:01
emergentes o cuando nos ofrecen 00:13:04
dig si no o cancelar 00:13:07
o cancelar o cosas de estas suelen ser este otro tipo, este otro 00:13:09
grupo, digamos, de ventanas. Durante la clase sacamos 00:13:14
alguna de estas también. Ahora lo que estamos diciendo es que 00:13:18
VentPrint es un JFrame, con lo cual va a ser una ventana que vamos a dibujar 00:13:21
nosotros. Mirad, la ventana, o sea, 00:13:25
esta clase ahora va a tener una serie de propiedades y métodos 00:13:32
heredador de JFrame, más los que pongamos nosotros aquí. 00:13:36
pues podemos hacer, por ejemplo, un constructor aquí, 00:13:39
vent, print, constructor de esta clase, y bueno, vamos a llamar 00:13:44
a otro método que sea iniciarVentana. 00:13:53
Podríamos directamente lo que ponemos aquí en iniciarVentana ponerlo aquí en el constructor, 00:13:56
pero bueno, el ejemplo que tengo más o menos que estuve 00:14:01
organizando para enseñaros lo hacía con esta distribución, vamos a mantenerla. 00:14:05
Y aquí vamos a definir el método, public void 00:14:10
init ventana. Entonces si empezamos a 00:14:13
trabajar sobre esto como una ventana, si ponemos el 00:14:23
dis, aquí podríamos poner los métodos directamente, pero no me ayuda el IDE, 00:14:27
pero si ponemos el dis, me ayuda a la hora de ir mostrándolos. 00:14:32
Luego si queréis quitamos el is, para que me salga esta ayuda aquí en el IDE, 00:14:35
estoy poniendo este dis, que es yo mismo, pero si lo quitamos, pues nos 00:14:39
valdría de igual forma. Pues mirad, alguno de los métodos que tiene típicamente 00:14:43
pues el setSize. El setSize nos permite definir con un ancho y un alto 00:14:47
las dimensiones que va a tener esta ventana. Vamos a definir, por ejemplo, 00:14:52
una ventana de un tamaño de 300 y 300. Método que aplica con this 00:14:56
a los objetos que definamos de esta clase, que está disponible gracias 00:15:08
a la herencia del DJFrame. Y está aplicando, bueno, pues como nos sugiere 00:15:13
el nombre del método está aplicando un tamaño y la sed se titel para poner un título el título 00:15:18
por lo que nos aparece aquí igual que en estos de clic se pone aquí en este de él en este poner 00:15:27
debian 12 6 particular de virtual voz o esta de crisis que pone crisis workspace interfaz gráfico 00:15:32
pues aquí ponemos el título que queremos que tenga esa ventana luego cuando la mostremos vamos a 00:15:39
poner aquí por ejemplo ventana 1 o sea numerarlas porque en el ejercicio según vayamos desarrollando 00:15:45
pues os enseño alguna alguna ventana más se locación esto lo que el se locación lo que 00:15:53
nos indica es la posición dentro de toda la ventana donde en el momento de mostrarse por 00:16:02
primera vez va a aparecer la vez va a aparecer nuestra dentro de la pantalla va a aparecer 00:16:07
nuestra ventana. Entonces, a ver, set location y le podemos decir, por ejemplo, que aparezca en la 00:16:13
posición 100, 100. Bueno, cualquiera. Otra de las características que tiene es set resizable, es decir, 00:16:22
si nos permite, cogiéndola del borde, que se haga más grande o más pequeña. Entonces aquí le vamos a poner, 00:16:32
por ejemplo, false. Cada una de todas estas opciones podríamos poner 00:16:38
algunos otros datos. Si ponemos aquí this, fijaros que 00:16:42
tiene un montón de opciones por aquí. 00:16:46
Algunas más vamos a ir viendo, que en cada 00:16:50
caso podríais ir utilizando unas u otras. De momento no vamos 00:16:54
a dar por satisfechos con esto. Fijaros, frame 00:16:58
está este objeto, en realidad lo que nos está marcando 00:17:02
cómo se construyen las ventanas en Java. 00:17:06
Pues tienen un frame, que vendría a ser un borde, 00:17:11
el frame es el borde, 00:17:13
y dentro de ese borde lo que hacemos es 00:17:15
adjuntarle paneles, un panel. 00:17:18
Digamos que sería como si estuviéramos dibujando un cuadro, 00:17:21
el marco del cuadro, 00:17:24
y el panel sería el lienzo 00:17:25
sobre el que nos pondríamos a pintar nuestro cuadro. 00:17:27
Pues el panel es aquel elemento 00:17:31
sobre el que vamos a ir poniendo los diferentes controles, botones, radio buttons, lo que corresponda. 00:17:34
Todo frame normalmente trae por defecto un panel, aunque aquí vamos a crear un objeto de la clase JPanel 00:17:42
para asociárselo a este frame, que va a sustituir el que trae por defecto en realidad, 00:17:50
o sea que ya dispondría de uno, pero vamos a crear un panel para hacerlo. 00:17:55
Entonces utilizamos el objeto de la clase JPanel, 00:18:01
lo llamamos por ejemplo miPanel, igual a new, JPanel. 00:18:06
Este panel es el que vamos a, digamos, 00:18:14
enganchar al marco que va a tener nuestra ventana, 00:18:18
que viene el marco definido por el JFrame. 00:18:22
Importamos el JPanel también para que me compile 00:18:29
y ya tenemos aquí un panel. A la hora de asociar este nuevo panel a la ventana, lo que vamos a hacer es utilizar el método this.setContentPanel 00:18:32
y le decimos que queremos que al marco de esta ventana, de la ventana principal, se le asocie este panel. 00:18:48
Fijaros, podríamos definir aquí diferentes paneles y durante la ejecución del programa ir poniendo diferentes lienzos, como si tuviéramos un marco de un cuadro en el cual ponemos un lienzo que hemos pintado con una bodega y tenemos otro lienzo por ahí que hemos pintado con una escena en el campo, 00:18:58
dando un paseo a un par de personas, pues al marco, al JFrame 00:19:19
le podríamos ir poniendo diferentes paneles, con lo cual 00:19:24
es el mismo objeto de esta ventana con diferentes paneles, si los tuviéramos 00:19:28
iría mostrando diferentes contenidos en cada momento 00:19:32
en particular ahora de momento vamos a trabajar con un panel solo, este 00:19:35
que acabamos de definir aquí, dejo por aquí hueco porque nos va a interesar 00:19:40
ir haciendo cosas por aquí entre medias, después de asociar 00:19:44
el panel este, una de las cosas que podríamos hacer es 00:19:50
indicar que queremos que esté visible 00:19:54
podemos tener una ventana creada, fijaros, un objeto 00:19:58
creado, cuando hagamos un new de un objeto de esta ventana 00:20:02
en memoria RAM tendremos la ventana, pero podrá estar 00:20:05
a la vista en la pantalla o podrá estar oculta. Entonces eso lo podemos 00:20:10
manejar con el método set visible del 00:20:16
JFrame, se ve visible, vamos a ponerle aquí true, queremos que se vea 00:20:19
y de momento vamos a hacer una primera ejecución con esto 00:20:23
esta ventana, cuando hagamos el new, llamará al constructor 00:20:29
hará una inicialización de la ventana, dará un tamaño 00:20:35
un título, dirá posiciona en la pantalla en un determinado sitio 00:20:39
no permitas que se pueda modificar su tamaño 00:20:43
al marco de esta ventana, aplícale 00:20:48
este lienzo este panel que hemos definido por aquí y a lo que esté visible desde aquí que 00:20:51
tenemos el main lo que vamos a hacer es como hemos hecho siempre durante el curso vamos a 00:20:58
crear un objeto que vamos a llamar mi ventana 1 por ejemplo de la clase ven print que tendrá 00:21:06
las características de todo lo definido aquí más todo el heredador de jota frame cuando hagamos 00:21:13
ahora el new, se hará su reserva en memoria y llamaremos a la ejecución del constructor y el 00:21:19
constructor llama este método init ventana y este init ventana hace esto, da estos valores y 00:21:30
finalmente la pone visible. Entonces si cogemos y damos aquí una ejecución al programa, pues fijaros 00:21:36
cómo me ha salido la ventanita, la veis aquí, en esta ventanita tenemos que tiene un tamaño de 300 00:21:45
por 300, bueno, pues nos creemos que es 300 por 300, es cuadradita, eso sí que es 00:21:53
cierto. Inicialmente me ha salido como por aquí, que es el 100-100 este 00:21:58
con un título ventana 1 y fijaros 00:22:02
que aunque me venga aquí con el ratón, no me da la opción de redimensionarla 00:22:06
y por aquí, por aquí tampoco, también lo tiene 00:22:10
deshabilitado, veis, en el que se haga mayor o menor y con el 00:22:13
ser visible true, pues se ha mostrado. Al marco 00:22:18
del frame aplicado un panel el lienzo que ha sido mi panel que en principio lógicamente se genera 00:22:22
sin ningún contenido con lo cual tenemos una ventanita que por aquí está en blanco para la 00:22:29
aplicación para seguir metiendo cosas si tenéis dudas me va a ir diciendo como siempre vamos a 00:22:37
vamos a añadir alguna cosita aquí a la ventana entonces lo que haremos será fijaros vamos a 00:22:43
construir como os digo en java todo todo todo son clases y dentro de los componentes que habréis 00:22:52
podido ver en el tema pues hay botones hay bueno pues hay un montón de ello vamos a trabajar hoy 00:22:58
con tres o cuatro para ver la filosofía y luego cada uno tendrá alguna característica un poquito 00:23:04
particular que con más clases lo desarrollaremos más y si os veis en la necesidad como no vamos a 00:23:09
tener más clases pues os tocará investigarlas pero un poco vamos a sentar cómo funcionan en 00:23:15
general todos los componentes y las pautas que hay que ir dando para ponerlo en marcha. Uno de los 00:23:20
componentes más típicos son los botones. Entonces vamos a poner JButton. Vamos a crear un botón. 00:23:26
Botón, por ejemplo, vamos a llamarlo botón saludar. Vamos a poner aquí. Vamos a crear como 00:23:34
atributo de clase un botón. Fijaros que como es J será de la librería Swim y vamos a importarlo. 00:23:44
Aquí vamos a poner un comentario botones. Insisto, fijaros cómo estamos definiendo una referencia, no hemos hecho el new, lo podríamos hacer aquí o lo podemos hacer abajo en el código para un objeto de la clase JButton que pertenece, como veis aquí, JButton a la librería Swing. 00:23:55
pues vamos a ver que tenemos que hacer para que este botón termina apareciendo en el JFrame 00:24:16
vamos a poner aquí botones, entonces lo primero que vamos a hacer va a ser 00:24:25
hacer el new, vamos a hacer un new para esta referencia, esto lo podríamos haber hecho también aquí 00:24:29
lo podemos poner aquí y los botones permiten varios constructores 00:24:40
uno que está vacío y luego permite también poner constructores 00:24:46
un constructor sobrecargado con un string, donde pongamos aquí 00:24:51
un texto del string y es el contenido que va a aparecer luego en el botón. 00:24:55
Entonces damos de aquí de alta el botón. 00:25:00
Bien, otra cosa, contaros otra cosa, cuando 00:25:10
vamos a dibujar una ventana, 00:25:13
una nueva ventana, como la que estamos haciendo ahora, 00:25:18
existe la posibilidad de que tenga diferentes layout. 00:25:21
esto qué significa que según vayamos añadiendo componentes botones por ejemplo diferentes 00:25:24
elementos en la ventana por defecto se vayan colocando de una determinada manera entonces 00:25:31
hay unos cuantos layout yo de verdad que no conozco muchos hay uno que permite situar las 00:25:36
cosas según posiciones en la ventana entonces te define un espacio norte un espacio es este 00:25:42
un espacio este un espacio sur y un espacio central y los componentes que pones en cada 00:25:49
unos espacios se van poniendo en esa zona. Si tú dices, quiero que me crees un botón 00:25:54
y ponlo en la zona sur, pues coge y ese botón cuando lo añades 00:25:58
te lo pone por aquí abajito. Dices, pónmelo en la zona norte y te lo pone aquí. 00:26:01
Pónmelo en la zona centro y te lo pone aquí. Hay otros layouts 00:26:06
que lo que hacen es ir poniéndote de forma secuencial de izquierda 00:26:09
a derecha como si estuviéramos escribiendo en un cuaderno y dices, el primer botón 00:26:14
te lo pone justo a la izquierda aquí y el siguiente te lo pone a continuación 00:26:18
como si estuviéramos, ya os digo, escribiendo aquí. 00:26:21
Si pones otro botón. Y si ahora pones un combo 00:26:24
vos, te lo pondría aquí. Y si ahora 00:26:25
pones otra cosa, aquí. 00:26:27
Y cuando se completa esto, te salte y te empieza a poner 00:26:29
como en otra línea, componentes 00:26:31
por aquí. 00:26:33
Según el diseño de cada una de las ventanas, te puede 00:26:35
interesar uno u otro porque te resulte más 00:26:37
cómodo. 00:26:39
Yo casi tengo la costumbre de decir, 00:26:41
mira, quiero total libertad para 00:26:43
colocar los componentes. Luego, si nos da tiempo, 00:26:45
utilizamos un ejemplo, por ejemplo, 00:26:47
del layout este que ofrece 00:26:49
la posibilidad de norte, sureste, oeste y centro, pero este primer ejemplo, estos primeros ejemplos, 00:26:51
por lo menos lo voy a hacer con total libertad. Entonces, para eso, lo que hacemos en la ventana 00:26:56
es decirle, no recuerdo si es en la ventana o es en el panel, quizás sea en el panel, creo que es 00:27:02
en el panel, entonces vamos a decir que el panel tenga un set layout, aquí definimos el tipo de 00:27:12
layout y según lo que pongamos aquí, creo que en la teoría os habla de diferentes layouts, se comportaría 00:27:18
de una forma norte, sureste, oeste, uno secuencial uno detrás de otro, pero si le ponemos la opción 00:27:25
null, es decir, ninguno, lo que estamos diciendo es no consideres por defecto ningún layout que voy a ir 00:27:31
colocando yo las cosas a mano. Vamos a hacer este ejercicio así, totalmente con el control total de 00:27:36
dónde ir situando los diferentes controles, en este caso por ejemplo un botón dentro del panel 00:27:42
que a su vez el panel está metido en el marco 00:27:48
con lo cual será como van a aparecer distribuidos los 00:27:51
componentes en nuestra ventana. Y para hacerlo con toda libertad 00:27:54
lo hacemos de esta forma. Si lo hacemos de esta forma, ahora este botón 00:28:00
podría ir en cualquier sitio. ¿Y ese cualquier sitio cómo lo 00:28:04
definimos? Pues lo que decimos es que el objeto de botón 00:28:08
saludar y le decimos set bones 00:28:12
Y este nos permite poner un objeto de la clase rectángulo, fijaros, o está sobrecargado y nos permite decir en qué posición X e Y está el punto, en este caso el botón, de arriba a la izquierda, qué ancho tiene y qué alto tiene, con cuatro parámetros. 00:28:15
parámetros. Entonces, por ejemplo, para este botón vamos a decirle que esté 00:28:35
en X en la posición 10, en Y 00:28:41
en la posición 20, que tenga un ancho de 100, 00:28:45
esto ya dependería del diseño que tengáis en vuestra 00:28:50
ventana, y de 20. Decimos, este botón, cuando se coloque, 00:28:53
que se coloque en estas posiciones. Si el layout del panel 00:28:57
es uno de los otros, seguramente ignore el 00:29:01
setBounce este. Pero si es nulo, es decir, no está obligando 00:29:05
mi panel a una distribución de los componentes en particular, sino que le he dicho 00:29:09
nulo porque quiero tener yo el control, este botón, ¿en qué posición se va a colocar en el 00:29:13
layout? En el panel, en estas. Considerando 00:29:17
este como punto de arriba a la izquierda, en el 00:29:22
botón, el ancho y el alto. Y luego lo que hacemos es 00:29:25
hemos definido un panel, este panel se lo 00:29:33
añadido al frame hemos definido un botón y antes os decía podríamos tener diferentes paneles y 00:29:40
luego ir aplicando diferentes paneles al mismo frame al mismo a la misma ventana entonces este 00:29:47
botón si tuviéramos diferentes paneles en cuál de todos los paneles aparecería si tuviéramos 00:29:53
distintos aquí parece que estamos tenemos tendencia que vaya a estar en este no porque 00:29:58
es el nuevo que hemos definido pero en cuál de todos ellos si tuviéramos varios que posteriormente 00:30:03
iríamos poniendo unos otros en el jota frame pues para indicar en qué panel va lo que hacemos es 00:30:08
indicarlo de esta forma decimos mi panel que es el panel este punto adb añádeme fijaros que aquí 00:30:14
me dice añádeme un componente un componente que va a ser en este caso quien el botón saludar entonces 00:30:23
este botón que hemos definido aquí una referencia del cual hemos hecho aquí un new que tenga el 00:30:31
texto saludar digo cómo se va a posicionar en un layout el cual hemos indicado en un panel que 00:30:37
hemos indicado que su layout sea nul y ahora decimos que lo añada. Fijaros cómo ahora si cojo y ejecuto 00:30:44
la aplicación, me aparece ya el botoncito este, ahí tenemos el botón, botón con texto saludar en la 00:30:50
posición 10x20i con un ancho de 100 y un alto de 20 y hemos añadido este botón a este panel y este 00:31:02
panel a este frame con lo cual dentro del frame que contiene el panel que será esto que está aquí 00:31:12
en gris aparece el botón saludar todo lo que estamos haciendo hasta ahora es estético si 00:31:16
nosotros pulsamos el botón que sucede no sucede nada veis bueno sucede que da la sensación de 00:31:25
estarse pulsando pero en realidad no tiene ninguna consecuencia sobre sobre nada pues una vez que 00:31:31
hemos trabajado sobre la parte diseño gráfico de un componente de los diferentes componentes que 00:31:38
iremos poniendo por aquí en particular hemos empezado con un botón ahora vamos a hacer que 00:31:46
esto tenga sentido y como os decía la jugada se divide entre dibujo y comportamiento cómo hacer 00:31:50
las cosas. Para definir 00:31:57
y nuevamente continuamos con 00:32:00
el trabajo siempre en clases, porque en Java 00:32:03
todos son clases. Entonces, lo que decimos aquí 00:32:06
ahora para el botón este, decimos el botón saludar, decimos 00:32:09
add, action listener 00:32:12
hay muchas alternativas para hacer cosas 00:32:15
pero esta es la típica en un botón 00:32:20
aquí lo que estamos diciendo es, mira 00:32:22
para este objeto, que es un botón 00:32:26
vamos a activar un escuchador 00:32:29
para cuando suceda un evento, es decir 00:32:32
lo que decía antes de Eclipse, cuando suceda y con el ratón 00:32:35
yo le doy aquí a run, pues sucede un evento 00:32:38
pues ponte que la aplicación esté dándose cuenta 00:32:41
si con el ratón pulso este run, como opción de menú 00:32:44
en particular estamos añadiendo, poniéndolo a la escucha 00:32:47
para que cuando se produzca 00:32:50
tenga un escuchador, una orejita ahí puesta 00:32:54
para cuando se produzca una acción. ¿Sobre quién? Sobre este elemento. 00:32:56
Y aquí nos dice, aparece un nulo ahora por defecto. 00:33:00
Aquí lo que vamos a indicar va a ser la clase donde vamos a poner el código 00:33:05
que se tiene que ejecutar cuando se produzca una acción sobre este botón. 00:33:10
Entonces aquí podríamos, a ver qué tiempo nos va permitiendo hacer cosas. 00:33:18
Luego podemos crear una clase diferente. Otra opción que tenemos es decir que el código para atender este botón sea esta misma clase. Si ponemos aquí this, esto lo que quiere decir es que esta misma clase, BenPrint, tendrá el código para atender aquellas acciones que hay que ejecutar cuando se produzca una acción sobre el botón pulsar. 00:33:26
Bueno, aquí se me queja, ¿verdad? Dice que he metido esto. ¿Qué es lo que sucede? Que esta clase no está preparada para hacer esto. 00:33:48
Entonces, lo que tenemos que hacer aquí es implementar, ponemos un implement, un interfaz, que es el interfaz ActionListener. Fijaros, he dicho, añade ActionListener al botón saludar y esperamos que la clase que lo atienda sea esta misma. 00:34:04
y ahora lo que decimos es que esta clase 00:34:32
que precisa implementar los métodos de ActionListener 00:34:35
porque hemos dicho aquí this, le ponemos aquí implements 00:34:40
ponerlo por aquí, me dice 00:34:43
que importe el JavaEventActionListener 00:34:45
y ahora como hemos implementado, hemos puesto aquí un interfaz 00:34:51
me deja de compilar porque no tengo los métodos necesarios 00:34:55
a los que me obliga esta interfaz 00:34:58
escojo y digo ahora añádeme los métodos no implementados 00:35:00
y fijaros que me ha añadido este método, el ActionPerformance 00:35:06
ActionPerformance es el método al que me obliga el ActionList 00:35:10
tener este. ¿Qué sucede? Con esto que habíamos 00:35:14
puesto antes, habíamos conseguido, voy a bajar esto abajo 00:35:20
pintar el botón y ahora estamos 00:35:24
buscando la técnica que Java nos permite para que cuando 00:35:27
pase algo sobre el botón, porque hemos dicho, oye, pon una orejita 00:35:31
con el listener para cuando pase algo en este botón y que el código 00:35:35
que lo considere esté en esta clase, 00:35:40
como es ActionListener que estamos añadiendo, metemos el interfaz 00:35:44
e incluir esta interfaz me obliga a tener 00:35:48
este método. Entonces fijaros, si ponemos aquí un 00:35:51
system.out.println pulsando 00:35:55
un botón y ahora ejecutamos 00:36:03
System.out, escritura por consola, nos escribirá aquí 00:36:07
y ahora ejecutamos. Mirad como al pulsar el botón 00:36:11
nada más arrancar, hemos puesto 00:36:17
una acción listener, pues estará algo dentro del programa, la escucha 00:36:21
a ver si pasa algo en este botón. Cuando hagamos un clic 00:36:25
con el ratón en el botón, es de esperar que se ejecute 00:36:29
ese método, entonces damos aquí, veis como me saca aquí pulsando botón 00:36:34
el dibujo gráfico del botón ya lo hemos 00:36:37
asociado con una zona de código donde podremos poner 00:36:40
lo que tenga que pasar cuando pulsemos este botón 00:36:42
en un programa será escribir en un fichero, en otro será 00:36:45
lo que vaya tocando, vamos a poner un segundo botón 00:36:49
lo hago así un poquito rápido porque esto ya es 00:37:01
un poco complicado, hacemos botón saludar 2 00:37:06
entonces aquí en la zona de botones 00:37:09
voy a copiar todo esto 00:37:11
digo botón saludar, le cambio aquí el texto, 2 00:37:14
este otro botón pues lo vamos a colocar un poco desplazado 00:37:21
entonces por ejemplo cambiamos la X, decimos que se posicione 00:37:25
en X150 con la misma Y 00:37:29
estará a la misma altura, mismo ancho y mismo alto 00:37:33
decimos sal 2, aquí decimos que estamos trabajando sobre el botón 2 00:37:35
este botón ahora mismo no está asociado a ningún panel 00:37:41
no aparecería en ningún sitio, pero le decimos mi panel add2 00:37:44
y también queremos que tenga 00:37:48
que se ponga a la escucha de cuando pase algo en este botón, con lo cual 00:37:50
le decimos botón2, addActionListener y la clase donde 00:37:56
se va a gestionar, donde va a estar el código, donde se va 00:38:00
a gestionar el clic sobre este botón 00:38:04
si le damos aquí y volvemos a ejecutar 00:38:08
fijaros ahora nos aparecen ya dos botones 00:38:12
si damos saludar 00:38:16
nos dice pulsando botón, si damos 00:38:17
sal 2, también nos sale 00:38:19
¿qué le hemos dicho al programa? 00:38:21
le hemos dicho que en ambos casos 00:38:28
pongo un ActionListener y este ActionListener 00:38:29
se ha asociado con el ActionPerformat 00:38:32
y en este hemos dicho que 00:38:34
muestre por pantalla pulsando 00:38:36
botón, con lo cual los dos nos muestran 00:38:38
pulsando botón 00:38:40
en consola 00:38:42
Pero claro, en una aplicación normal nos interesaría que pulsar un botón hiciera unas cosas y pulsar otro botón hiciese otras. Ambos dos están ejecutando este método, con lo cual no sé distinguir si este pulsando botón que me ha escrito es porque he dado clic al botón saludar o al botón saldos. 00:38:46
¿Cómo podemos gestionar esto? Pues mirad, aquí podríamos coger, fijaros cómo este método aquí coge, recibe un objeto y este objeto nos da información, contiene información del momento en el que se lanza el evento, en el momento en el que en este caso pulsamos los botones. 00:39:07
entonces aquí lo que podríamos hacer es 00:39:29
si ponemos if 00:39:33
fijaros que estamos programando en java 00:39:34
como hemos hecho durante todo el curso 00:39:38
en sus métodos considerando conceptos como interfaces 00:39:41
que hemos añadido métodos 00:39:45
la clase la hemos definido como una clase 00:39:47
la hemos seleccionado de jframe para que tenga 00:39:49
todas las funciones de comportamiento como una ventana 00:39:53
de escritorio 00:39:57
entonces ponemos aquí if e get source, aquí me indica la fuente de quien ha ejecutado este evento, si decimos que este es igual, si ha sido el botón, botón saludar, de esta forma me permite diferenciar entre un botón y otro, aquí ponemos un else if por ejemplo, si en lugar de botón saludar ha sido el botón saludar 2, 00:39:59
Y ahora aquí ya podríamos poner código que nos diese respuesta a pulsar uno de los botones, escribir un fichero en no sé qué, abrir otra ventana, lo que correspondiese, simplemente para ver su funcionamiento. 00:40:26
Vamos a poner un system out, botón saldos aquí y aquí botón saludar. Fijaros ahora si pulso el botón saludar, efectivamente dice pulsando saludar, se ha dado cuenta con el guest source que es este botón, aunque los dos hacen que se ejecute el mismo método, con ese if ya se ejecuta el código asociado al pulsado de este botón. 00:40:42
Si pulsamos Sal 2, el mensaje que nos muestra aquí abajo ya es pulsando Sal 2. Aunque en ambos casos utilizamos el mismo Listener, que es el ActionListener, podemos diferenciar si el método se ha ejecutado desde una fuente o desde otra. 00:41:14
diferente con el getSource. Aquí tenemos con nuestro diseño, nuestro programa, 00:41:32
necesitaríamos uno, dos, tres, veinte botones, pues podríamos colocar 00:41:41
tanto como fueran necesarios de esta forma, cada uno de ellos con un objeto 00:41:47
de una clase JButton. En este caso todos ellos lo podríamos asociar a este 00:41:51
listener, hay más listeners, ahora veremos alguno más. Este listener al implementar 00:41:56
interfaz nos obliga a añadir este método solamente uno en la acción performance 00:42:02
que es el que se ejecuta cuando pasan cosas sobre una acción listener y con el 00:42:07
guest source podemos diferenciar entre unos y otros otro componente típico que 00:42:12
aparece en prácticamente todas las ventanas son este menú principal pues 00:42:22
este menú principal se también lo vamos a crear a partir de objetos de 00:42:28
objetos de clases que tenemos en la librería suene vamos a poner aquí menú y vamos a ponernos a la 00:42:35
marcha con él mira pues vamos a definir los menús se estructuran en jota menú bar un objeto de este 00:42:44
de este tipo que vendría a ser el elemento que nos permite tener un menú aquí arriba y ahora 00:42:53
vamos a añadiendo elementos a este menor por ejemplo llamamos barra menos vamos a importarlo 00:43:00
de Swing, como empieza por J 00:43:08
ya teníamos la sospecha de que iba a ser de la librería 00:43:12
Swing, al menú 00:43:14
digamos que eso es la barra 00:43:19
cada uno de los elementos 00:43:23
principales que tiene aquí, File, Edit 00:43:24
Source, cada uno de estos serían 00:43:27
objetos de la clase JMenu 00:43:28
entonces por ejemplo 00:43:31
podemos definir una 00:43:33
elemento que sea 00:43:37
MenúArchivo 00:43:39
o el que aquí pone File, pues MenúArchivo 00:43:40
Hemos definido el JBar, que sería el conjunto, digamos, una estructura que nos permite definir un menú y ahora un JMenu, que sería uno de estos. File, pues lo vamos a llamar menú archivo de ese objeto. Lo importamos también. 00:43:46
Y ahora al pulsar sobre File nos aparecen diferentes opciones, aquí veis, en Edit también, pues cada una de estas opciones en Java las podemos definir como JMenuItem y por ejemplo vamos a definir el ítem Salir, todos ellos de la librería Swing que tenemos en Java. 00:44:00
vamos a poner aquí, que es lo primero que tenemos que hacer si son referencias a objetos de clase 00:44:35
podríamos haberlo hecho aquí, pero lo podemos hacer directamente aquí también 00:44:40
pues vamos a hacer el new, entonces tenemos aquí, le decimos igual a new 00:44:45
y vamos a su constructor, el jmenu, le hacemos el new 00:44:50
y por aquí el jmenu tiene la opción de constructor vacío o constructor en el cual 00:45:03
igual que en los botones podemos incluir ya el texto este 00:45:14
está sobrecargado con un string, entonces podemos poner aquí 00:45:17
archivo, y en el jMenuItem vamos a hacer la misma jugada 00:45:21
y el jMenuItem también está sobrecargado y podemos 00:45:26
recordar, los jMenuItem son los que aparecen por aquí, en una opción de menú 00:45:35
colgando, y también tienen, están sobrecargados, está sobrecargado 00:45:39
el método constructor y nos permite con un string meter el nombre 00:45:43
entonces este como lo hemos llamado itemSalir, vamos a ponerle aquí salir 00:45:47
Vale, pues para seguir construyéndolo esto, lo que decimos es que esta ventana, este frame, lo tenemos definido por ventana principal, decimos this, asocia a este frame setJMenu, una barra de menú y le identificamos qué barra de menú queremos añadirle. 00:45:51
Con lo cual esta barra de menú está asociado ya a esta ventana, pero estos objetos no están asociados por el momento a esta barra de menú, pues vamos a hacerlo. 00:46:32
lo que decimos es que el menú archivo.add, añádelo y se lo añadimos a la barra de menú. 00:46:44
Estamos diciendo que este elemento, este jMenu, se lo estamos añadiendo a esta barra 00:47:01
y esta barra se lo estamos añadiendo como menú a la ventana. 00:47:08
Entonces, archivo lo hemos añadido a la barra de menú que se lo hemos puesto a la ventana, pero el menú archivo tiene un ítem, que es los que van a colgar por aquí, que también tenemos que asociarlo. 00:47:12
Fijaros cómo vamos pasito a pasito metiéndolo. Entonces ponemos aquí menú, creo que lo he puesto mal el de arriba, ahora ADD, al menú archivo, lo he puesto mal el de arriba, ahora lo cambio, al menú archivo lo que hacemos es añadirle el ítem. 00:47:33
Y en verdad, digamos, tenemos la barra, el JMenu y el JMenuItem. A la barra tenemos que añadir el JMenu, entonces este es que a la barra menú le añado el JMenu. 00:47:58
la barra en sí se la añado 00:48:21
al frame, a la barra le añado 00:48:25
el jMenu y a la jMenu le meto el jMenuItem 00:48:29
si hacemos ahora una ejecución, vamos a ver si nos sale 00:48:33
fijaros, ha añadido la barra 00:48:40
el jMenuBar, que es todo esto, fijaros como aparece un poquito más en gris 00:48:43
y un poquito sobrepuesto, a la barra le hemos metido 00:48:48
un JMenu que es archivo y al JMenu le he movido un JMenuItem 00:48:52
que es el salir. ¿Qué sucede si ahora pulso 00:48:56
y aquí salir? No parece que esté sucediendo nada. ¿Por qué? 00:49:00
Pues porque nos está pasando exactamente lo mismo que cuando hemos puesto los botones. 00:49:04
Lo que hemos hecho hasta ahora ha sido dibujar el 00:49:08
componente dentro del frame, pero dentro del panel 00:49:12
y como consecuencia en el frame, pero sin poner ningún listeners 00:49:15
y sin decir que suceda nada en particular cuando estemos trabajando 00:49:19
con ello. Pues para eso tenemos que hacer como con los 00:49:23
botones y en particular la opción 00:49:27
ítem, es decir, la de salir es a la que le queremos añadir algo. 00:49:37
Entonces ponemos, igual que hemos hecho antes aquí, 00:49:42
las opciones de menú también utilizan el ActionListener, hay 00:49:46
más Listener, ahora por lo menos otro más veremos ahora. 00:49:49
Entonces le decimos que al JMenuItem le añade un AddActionListener y aquí, como antes, tenemos que decirle qué clase es la que va a atender ese ActionListener. Decimos que sea esta misma. 00:49:52
Entonces, ahora nos venimos aquí. Fijaros que es el mismo, es el ActionListener, es el mismo que en estos casos que hemos incorporado a través del interfaz. Cuando le hemos dicho métodos necesarios para ese interfaz, nos ha metido el ActionPerformat, con lo cual este nuevo elemento que estamos metiendo también va a lanzar la ejecución de este ActionPerformat. 00:50:07
como es una casuística diferente a pulsar el botón saludar o saludar 2 00:50:35
pues aquí lo que vamos a hacer va a ser diferenciarlo 00:50:39
también, decíamos cuando pulsemos el botón saludar, botón saludar 2 00:50:43
pues aquí cuando pulsemos 00:50:47
el ítem salir, pulsando salir, ejecutamos 00:50:49
y ahora si voy a salir, fijaros como ya me sale aquí 00:51:05
pulsando salir, hemos capturado el evento de pulsar con el ratón salir 00:51:09
se va al método 00:51:13
que está definido para atender ese evento 00:51:17
y hace lo que hemos puesto por código. En este caso es pulsando, hemos dicho 00:51:21
que haga un system of println de pulsando salir. Vamos a 00:51:25
hacer algo que sea un poco más real, que no sea pulsar salir de lo que 00:51:35
suele pasar cuando hacemos estas cosas. Podríamos poner 00:51:39
si queréis un primer mensaje, antes decía, tenemos en las librerías 00:51:43
de Java, los JFrame y otras ventanas que suelen ser informativas 00:51:47
o para capturar información, vamos a poner aquí una informativa, podemos poner 00:51:51
JOptionPane 00:51:55
una clase que está disponible en la librería de Java 00:51:58
y fijaros, tiene un montón de cosas por aquí 00:52:03
muchas alternativas, una de ellas es muestra un mensaje 00:52:06
por ejemplo, MessageDialog, muestra un dialog, vendría a ser una ventana con 00:52:13
un mensaje, me pide aquí dos parámetros, este primer parámetro sería el contenido 00:52:16
de este mensaje, quieres que se asocie a alguna ventana en particular que ya exista 00:52:26
en el proyecto, si pones null te crea una nueva y aquí podemos poner el mensaje, entonces 00:52:30
por ejemplo como mensaje podríamos poner pulsado el botón salir del menú, en lugar 00:52:36
de un System.out, vamos a hacer que nos muestre un mensajito al pulsar 00:52:48
salir. Entonces, si ejecutamos ahora, vamos aquí 00:52:52
y fijaros cómo me sale aquí una ventanita. 00:52:56
Bueno, tampoco es lo habitual que nos salga una ventana informativa 00:53:00
pulsando el botón salir del menú, sino que se salga de la aplicación o de la ventana 00:53:04
como poco. Pero bueno, así vemos por si necesitamos 00:53:08
sacar un mensajito en algún momento, pues con un Joption Paints o un 00:53:12
messageDialog, somos capaces de mostrar una ventanita. Si lo que queremos 00:53:16
es acabar la aplicación, pues tenemos al menos 00:53:22
dos alternativas. Una que es llamar al mento dispose. 00:53:26
Este método te acaba la aplicación. Yo si ahora voy a salir, 00:53:32
fijaros, como se me acaba, ha desaparecido y se me ha ido aquí el botoncito rojo. 00:53:42
Bueno, y otra alternativa también es 00:53:49
a través de un system.exit. 00:53:52
System.exit y aquí podríamos meter un valor numérico, que bueno, si esta aplicación fuese lanzada por otra, podría llegar a capturar este valor y gestionar esa aplicación que ha arrancado esta, pero bueno, es algo que veréis en otro momento. 00:53:58
Consiste en exit, podemos acabar la aplicación también, entonces le damos aquí un archivo salir, fijaros como también acaba la ventanita, se apaga aquí el rojo y se cierra la ventana. 00:54:14
Bueno, pues opción de menú, si aquí tenemos archivo, edit, source, refactor, en esta, si quisiéramos tener más elementos aquí, sobre esta barra, tendríamos que definir un mayor número de elementos de JMenus, para que no solamente fuera archivo, y cada uno de estos los tendríamos que añadir al barra menú, como hemos hecho aquí. 00:54:30
mirad como al barra menú le hemos añadido el jMenu 00:54:52
el único que tenemos en la aplicación, pues tendríamos que tener más veces el barra menú 00:54:58
add y te iría poniendo uno detrás de otro, y cada uno de estos 00:55:03
jMenu tendrían una serie de jMenuItems, en este caso 00:55:06
hemos puesto uno solo, de momento, ahora si acaso a lo mejor ponemos alguno más 00:55:11
pues en cada jMenu podría tener sus jMenuItems, como aquí 00:55:14
veis otro elemento que podemos poner pues los radio button ahí están hay mil opciones muy 00:55:19
bueno muchas no tenemos campos de texto tenemos áreas de texto tenemos radio button con bobos 00:55:35
vamos a meter un radio button cada uno tiene alguna característica un poco diferente lógicamente no 00:55:42
dar tiempo a ver todos pues los que nos dé tiempo los vemos y la idea todo el rato va siendo la 00:55:50
misma con pequeños matices de unos u otros pero la idea es la misma lo dibujamos y una vez que 00:55:56
lo hemos dibujado pues tenemos que decirle por dónde podemos actuar sobre ellos 00:56:07
imaginaos antes de meter los radio button vamos a hacer una cosa diferente para meter un listener 00:56:20
diferente imaginaos que es una ventana que cuando le demos salir queremos tener la opción de decir 00:56:27
oye mira es verdad le hemos dado salir pero quiero comprobar si efectivamente o quiero sacar una 00:56:35
ventana de confirmación preguntando si de verdad quiero salirme o no quiero salirme por ejemplo 00:56:42
si no venimos aquí le pulsamos a la equis se sale fijaros que no se ha terminado ni siquiera el 00:56:52
programa, veis que sigue aquí, es decir, ha escondido esa ventana pero el programa no ha terminado, no ha 00:56:58
ejecutado el pulsar la X un Dispose o un System Exit como hemos puesto aquí, si vamos por la opción 00:57:05
de menú, sí que hemos puesto el Dispose o el System Exit, pero en ese caso no, ha cerrado la ventana 00:57:13
pero la aplicación, veis aquí en rojito que está arrancada, pues si doy aquí a la cruz, se va la 00:57:18
ventana, es cierto, pero no acaba el programa. El programa se iría 00:57:25
por ahí en ejecución. Esa ventana ha desaparecido, no ha considerado que termine 00:57:29
el programa, para lo cual es necesaria alguna de estas instrucciones. 00:57:34
¿Somos capaces de alguna forma de tener un espacio de código 00:57:40
donde poner nosotros lo que queramos que pase cuando 00:57:44
pulsemos la X o a través de aquí, creo que también nos da la opción 00:57:48
cerrar. Pues sí que lo tenemos. Vamos a ver cómo lo podemos hacer. 00:57:52
la opción esta, en lugar de ser de un botón 00:57:56
o de una opción de menú, es una acción que tiene que ver 00:58:07
con la ventana en sí. Entonces lo que podemos poner 00:58:10
igual que aquí, al botón 00:58:14
para que tuviera comportamiento, le hemos metido una acción listener 00:58:19
al elemento, el ítem del menú o al botón 00:58:23
podemos poner this, this es el propio objeto 00:58:28
de la clase BenPrint 00:58:34
addWindows 00:58:35
fijaros aquí tenemos diferentes opciones que nos presenta 00:58:42
aquí, addWindowsFocusListener cuando saltará 00:58:48
una zona de código si añadimos 00:58:52
este listener cuando la ventana coja el foco 00:58:55
WillListener, no sé exactamente, pues el WillListener tiene pinta de ser 00:58:58
en el ratón si pulsas ahí la ruedecilla, ¿no? 00:59:05
Probablemente salte una zona de código para si pulsas sobre la ventana la ruedecilla 00:59:08
tengas control de poder hacer ciertas cosas. 00:59:12
Una un poco más general de toda la ventana es el AddWindowListener 00:59:16
que es diferente al AddActionListener sobre el botón. Entonces vamos a 00:59:21
añadir este Listener aquí a la ventana. 00:59:24
y que nos ofrece aquí la posibilidad de identificar en qué clase 00:59:28
se gestiona ese código. 00:59:32
Perdón, me ha atascado. 00:59:37
Entonces, si le decimos this, lo que estamos diciendo es 00:59:39
la clase donde queremos que se gestionen 00:59:41
los eventos que se produjan sobre la ventana 00:59:44
porque estamos añadiendo al window 00:59:47
este listener, aquí podemos decir qué objeto queremos que sea 00:59:50
y, por ejemplo, podemos decir que sea este objeto. 00:59:54
Ahora después también cambiamos para demostrar cómo poner algo diferente de este dis. 00:59:57
Como estamos diciendo que esta clase tiene que atender esto, se ha empezado a quejar. 01:00:03
¿Por qué? Porque para esta clase no tenemos el código necesario para atenderlo. 01:00:07
¿Qué vamos a hacer? Pues lo mismo que antes. 01:00:12
Vamos a hacer que implemente el interfaz WindowsListener, esta clase. 01:00:14
Venimos aquí y junto a este le ponemos aquí una coma. 01:00:21
decimos, oye, también tienes que atender 01:00:24
hacer el listener de una ventana, que por aquí lo han añadido 01:00:27
y han dicho que es esta clase la que lo atiende. Entonces, cojo 01:00:33
por aquí y digo que me incorpore, que me importe esto 01:00:40
y ahora, por aquí, le digo, añádeme los métodos 01:00:44
que no están implementados a los que me estoy obligando al firmar 01:00:48
un contrato, contrato entrecomillado, con la interfaz acción listener 01:00:51
para esta clase, entonces cojo y digo 01:00:56
méteme los métodos no implementados, y fijaros como aquí 01:01:00
me ha puesto una serie de métodos, si el ActionListener me metía 01:01:04
un método solo, esa interfaz me obligaba a considerar 01:01:08
este método, pues el WindowsListener me obliga a tener implementados todos estos 01:01:12
que fijaros es WindowsOpened, cuando se abre la ventana, cuando se está 01:01:16
cerrando, cuando se ha cerrado, bueno pues más cosas 01:01:20
Si queréis, tenemos un poquito curiosidad de lo que pasa en cada una de ellas, podemos poner aquí un system out para ver cuándo se producen, ponemos aquí pasando por y así vemos cuándo se producen esos eventos, vamos a pegarlo en todos y ahora lo cambiamos, un montón de métodos ha metido aquí esta interfaz, todos ellos relativos a window, porque todos ellos tienen que ver con el listener de window, 01:01:25
veis, por aquí, entonces 01:02:03
para ver cuando se ejecuta cada uno de ellos vamos a 01:02:06
modificar los system out 01:02:08
vamos a poner pasando por y el 01:02:10
nombre del método en el system 01:02:12
out, println, bueno pues ahí los 01:02:14
tenemos y ahora si ejecutamos por aquí 01:02:26
mirad, el arranque y el 01:02:28
mostrar la ventana ha pasado ya 01:02:31
el window listener me ha 01:02:33
ejecutado porque estaba la escucha 01:02:36
de cosas que pudieran pasar en esta ventana 01:02:38
los métodos pasando 01:02:39
por windows opened y por 01:02:42
windows activated 01:02:43
¿Qué sucede si ha pasado por estos? Que ahí podríamos nosotros poner cierto código que en nuestro diseño de la aplicación fuera necesario en el momento en el que esta ventana se está abriendo. Escribir en una base de datos, no sé qué, enviar tal o inicializar no sé qué variable, en el momento que esto pasa, pues ya sabemos que cuando arranca esta ventana, estos dos métodos, fijaros, se han ejecutado. 01:02:44
porque nos ha sacado los System of Printed Learning. 01:03:08
Mira, si yo pulso aquí, a la hora de cerrar, sobre el ASPA, se me ha cerrado, el programa nos ha cerrado. 01:03:11
Antes no parecía que tuviéramos posibilidad de hacer cosas, pero fijaros que se me han ejecutado estos dos métodos, 01:03:18
pasando por Windows Closing. 01:03:24
Bueno, pues ahí tenemos la posibilidad de meter código sobre algo que pase cuando pulsemos la cruz. 01:03:30
En cualquier caso, además de ejecutarse el Windows Closing y Windows Closed, la ventana se ha cerrado. El comportamiento que puede tener la ventana cuando pulsamos la cruz se lo podemos preestablecer también con una opción aquí. 01:03:37
Si decimos this, la ventana, punto, set default close operation, quiero que hagas por defecto cuando te cierres esto, si ponemos aquí un this nos da algunas alternativas. 01:03:59
fijaros, podemos poner dispose on close, desaparece cuando te cierres, también podemos decir un do nothing on close, no hagas nada cuando te cierres, podemos poner un hide on close, que yo creo es la que debe tener por defecto, es decir, se esconde, si es dispose, liberaría la memoria RAM de las tres que hemos visto, se cerraría la ventana, liberaría la memoria RAM asociada al objeto S que tiene que ver con la ventana, 01:04:18
un hide on close, lo que haría sería poner un set visible a false, pero la ventana 01:04:50
seguiría existiendo, y un do nothing on close, 01:04:54
pues no haría nada. Entonces, vamos a seleccionar, yo creo, no sé por 01:04:58
defecto si estará el dispose o el hide on close, 01:05:02
pero si ponemos un do nothing on close como comportamiento por defecto cuando la ventana 01:05:06
se cierre, si ahora ejecutamos, fijaros 01:05:10
que al pulsar sobre la cruz, me pasa por el 01:05:16
Windows Close It, tengo una zona de código que sí que salta el evento 01:05:19
porque he hecho esto, pero la ventana no se cierra. 01:05:25
¿Qué posibilidades tengo con esto? Pues mirad, como ya no se cierra 01:05:30
la ventana y sigue activa y me está pasando por aquí, yo aquí voy 01:05:36
a poder poner, por ejemplo, una ventanita diciendo, oye, ¿estás seguro 01:05:42
que quieres cerrar la aplicación? O imaginaros que tuviera ciertos 01:05:46
campos que estamos introduciendo datos 01:05:51
me he creado una variable 01:05:54
donde si se produce 01:05:56
algún cambio, la pongo a true 01:05:57
y ahora podría decir, si se ha producido 01:05:59
algún cambio, ¿quieres salvarlos 01:06:01
antes de cerrar la ventana? 01:06:03
si, no, cancelar, es decir, me da opciones 01:06:05
en el momento en el que se está cerrando la ventana 01:06:07
de hacer cosas, aquí 01:06:09
vamos a poner una ventanita 01:06:11
de mensaje para decirle, oye 01:06:15
¿seguro que quieres que se cierre 01:06:17
o no? 01:06:19
entonces, igual que antes hemos puesto una J 01:06:21
option pane por aquí, mostrando un mensaje, un show message dialog, pues ahora vamos a 01:06:23
mostrar un j, option pane, punto, y lo que vamos a hacer en lugar de mostrar un mensaje, 01:06:31
lo que vamos a hacer va a ser mostrar un show confirm dialog, que fijaros ahí está sobrescrito 01:06:41
con muchas alternativas. Aquí me ofrece de primeras una con dos valores. Vamos a utilizar una que permite 01:06:51
cuatro parámetros. Ahora después ponemos unos strings que tengan sentido con esto que estamos poniendo aquí. 01:07:02
Vamos a poner de momento esto para ver dónde se nos dibujan las as y las ver dentro de la ventana. 01:07:10
Y aquí podemos coger y poner J, Option, Paint. Fijaros, es la misma clase que esta, que tiene una serie de métodos, pero también tiene una serie de atributos. Y aquí podemos seleccionar esta ventanita que Opciones nos muestre. Por ejemplo, que simplemente tenga la opción de Cancelar, Default, Options. 01:07:14
Y una de ellas, por ejemplo, es la Yes, No. Esta nos da, ofrece dos botones. Dice sí o no. Quieres cerrar sí o no. Esta nos ofrece tres botones. Los botones sí, no y cancelar. Esta solamente la sí. Vamos a poner la sí, no opción. Y vamos a ejecutar. Un momento. Luego seguimos desarrollándolo más. 01:07:37
si yo pulso ahora aquí, fijaros, me sale esta ventanita que me dice BBBB, veis aquí, pues para poner un índice aquí arriba y aquí un mensajito en las as 01:08:04
y como hemos dicho que la opción que queremos es las yes no option, me ofrece la posibilidad de yes y no, pulso igual que dar dos cosas y no pasa gran cosa 01:08:17
ahora vemos cómo lo manejamos, si me vengo por aquí, como tenemos el dispose, sí que acaba la aplicación 01:08:27
entonces aquí decidiríamos seguro que quieres cerrar y aquí ponemos 01:08:34
msg cierre y esta ventana con las opciones sino la idea es que podamos capturar información de 01:08:46
si queremos cerrar o no mirad entonces este método no se va a estar devolviendo un entero 01:08:58
que vamos a mostrar aquí por pantalla, vamos a poner un system.out.println 01:09:04
lo que estoy metiendo es un system.out.println lo que nos devuelve 01:09:12
la ventanita esta, lanzará la ventana, cuando le demos así o no 01:09:22
el método devolverá un valor entero y lo estamos mostrando por pantalla 01:09:29
podremos buscar la información o podemos de esta forma ver que nos devuelve en cada caso 01:09:34
si le doy a ejecutar 01:09:39
pulso aquí 01:09:42
mirad, me ha sacado aquí los eventos 01:09:44
si pulso sí 01:09:47
me devuelve un 0, ¿veis? 01:09:48
y si pulso no, me devuelve un 1 01:09:52
no, un 1, sí un 0 01:09:54
¿seguro que quiere cerrar? 01:09:58
pues entonces, fijaros, a ver 01:10:00
aquí que podría hacer en el Windows 01:10:02
Closing, pues podría decir if 01:10:06
voy a capturar esto en un entero 01:10:08
int if val 01:10:18
devuelto 01:10:20
digo, esto que estoy, el sí y el no, que me volvió un cero y uno que mostraba por pantalla, ahora lo estoy cargando aquí en esta variable, entonces digo, sí, lo que me ha devuelto es un cero, pues entiendo que me ha devuelto que sí, quiere cerrar, entonces con un sí quiere cerrar, qué código hemos puesto aquí para que se cerrara la ventana antes, fijaros, teníamos el dispose o el system.exe cero, aquí podemos poner esto, 01:10:22
else 01:11:00
bueno 01:11:02
pues 01:11:04
pues nada, pues en realidad no queremos 01:11:05
hacer nada, porque no queremos que se cierre 01:11:08
si queréis que completemos aquí podemos 01:11:10
poner un system.ln 01:11:12
y ponemos aquí 01:11:13
cancelado proceso 01:11:17
de cierre, me he arrepentido 01:11:21
de cerrar, le doy aquí 01:11:29
dices 01:11:30
no, no se cierra la ventana 01:11:32
y fijaros como dice 01:11:35
cancelado, repuesto, cancelado, proceso de cierre. 01:11:36
Y si ahora doy aquí, por aquí también, yo resalto ese mismo evento 01:11:39
y digo, yes, sí, pues la ventana se cierra. 01:11:43
¿Por qué? Porque en ese caso ha entrado por aquí, por el system exit. 01:11:46
Se ha cerrado la aplicación entera en sí. 01:11:49
Diferentes componentes, en este caso el componente ventana, 01:11:54
trabaja con un listener un poquito distinto, 01:11:58
que te mete una serie de métodos. 01:12:00
¿Por qué mete estos métodos? 01:12:03
Porque son los que hemos acordado para esta interfaz. 01:12:05
para este WindowsListener, ahí los tenéis todos 01:12:08
y luego en función de cuando queramos que pasen cosas 01:12:14
en cada uno de estos métodos metemos código, en este caso 01:12:19
nos ha interesado cuando se producía el método WindowsClosing 01:12:23
por defecto la ventana seguro que se cierra 01:12:27
no sé si hace un dispose o un hide, no sé si se esconde o libera toda la memoria RAM 01:12:31
que tenía esa ventana, pero el programa no se cerraba en sí, si queremos 01:12:35
que la ventana no se cierre para tener cierto control aquí de, antes de que se cierre 01:12:39
que pasen algunas cosas, tenemos la posibilidad de indicar 01:12:43
el comportamiento que va a tener este objeto 01:12:47
que este objeto, recordad que es el JFrame, cuando se cierre 01:12:50
que en este caso hemos indicado que sea this do nothing on close, no hagas nada 01:12:55
cuando se cierre, pero, no hagas nada, pero saca los eventos 01:12:59
los eventos si que se lanzan, zona de código donde podemos trabajar nosotros 01:13:03
hay tantas cosas que contar con las ventanas 01:13:07
pero bueno, un poco como para que os dé pistas 01:13:18
luego todos se van comportando de formas 01:13:21
más o menos parecidas 01:13:23
conceptualmente, otra cosita que os comentaba 01:13:26
todo el rato, estamos metiendo los listener 01:13:31
en this, es como this, es esta clase 01:13:32
en esta misma clase estamos poniendo 01:13:36
esto es decir, en esta clase estamos definiendo 01:13:38
el dibujo de la ventana y estamos definiendo el comportamiento 01:13:41
que tienen sus componentes. Pero bueno, por diseño también podríamos decir 01:13:46
pues mira, quiero dedicar unas cosas al dibujo y otras cosas 01:13:50
una clase al dibujo y otra clase diferente al comportamiento 01:13:53
de tal forma que si luego tengo que hacer una actualización en mi proyecto 01:13:58
si lo que quiero es que un componente me salga con otro color o más 01:14:02
desplazado a la derecha o a la izquierda, pues me voy a 01:14:06
tengo muy localizado cómo trabajar eso en la clase 01:14:09
donde lo estoy dibujando. En cambio, si lo que quiero es 01:14:13
que antes guardaba cierta información al pulsar un botón, la guardaba en un fichero 01:14:17
y ahora, además de en el fichero, tengo que escribir una base de datos o solo en la base de datos 01:14:21
o no escribir o cambiar el formato de lo que escribo, no quiero 01:14:25
arriesgarme a tocar la clase donde lo estoy dibujando, no es así que empiece a 01:14:29
mezclar cosas por ahí y se me descuadre todo. Quiero tener bien separadito 01:14:33
el comportamiento del dibujo. Pues eso, ¿cómo lo podemos hacer? 01:14:37
Pues fijaros, para cualquiera de ellos, me da igual, 01:14:42
para el botón 2, vamos a decir que se defina en otra clase. 01:14:45
Fijaros que el botón 2, teníamos aquí puesto el dis, 01:14:51
para que fuese en esta clase. Entonces, aquí lo que vamos a hacer 01:14:54
en nuestro proyecto es crear una nueva clase, 01:14:57
que sea, la llamamos como sea, vamos a llamarla 01:14:59
compor botón 2 01:15:04
aquí cogemos y decimos que creamos un objeto de esta clase 01:15:09
y ahora el botón 2 cuando se produzca 01:15:18
una acción sobre este botón en lugar de decir que 01:15:39
lo capture esta ventana principal lo que vamos a decir 01:15:43
va a ser que el botón 2 lo capture este otro objeto 01:15:47
cuando se produzca una acción sobre este botón ya no se va 01:15:51
a venir al método ActionPerformance y lo que he pulsado ha sido el botón 2, porque no estoy 01:15:58
diciendo que sea esta clase lo que haga, sino que se va a ir a un ActionPerformance que tendrá que 01:16:06
estar definido en este botón 2. ¿Por qué no me compila? Pues porque botón 2 no está implementando 01:16:10
ese Listener. Entonces, si no venimos aquí, hacer copy-pega para que sea más rápido, digo 01:16:15
implementame ese Listener y ahora digo, mete los métodos no implementados, me pone este aquí el 01:16:21
acción performance, si pongo ya aquí un system.out.println, botón 2 pulsado, en, vamos a ponerlo aquí 01:16:32
para que quede claro que es ahí, si yo ahora ejecuto y pulso el botón 2, fijaros como me dice botón 2 01:16:50
pulsado en comport botón 2, donde he derivado el comportamiento de los componentes 01:17:01
No, en particular este componente, cuando se produce un evento sobre él, lo he derivado a este objeto en lugar de a dis. 01:17:10
Antes era a dis en todos los casos, por eso lo implementábamos en esta misma clase. 01:17:20
Bueno, ahora hay una clase encargada de gestionar el comportamiento del botón 2 cuando se ha pulsado. 01:17:24
Por eso al ActionListener le he dicho que sea este objeto, que es un objeto de la clase. 01:17:31
con por si no se ve decirme a ver si tengo por aquí anotar alguna anotación otra cosilla que 01:17:35
os iba a contar porque es que esto el aparte de añadir los listener también se puede meter otro 01:17:56
hacer que hereden las clases de una acción performance si localizó si localizó donde 01:18:05
tengo alguna anotación por aquí de esto 01:18:14
si no lo intentamos hacer en cualquier caso 01:18:16
bueno 01:18:20
sí 01:18:21
bueno, en línea 01:18:26
general es que yo os diría 01:18:36
que un poco 01:18:39
o sea 01:18:40
bueno, yo que sé un poco, a ver 01:18:41
alguna cosa de colecciones, pues alguna cosa 01:18:46
de colecciones, pues caerá 01:18:49
seguramente, alguna cosa de 01:18:51
algún ficherito para escribir o leer 01:18:53
pues también, caer alguna cosa de esas 01:18:55
de estos últimos dos temas 01:18:58
pues como os decía, si andáis 01:19:01
muy sobrados de tiempo 01:19:03
pues miradlos 01:19:05
y si no andáis sobrados de tiempo 01:19:07
tampoco lo miréis mucho porque será 01:19:09
muy poco 01:19:11
el peso que tendrá en el examen 01:19:12
y luego 01:19:15
bueno, pues todo lo demás al final 01:19:17
si es que hace falta para todo 01:19:18
que si los bucles, que si los arraes 01:19:20
al final todo más o menos 01:19:23
hasta el momento en el que hemos llegado 01:19:25
a colecciones 01:19:28
bueno, también están las excepciones 01:19:29
las excepciones quizás 01:19:32
no tengan tanta 01:19:34
trascendencia como quizás las colecciones 01:19:36
o los ficheros, pero hasta el momento que 01:19:38
hemos llegado a esto 01:19:40
es que todo es imprescindible para cualquier 01:19:41
programa, manejar los bucles 01:19:44
un poco, manejar 01:19:46
los condicionales 01:19:47
el examen está estructurado 01:19:50
pues en línea general es un poco como el de febrero 01:19:53
tiene algunas preguntas así iniciales 01:19:57
que tipo T es 01:20:00
os acordáis también que en febrero también lo teníamos así 01:20:02
y luego pues se hace un planteamiento 01:20:06
así un poco general de un ejercicio 01:20:09
y sobre ese ejercicio pues se preguntan 01:20:11
pequeñas parcelas, ¿cómo harías esto? ¿cómo harías esto otro? 01:20:15
y entonces pues para hacer esas cosas pues tendréis 01:20:19
que en algún caso hacer alguna colección 01:20:21
o escribir en algún fichero. 01:20:24
Un poquito esto. 01:20:28
Quizás es un poco genérico y no te preciso mucho, 01:20:33
pero es que es un poco esto. 01:20:36
O no sé si tienes alguna duda así particular. 01:20:40
Bueno, un poco la idea. 01:20:44
Ya te digo, tendrá una pequeña parte ahí con preguntas tipo test 01:20:46
y luego para que escribáis ahí un poco en el código 01:20:50
Os daremos también el chuletario, el mismo que tuvimos en el examen de febrero y que para los que no hayáis venido al examen de febrero, aunque no lo tenéis que traer porque os lo daremos, pero está colgado en el aula virtual para que os familiaricéis un poco con él. 01:20:55
aquel chuletario de febrero incluía estas cosas de las colecciones 01:21:10
si echáis alguna cosa en el chuletario muy en falta 01:21:17
pues decírmelo a ver si nos da tiempo de incorporarlo 01:21:20
de aquí al próximo día 01:21:22
pero bueno, ese mismo chuletario lo venimos usando desde hace años 01:21:24
y en principio yo creo que es un buen resumen 01:21:28
para no tener que acordarse de toda la sintaxis de las cosas 01:21:32
y bueno, pues un poco 01:21:36
esto os puedo contar 01:21:38
no, pero bueno, esto 01:21:40
yo qué sé, sí, más o menos 01:21:48
esto, no sé 01:21:51
sí, y 01:21:52
nada, bueno, pues eso, para el examen 01:21:58
ya os pondré un mensajillo 01:22:00
también un poco recordando, pero bueno 01:22:01
las cosas un poco lógicas, acordaros 01:22:03
de traeros algo que os identifique 01:22:05
porque como tenemos que pasar lista 01:22:07
y bueno, los bolis y poco más 01:22:09
y mucho ánimo 01:22:11
En el examen, si no os quedáis con preguntas, esto siempre os lo digo, si hay cosas que no estáis entendiendo en el examen, preguntadme. Yo valoraré ya si la pregunta sobrepasa un poco lo que os puedo contar o no, pero a lo mejor sí que lo que me estáis preguntando es algo de que os puedo aclarar alguna cosilla y os permite tirar en el examen. 01:22:13
O sea, que no os quedéis con la duda en el cuerpo, que para, como cuando sales por ahí a dar una vuelta, él no siempre lo tiene, ¿no? Pues ya está, pues pregunta si os puedo contar algo de la duda que tengáis, os la aclaro y si me parece que ya no, pues ya os digo, pues no hombre, eso yo creo que lo tendrías que saber, pero vamos, que no se quede la duda ahí pendiente. 01:22:35
y no sé del examen poco a poco más como yo creo que os puedo contar con incluyendo los nuevos 01:22:53
contenidos pues un examen en cuanto a esquema muy muy parecido al de al de febrero en cuanto 01:23:06
a la estructura y esto claro incluyendo ya por las nuevas partes que hemos visto desde entonces 01:23:14
bueno mirad os meto métodos si os parece lo de la acción performance a ver si nos funciona 01:23:19
y tampoco damos muchas más vueltas porque 01:23:33
luego podemos añadir mucho más incluyendo 01:23:36
nuevos componentes por aquí 01:23:41
pero que más o menos, ya os digo, la idea es 01:23:45
con una sintaxis un poco distinta que se puede buscar por ahí 01:23:49
añades el dibujo, le metes un listener, lo metes para el comportamiento 01:23:52
y luego cada vez que actuemos sobre él se ejecuta una zona de código 01:23:57
que es donde metemos el código en particular. Lo que os decía es que también nos da la posibilidad 01:24:01
es en lugar de poner un implement action listener, vamos a hacerlo para la ventana. 01:24:12
Fijaros, hemos metido aquí el implement action listener que nos ha obligado a meter todo esto 01:24:23
y la ventana le hemos dicho un dis, entonces aquí a la ventana donde le hemos dicho aquí el dis, 01:24:27
vamos a decir que también sea este mismo objeto el que tenga en consideración los eventos de la 01:24:40
ventana, es decir que en lugar de saltar estas zonas de código cuando hagamos algo sobre la 01:24:46
ventana salte en la zona de código en este objeto. ¿Qué tendríamos que hacer? Pues nos vendríamos 01:24:53
aquí poner el Implements Window Listener pero en las librerías de Java aparte de los Listener 01:24:59
estos como interfaces tenemos la posibilidad de en lugar de utilizar eso hacer que herede de 01:25:06
windows adapter en lugar de listener windows adapter fijaros que ahora ya no implementamos 01:25:14
sino que heredamos y ahora fijaros que incluso quitando esto me compila o no me compila bueno 01:25:27
no, porque este era de este, vale. El que acabo de borrar era del 01:25:39
listener, no del adapter. Fijaros que el WindowsListener aquí 01:25:43
me había obligado para que compilase a meter todos estos métodos. 01:25:46
En cambio, aquí lo que hemos hecho ha sido un stents, una herencia. 01:25:53
Entonces, todos esos métodos vacíos están ya aquí 01:25:57
disponibles en el adaptador. De tal forma que 01:26:00
ya existen en esta clase todos los métodos 01:26:03
que aquí teníamos 01:26:08
definidos con el 01:26:10
Windows Listener 01:26:14
como interfaz, pero están vacíos. 01:26:16
¿Qué necesitamos hacer? Lo que necesitamos hacer es 01:26:20
que para que todos esos 01:26:23
métodos tengan algún sentido, sobrescribirlos. 01:26:26
Esta clase los tiene disponibles vacíos y aquí los podemos 01:26:28
sobrescribir. Pero si solamente 01:26:31
estamos utilizando el Windows Closing 01:26:35
en lugar de sobrescribir todos, que en realidad 01:26:37
con el interfaz me ha obligado a ponerlos pero vacíos, el único que sobrescribo 01:26:42
es este. Entonces se va a comportar cuando hagamos un Windows Closing 01:26:47
según esto y los demás no los tengo que escribir. 01:26:52
El Windows Listener, como es un interfaz, me obliga a meter todos dentro de esta clase 01:26:56
porque en realidad son abstractos esos métodos en el interfaz 01:27:00
pero el Windows Adapter es una clase que los tiene 01:27:04
desarrollados, pero vacíos. Todos ya existen, me compila, pero no 01:27:10
hacen nada. Si quiero que haga algo, alguno de ellos, en este método 01:27:14
tengo que sobrescribirlo. Y todos los demás vacíos no los tengo que sobrescribir y tienen 01:27:18
su comportamiento vacíos, igual que aquí los tenía este. 01:27:22
Entonces, para tener claro que está pasando por aquí, 01:27:31
porque se lo hemos dicho aquí al incluir 01:27:36
el AddWindowListener, hemos dicho 01:27:40
que sea este objeto y no di ya a quien 01:27:43
capture 01:27:45
los eventos relacionados con la 01:27:47
ventana, para 01:27:49
tener claro que pasa por aquí, en lugar de pasando 01:27:51
por Windows Closing, vamos a poner pasando por 01:27:53
Windows Closing de la clase 01:27:55
con por botón 01:27:58
2, en lugar de 01:27:59
el que nos salía antes, que sería 01:28:01
este, pasando por 01:28:03
Windows Closing, pues ahora para tener certeza 01:28:05
que es por este, ponemos pasando por 01:28:07
Windows Closing con por botón 01:28:09
2, entonces damos aquí 01:28:11
veis y ya me dice pasando por windows cruz en con por botón 2 que es que es vamos en lo 01:28:17
previsible que tiene que pasar porque lo que le hemos dicho aquí que es esta clase ahora la que 01:28:23
se encarga de los eventos relacionados con la ventana donde lo tenemos y bueno por aquí tenía 01:28:28
un montón de controles más para mostraros pero pero yo creo que no voy a arrancar ya porque ya 01:28:44
nos falta poco rato y no nos va a dar tiempo a meter muchos más queréis que de aquí de esto de 01:28:50
las ventanas o de el resto de los contenidos del curso alguna duda así seria que queréis que 01:29:00
comentemos o algo de eso cualquier caso estoy pendiente estos días también de de los foros 01:29:07
por si acaso me queréis preguntar alguna cosita diferente y os pongo un mensaje antes de del 01:29:19
examen que no recuerdo si es el miércoles cuando lo tenemos pues os pongo un mensajillo también 01:29:26
recordando un poco las diferentes cosas 01:29:33
para el día del examen. ¿Alguna cosita 01:29:35
más? ¿Os parece 01:29:43
que vayamos cerrando entonces por hoy? 01:29:45
Bueno, si no, me decís 01:29:53
nada nuevo. 01:29:54
Que tengáis mucha suerte esta semana 01:29:56
de exámenes y a ver si os quitáis 01:29:58
todas o la mayor parte de ellas. 01:29:59
Y nada, 01:30:03
nos mantenemos en contacto estos días. 01:30:04
Venga, pues nada. 01:30:10
Buena tarde a todos. 01:30:10
Os dejo 01:30:14
también colgada esta clase 01:30:14
ahí en el curso de Lola Virtual. 01:30:16
Venga, hasta luego. 01:30:20
Buena tarde. 01:30:21
Chao. 01:30:21
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
JM
Subido por:
Jose Manuel M.
Licencia:
Dominio público
Visualizaciones:
20
Fecha:
12 de mayo de 2025 - 19:09
Visibilidad:
Clave
Centro:
IES ALONSO DE AVELLANEDA
Duración:
1h′ 30′ 24″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
202.71 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid