Saltar navegación

Clase 19-04-24 - 2 - 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 21 de abril de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues nada 00:00:00
pues la primera parte, o sea, ya tenemos 00:00:02
hecho el marco, pero claro 00:00:04
Anis, un compañero 00:00:05
silencio 00:00:08
bueno, entonces, ahora 00:00:09
nuestra aplicación 00:00:11
de partida, es una aplicación en la que 00:00:16
le metes un año y te dice si es bisiesto, ya está 00:00:18
la tengo aquí en mi 00:00:20
reloj, meto el año y me dice, ah, pues era bisiesto 00:00:21
pues yo que sé, porque me están preguntando todo el rato 00:00:24
y así lo contesto rápido 00:00:26
bueno, pues entonces, la primera parte 00:00:27
que nos planteamos es, venga, pues vamos a 00:00:30
decidir el diseño. ¿Qué componentes 00:00:32
necesito? 00:00:34
El contenedor raíz ya lo tenemos. 00:00:36
Que es este. Ya tenemos el 00:00:38
contenedor raíz. Pero hay que 00:00:40
decidir qué componentes queremos que estén. 00:00:42
Bueno, pues entonces 00:00:45
lo ideal sería que hubiera 00:00:46
una etiqueta que pusiera 00:00:47
introduzca el año. 00:00:50
Un área de texto 00:00:53
para meter 00:00:54
yo el año. 00:00:56
Y luego un botoncito, pues para 00:00:57
ver si es bisiesto, por ejemplo 00:01:00
eso sería la idea, luego tres componentes 00:01:01
me han salido, tres componentes 00:01:04
una etiqueta 00:01:06
para mostrar simplemente un mensajito 00:01:07
para mostrar un área de texto 00:01:09
para introducir 00:01:12
y un botoncito 00:01:13
para calcular si es bisiesto 00:01:16
tres, vale 00:01:18
pues ahora se trata de que yo averigüe 00:01:19
esos componentes como se llaman en swing 00:01:21
y los incorpore 00:01:23
a este marco básico 00:01:26
vale, pues 00:01:27
¿en qué momento, en qué punto del programa 00:01:29
que yo he hecho aquí se incorporan? 00:01:31
Bueno, pues este frame mío 00:01:32
aparece, se instancia 00:01:34
en el código, aquí, cuando yo llamo 00:01:38
al constructor. 00:01:39
Ahí es donde se instancia. 00:01:41
Luego, en el constructor 00:01:43
es donde yo tendré que pegarle las cosas. 00:01:45
¿No? 00:01:49
Cuando este objeto aparece y se construye 00:01:49
es cuando se llama al constructor, 00:01:52
obviamente. Entonces yo aquí 00:01:54
no he hecho ningún constructor, luego está usando 00:01:55
el constructor por defecto, que no hace nada 00:01:57
salvo 00:01:59
llamar al de super, porque el constructor 00:02:01
por defecto, si yo no lo indico 00:02:04
llama al de super 00:02:05
y el super por defecto del frame, ¿qué hará? 00:02:06
pues el super por defecto del frame 00:02:09
hace esto 00:02:11
construir esto 00:02:12
entonces mi constructor por defecto ahora mismo 00:02:14
está haciendo super 00:02:17
que es esto de aquí, nada más 00:02:18
entonces vamos a 00:02:21
sobrescribir ese constructor, vamos a 00:02:23
sobrescribirlo para que 00:02:25
añada las cosas que hacen falta 00:02:27
vale 00:02:29
pues entonces 00:02:31
sobreescribimos 00:02:32
el constructor, porque repito 00:02:35
a través 00:02:37
de él es como se construye 00:02:40
ese objeto, a través de él, y yo quiero 00:02:41
añadirle cosas 00:02:43
pues vamos a sobreescribir ese constructor 00:02:45
vale, pues entonces 00:02:47
tendría que seleccionar que componentes 00:02:59
son los que me interesan 00:03:01
y añadírselos a ese frame 00:03:02
bueno, pues 00:03:05
primero, ¿qué componentes son? 00:03:07
si uno busca, pues encuentra rápidamente 00:03:08
que son estos tres componentes 00:03:11
básicos 00:03:13
el JLabel que es la etiqueta para mostrar 00:03:13
texto 00:03:17
para mostrar un texto, para mostrar 00:03:17
imágenes, incluso lo que sea 00:03:20
para introducir datos 00:03:22
el área de texto para introducir datos 00:03:26
esa si uno se pone a buscar 00:03:28
en la documentación de Swin 00:03:30
pues ve rápidamente 00:03:32
que es el componente 00:03:34
JTextField 00:03:36
y de nuevo 00:03:37
si queremos un botoncito para decir 00:03:43
ahora, coge ahora el texto, calcula 00:03:46
lo que sea, calcula 00:03:48
pues rápidamente encontraríamos esto 00:03:49
entonces estos tres componentes son básicos 00:03:51
en cualquier interfaz gráfica 00:03:56
una etiqueta que muestra contenido 00:03:58
un área de texto para meter 00:04:00
un campo de texto para meter 00:04:02
texto y un botoncito, son básicos 00:04:04
entonces estos unos ya, pues los clientes lo saben de memoria 00:04:06
vale, pues ahora se trataría 00:04:08
de instanciarlos 00:04:10
y añadirlos a ese frame básico 00:04:11
añadirlos a ese frame 00:04:15
pero 00:04:16
lo siguiente que tenemos que entender 00:04:17
el frame básico 00:04:20
este de aquí, este frame básico 00:04:22
como veis de hecho aquí esto me aparece en gris 00:04:25
normalmente cuando 00:04:27
vosotros abrís una aplicación en Java 00:04:29
es muy raro que el fondo sea gris 00:04:31
o sea eso ya nos da indicaciones 00:04:33
de que el frame básico en realidad 00:04:35
es un contenedor raíz que no vale 00:04:36
directamente para ponerle componentes 00:04:38
hay que poner un contenedor intermedio 00:04:40
que es el que se llama panel 00:04:43
¿vale? entonces 00:04:44
tenemos el marco raíz básico 00:04:46
el frame, uno o más 00:04:49
paneles 00:04:51
que se pegan al frame y ahora ya 00:04:52
a los paneles van los componentes 00:04:55
¿vale? entonces 00:04:57
los componentes 00:04:59
recopilo 00:05:02
no se pegan directamente 00:05:05
al frame, no se añaden 00:05:07
sino que se añaden a 00:05:09
Una cosa que se llama paneles 00:05:19
Sino que se añaden a paneles 00:05:21
A paneles que están asociados a ese frame 00:05:23
¿Vale? Entonces 00:05:33
Pues 00:05:40
Uno diría, hombre, pues tendré que hacer 00:05:42
Un panel y asociarlo al frame 00:05:44
Vale, pues podemos hacer eso, un panel y asociarlo 00:05:45
Al frame, y ahora ya a ese panel 00:05:48
Pero cualquier frame 00:05:50
Viene ya con un panel por defecto 00:05:52
Si yo quiero usarlo 00:05:54
Que puedo activar, que puedo recoger 00:05:55
Que puedo coger, viene con un panel por defecto 00:05:58
Y ese panel por defecto se saca de aquí. 00:06:00
Es decir, el objeto panel sería este. 00:06:04
Asociados al frame. 00:06:08
A ese frame. 00:06:10
Vale. 00:06:11
Entonces, el objeto panel es el JPanel. 00:06:12
Ese es un panel, el JPanel. 00:06:15
Preguntaréis, que os vea ansiosos por preguntar mil cosas. 00:06:17
Y como todas las clases tienen una J delante. 00:06:20
No podría ser Label, TextField, Button, Panel. 00:06:24
Tiene más sentido. 00:06:26
Todas una J. 00:06:27
Claro, porque Swin en realidad es un paquete 00:06:28
desarrollado a partir de la versión antigua 00:06:30
de esta que se llamaba AWT 00:06:33
entonces, AWT 00:06:35
tenía sus componentes 00:06:37
Label, TextField, Button, Patatín 00:06:39
entonces cuando se incorporó ya Swim 00:06:41
que es la versión moderna 00:06:43
de AWT 00:06:45
para que no tuvieran el mismo nombre 00:06:46
porque no se podía desaparecer el otro 00:06:49
el otro tiene que seguir existiendo 00:06:51
porque si no las aplicaciones que estaban hechas para AWT 00:06:52
si quitamos de las máquinas virtuales 00:06:54
AWT, dejarían de funcionar 00:06:57
todas las aplicaciones de golpe 00:06:58
entonces AWT no se puede quitar de las máquinas 00:06:59
virtuales, AWT sigue 00:07:02
estando y sigue estando, label, textfield, 00:07:04
button, entonces las clases 00:07:06
del nuevo paquete que es JavaX 00:07:08
el antiguo era este 00:07:10
¿veis? este de aquí que sigue existiendo 00:07:11
este era el antiguo y aquí está 00:07:16
button, panel, todas 00:07:21
pues las clases del nuestro 00:07:23
del nuevo, para que se 00:07:25
distinguieran se les puso una J delante 00:07:28
y ya está, nada más, de ahí viene la J 00:07:29
¿vale? 00:07:31
vale, pues entonces el panel 00:07:32
podemos construir nosotros uno 00:07:36
pegarlo al frame 00:07:39
pero es que 00:07:40
hemos dicho que el frame ya tiene un panel 00:07:42
por defecto que yo puedo recoger 00:07:45
entonces mi frame 00:07:47
es este, es mi objeto this, ¿verdad? 00:07:49
ahora mismo recordad que 00:07:51
estamos en el constructor de la clase 00:07:53
ventanaVis y esto es mi frame 00:07:55
es mi frame particularizado, pues es this 00:07:56
pues this por heredar de 00:07:59
JFrame tiene un método 00:08:01
que se llama 00:08:03
getContentPanel 00:08:05
¿veis? habréis podido acceder a este método 00:08:09
getContentPanel 00:08:14
y este método 00:08:15
me devuelve el panel 00:08:17
que por defecto tiene asociado 00:08:19
un frame, puedo yo pasar 00:08:21
de ese panel, crearme otros paneles 00:08:23
y asociarlos al frame 00:08:25
o me puedo 00:08:27
quedar con el panel por defecto 00:08:30
que si lo recojo es un panel 00:08:32
que se extiende en todo el 00:08:33
tamaño del frame, todo el tamaño 00:08:36
porque yo puedo hacer paneles de diferentes tamaños 00:08:37
pues el panel por defecto se estira 00:08:39
a todo el 00:08:42
el tamaño del frame 00:08:43
vale, pues ahora ya tengo un panel 00:08:45
vale, lo que pasa es que 00:08:52
getContentPan este 00:08:56
te obliga a que 00:08:59
lo guardes en container que es un 00:09:02
sobre, una super clase de jPanel 00:09:04
vale 00:09:07
lo que pasa es que normalmente, ahora lo vamos 00:09:07
a abreviar para que veáis como se escribe normalmente 00:09:10
entonces, vale, bueno 00:09:12
pues entonces, a este panel 00:09:14
que es lo que me devuelve el get 00:09:15
content panel, que es el panel por defecto 00:09:18
a este ya sí se pueden 00:09:20
añadir componentes 00:09:22
entonces 00:09:23
¿y cómo se añaden componentes al panel? 00:09:25
bueno, aparte de añadir componentes, el panel 00:09:28
pues tiene métodos para 00:09:30
hacer 00:09:32
sí, he puesto la clase jPanel porque es una 00:09:33
subclase 00:09:39
de container 00:09:41
y es la clase que tienen los paneles 00:09:43
en general. Lo que pasa es que este método 00:09:45
es el paquete 00:09:47
de AWT. 00:09:51
Container, dices. Sí, porque 00:09:52
usan clases de varios, o sea, mezclan. 00:09:54
De hecho, los eventos se usan 00:09:56
las clases de AWT. Hay cosas 00:09:58
que no se han reescrito. 00:10:00
¿Vale? Entonces, getContentPanel 00:10:02
es un método que está 00:10:05
programado de tal manera 00:10:06
que te devuelve un objeto container 00:10:10
pero a lo mejor lo que nos importa es que es un objeto 00:10:12
panel y a este panel ya le podemos añadir cosas 00:10:16
no solo añadir cosas 00:10:19
podemos cambiarle el color, podemos hacer mil historias 00:10:22
a través de los métodos que tiene, cada clase tiene mil métodos 00:10:25
pero a nosotros ahora en particular lo que queremos es añadirle 00:10:29
ahora ya componentes y para eso tiene el método add 00:10:31
pues venga, vamos a añadirle 00:10:34
¿qué queremos añadir al panel? 00:10:36
pues queremos añadirle 00:10:39
los tres componentes que hemos dicho 00:10:41
queremos añadirle 00:10:43
una etiqueta 00:10:45
un área de texto 00:10:46
y queremos añadirle 00:10:54
un botón 00:10:58
son las tres cosas que queremos 00:10:59
eso es lo que queremos añadirle 00:11:01
al panel 00:11:04
una etiqueta, un área de texto 00:11:05
y un botón, que todavía no tenemos creados 00:11:09
¿vale? 00:11:11
queremos añadirlo 00:11:12
entonces, normalmente 00:11:13
cuando uno trabaja con el panel por defecto 00:11:15
no se hace a través 00:11:18
de esta variable intermediate añadiendo, sino que se pone 00:11:20
directamente aquí esto 00:11:22
el dis get content panel 00:11:24
¿vale? se pone directamente aquí 00:11:25
entonces yo ahora como estoy en 00:11:28
la parte primera en la que lo estoy explicando 00:11:30
todo más o menos al nivel de detalle 00:11:32
que se puede entender 00:11:34
pues he dicho, esto me devuelve panel 00:11:35
y ahora ya al panel lo añado, pero esto 00:11:38
como normalmente lo vais a encontrar 00:11:40
es directamente así, que es 00:11:41
getContentPanel.add 00:11:44
el componente que sea 00:11:50
así es como lo vais a encontrar, ¿por qué? 00:11:51
primero 00:11:57
porque el dis no hace falta, es opcional 00:11:58
recordad que si aparece una llamada 00:11:59
a un método por las buenas 00:12:01
en realidad es porque es dis quien lo está 00:12:03
llamando 00:12:06
el dis es opcional 00:12:06
me da igual poner dis getContentPanel 00:12:08
que poner esto 00:12:11
vale, pues este es el panel 00:12:13
por defecto 00:12:15
el que yo he guardado antes aquí 00:12:17
para que se viera más claro 00:12:19
y ahora al panel por defecto le añado 00:12:21
lo que me dé la gana 00:12:23
esta es la manera en la que lo vais a encontrar 00:12:24
y aquí es transparente 00:12:27
esto de container, ni se ve 00:12:29
y así no hay que importar 00:12:31
la clase ni nada 00:12:33
ay, perdonad, dime 00:12:34
un segundo 00:12:39
o sea, puedo pero si es muy rápido 00:12:42
porque estoy en clase 00:12:44
pues ahora sí que seguimos 00:12:44
bueno, pues entonces 00:12:47
repito, como os lo vais a encontrar 00:12:50
es así, es mucho más 00:12:51
que no con esta línea intermedia 00:12:53
ahora añadir al panel 00:12:56
vale, con lo cual este import 00:12:57
ahora ya sí que no haría falta 00:13:02
vale, entonces esta línea, nadie la extraña 00:13:04
¿no? de mi objeto frame 00:13:11
saco mi panel por defecto 00:13:13
de mi disk saco mi panel por defecto 00:13:15
y a ese panel por defecto le añado 00:13:17
los componentes que necesito 00:13:19
¿qué componentes hemos dicho que queremos? 00:13:20
esto después de haber hecho nuestro estudio 00:13:23
pues para explicaroslo 00:13:25
de dónde venía, y luego ya lo he dejado comentado 00:13:30
porque digo que lo vais a encontrar así, para explicaroslo 00:13:32
de dónde venía, ¿vale? 00:13:34
para no poner esta línea sin más, para explicaros 00:13:41
que esto viene de que esto es un objeto panel 00:13:43
y a ese objeto panel 00:13:45
hay que añadirle los componentes 00:13:47
y ese objeto panel 00:13:49
se saca de este 00:13:51
del frame en el que estoy 00:13:53
vale, pues entonces 00:13:54
a este objeto panel que hemos sacado 00:13:57
del frame en el que estamos, que es el panel 00:13:59
por defecto, pero podríamos haber instanciado 00:14:01
otros, podríamos haber hecho esto 00:14:03
podríamos haber instanciado otro panel 00:14:05
un panel mío que a mí me da 00:14:09
la gana y ya está 00:14:11
podría haber yo instanciado un panel 00:14:12
mío porque a mí me ha dado la gana, un jPanel 00:14:19
y pegarle a este los componentes 00:14:21
y luego pegar este al frame 00:14:23
¿vale? 00:14:24
pero vamos a trabajar, como estamos ahora al principio 00:14:27
vamos a trabajar con el panel por defecto 00:14:29
este, en lugar de con este, que podría 00:14:31
trabajar con este, que es uno que he instanciado de nuevas 00:14:33
pues vamos a trabajar con el panel por defecto 00:14:35
que se ha dado con este método, ya está 00:14:39
bueno, pues entonces 00:14:40
nosotros hemos decidido que vamos a usar 00:14:42
a ver, silencio 00:14:44
que vamos a usar una etiqueta 00:14:49
un área de texto y un botón, entonces 00:14:52
esto normalmente, Andoni, ¿te das 00:14:54
la vuelta y te callas de una puñetera vez para el resto 00:14:56
de tu vida hasta las dos y media de hoy? 00:14:58
Bueno, pues entonces, esto cuando uno decide, está en la parte de decidir la vista, lo suele decidir con herramientas que sirven solamente para construir vistas para que el cliente de tu aplicación lo vea. 00:15:01
Entre ellas hay una, que es la más usada, que es una que se llama Pencil, pero habrá muchas, claro, que son herramientas que te permiten a ti construir interfaces que no valen para nada, es solo para ver qué aspecto quedan, a ver si quedan bonitas o no. 00:15:14
y tú te haces ahí tu prototipo 00:15:31
y dices, oye, te vas al cliente 00:15:34
las ventanitas que tú quieres son estas 00:15:36
no, esta no me gusta 00:15:38
en esta me hace falta un botón 00:15:40
porque quiero además decirle no sé qué, pues en esta no sé cuánto 00:15:42
vale, te construyes un prototipo 00:15:44
entonces esta primera parte 00:15:46
que es la del diseño de la vista 00:15:47
si es muy compleja, pues eso se hace con herramientas 00:15:49
específicas para tú tener 00:15:52
unas vistas y se las vas enseñando 00:15:54
entonces nosotros después de haber hecho ese proceso 00:15:56
podríamos haber llegado a la conclusión 00:15:58
de que, ah, vale 00:16:00
el cliente nuestro lo que quiere es 00:16:01
un texto en el que ponga 00:16:03
introduzca año 00:16:06
un text fill 00:16:07
un área de texto en el que yo ponga el año 00:16:09
y un botoncito calcular 00:16:11
o resultado 00:16:14
o lo que uno quiera 00:16:16
vale 00:16:17
bueno pues esta es 00:16:18
nuestro prototipo 00:16:21
en eso estamos, pues ahora tenemos que seleccionar 00:16:23
estos componentes cuáles son, que ya los hemos dicho 00:16:25
jlabel es este 00:16:27
JTextFile es este y JButton es este 00:16:29
Y ahora vamos a añadirlos 00:16:32
Al panel 00:16:33
Pues para añadirlos tengo que construirlos antes 00:16:34
Si no, ¿cómo los voy a añadir? 00:16:37
¿Cómo los voy a añadir al panel si no los he construido antes? 00:16:38
Pues venga, vamos a construir la etiqueta 00:16:42
La etiqueta 00:16:43
Vale, esto es una etiqueta básica 00:16:46
Que no tiene texto ni tiene nada 00:16:54
¿Qué texto quiero yo que muestre? 00:16:57
Introduzca el año 00:17:00
Bueno, pues el texto de la etiqueta 00:17:01
se lo puedo poner en el constructor 00:17:04
ala, ese es el texto de la etiqueta 00:17:05
introduzca al año, ya tengo la etiqueta 00:17:15
y ahora ya se la puedo añadir 00:17:17
al panel, ala venga 00:17:19
etiqueta, ya tengo 00:17:21
mi etiqueta añadida al panel 00:17:23
que a su vez está en el frame 00:17:26
¿qué más quiero? quiero un text fill 00:17:27
porque necesito meter el año 00:17:29
y el componente para 00:17:33
meter texto, para meter datos es el 00:17:35
text fill porque ya lo he averiguado 00:17:37
pues venga 00:17:38
uno lo llama como le dé la gana 00:17:40
ala, ya tenemos el jtexfil 00:17:50
ya lo tenemos 00:17:58
vamos a añadirlo al panel también 00:18:03
claro, claro, porque en el constructor 00:18:04
es donde se construye la 00:18:16
interfaz, ala, ya tengo 00:18:17
añadido la etiqueta 00:18:21
al panel por defecto y el jtexfil 00:18:23
al panel por defecto, y me falta un botoncito 00:18:26
pues lo instanciamos 00:18:28
lo importamos 00:18:41
y de nuevo lo añadimos al 00:18:42
en el botón 00:18:50
lo normal es que estos componentes 00:19:00
no queramos su aspecto básico 00:19:03
sino que los queramos personalizar 00:19:05
por tamaño, por color 00:19:07
por texto que tiene encima, lo que sea 00:19:09
aquí la etiqueta de hecho la hemos personalizado 00:19:11
la hemos personalizado poniéndole un texto 00:19:13
pero podríamos seguirla 00:19:15
personalizando 00:19:17
a través de los métodos que me ofrece 00:19:18
cambiándole el color 00:19:21
cambiándole el tipo de letra 00:19:23
cambiándole, como veis tiene tropecientos mil 00:19:25
métodos que permiten 00:19:27
personalizar ese componente 00:19:29
yo no la he 00:19:31
personalizado, simplemente la he 00:19:34
dado el texto que quiero que tenga 00:19:36
el text field igual, me he cogido 00:19:37
el text field básico, también podría 00:19:40
ir a los métodos de datos y 00:19:42
personalizar lo que pudiera y me dejara 00:19:44
que son millones de cosas 00:19:45
¿vale? con swing 00:19:47
si yo no personalizo, la interfaz 00:19:49
básica de swing pues tiene un aspecto el de toda la 00:19:51
vida, pues el de toda la vida 00:19:54
de las aplicaciones java de siempre 00:19:56
pero si uno ya lo personaliza 00:19:57
con tamaños de letra 00:19:59
con bordes, con fondos 00:20:02
puede simular 00:20:04
absolutamente cualquier aspecto 00:20:06
cualquiera 00:20:08
vale, el botón tampoco lo he personalizado 00:20:08
pero hombre, este sí que necesita 00:20:12
por lo menos un texto encima 00:20:13
cuando uno le da un botón suele tener ok 00:20:15
o calcular o lo que sea 00:20:17
pues ese texto se puede particularizar 00:20:19
directamente en el constructor 00:20:21
no hace falta que lo hagamos luego a través de un método 00:20:23
pues vamos a ponerle que tenga el botoncito 00:20:25
tenga el método, el texto encima 00:20:29
es bisiesto, por ejemplo 00:20:31
para que al darse el botón me diga si o no 00:20:32
entonces ahora vamos a ver 00:20:34
esta interfaz teóricamente tendría que tener estos tres 00:20:39
componentes porque los he añadido al panel 00:20:41
del frame 00:20:43
los he creado y los he añadido 00:20:45
entonces ahora ya mi main 00:20:47
¿qué hace? instancia este objeto 00:20:49
y al instanciarlo 00:20:51
hace ya todo esto, porque llama al constructor 00:20:53
hace ya todo esto 00:20:55
instancias 00:20:56
y luego lo hago visible 00:20:57
bueno, le doy un tamaño 00:21:00
y lo hago visible 00:21:01
entonces 00:21:03
si ejecutamos esto 00:21:05
pues hombre 00:21:08
desde luego algo tiene 00:21:11
lo que tiene es un pedazo botón 00:21:13
tremendo 00:21:15
gigante, claro 00:21:16
yo no lo he personalizado 00:21:19
el botón por defecto se estira hasta el infinito 00:21:20
se estira hasta el infinito 00:21:24
esto 00:21:26
y ¿dónde está lo otro? 00:21:27
lo otro está debajo, no lo puedo ver 00:21:30
o sea, primero ha metido la etiqueta 00:21:32
como yo no he personalizado 00:21:34
ni dónde colocarlo 00:21:36
ni nada, no he personalizado nada 00:21:38
por defecto 00:21:40
la colocación es, pa, JLabel 00:21:41
ahí en medio planta 00:21:44
ahora el text fill 00:21:45
encima del JLabel tapándolo, ahí en medio planta 00:21:48
ahora, añade JButton 00:21:50
encima de lo anterior 00:21:52
o sea, los tres objetos están 00:21:54
pero es que están uno encima del otro y encima del botón 00:21:56
se ha estirado ahí hasta, con lo cual esto no me vale 00:21:58
para nada, claro 00:22:00
entonces un mínimo de colocación de componentes 00:22:01
tendremos que darle, un mínimo 00:22:04
vale, bueno, pues esto 00:22:05
hay herramientas y plugins 00:22:09
para poder hacerlo con 00:22:12
la forma de los vagos 00:22:13
que es el arrastro y pego, arrastro y pego, arrastro y pego 00:22:15
que nosotros usaremos 00:22:18
porque claro, no podemos hacerlo todo a mano, aunque 00:22:19
una de las empresas 00:22:21
con la que trabajamos 00:22:23
que hace aplicaciones para el BBVA y no sé qué 00:22:24
en Java 00:22:27
a todos sus trabajadores, a todos, a todos 00:22:28
los hace hacerlo a mano, o sea, y contar los 00:22:31
píxeles y todo, nada de usar esas herramientas 00:22:33
lo digo porque vais a encontrar de todo 00:22:36
de todo y tenéis que ser capaces de hacerlo 00:22:37
todo, todo 00:22:39
tenéis que ser capaces de hacer lo que habéis 00:22:40
hecho aquí, que será algo, y todo lo que no habéis 00:22:43
hecho aquí, porque sabéis de que 00:22:45
va ahí 00:22:47
bueno, pues entonces 00:22:48
esta aplicación no nos 00:22:51
vale, es que yo aquí ni tengo el área 00:22:53
de texto para meter cosas, ni tengo nada 00:22:55
entonces un poquito más tendremos que hacer 00:22:57
es que yo aquí he hecho 00:22:59
he racaneado, he hecho lo más básico 00:23:01
he hecho los tres componentes, los he pegado al panel 00:23:03
y ya está, no he podido racanear más 00:23:05
vale, pues algo más 00:23:07
sí que hay que hacer para colocarlos 00:23:09
entonces, ¿cómo se puede gestionar 00:23:11
la colocación de los 00:23:14
componentes? gestionar 00:23:15
pues mediante lo que se llaman 00:23:17
gestores de ubicación 00:23:19
¿vale? 00:23:21
entonces vamos a ponerlo aquí 00:23:23
si no usamos, que es lo que yo he hecho aquí 00:23:24
no usar, si no usamos una cosa 00:23:29
que se llama gestores de ubicación 00:23:31
los componentes 00:23:34
se ponen unos encima de otros 00:23:38
y encima con el tamaño máximo 00:23:40
entonces esto no nos vale 00:23:49
vale, pues entonces 00:23:56
¿cómo se usan los gestores 00:24:00
de ubicación? los gestores de ubicación 00:24:02
son objetos que hay que crear 00:24:04
estamos en la operación 00:24:05
de datos objetos, cualquier cosa 00:24:08
que haga algo y que forme parte de nuestra 00:24:09
aplicación es un objeto, no hay otra. 00:24:12
Entonces, un gestor de ubicación es un objeto 00:24:14
que hay que crear. Y ese gestor de 00:24:16
ubicación, ¿a quién hay que asociarlo? 00:24:18
Al panel, que es el que tiene los 00:24:20
componentes. Entonces, mi panel, 00:24:22
en mi caso es el getContentPane 00:24:24
que saco por defecto, mi panel, 00:24:26
que es el que tiene los componentes, tiene que tener 00:24:28
un gestor de ubicación que le manda. Ahora mismo 00:24:30
nadie le manda. No hay ningún gestor 00:24:32
de ubicación creado. Pues entonces, 00:24:34
por defecto, es unos encima de otros. 00:24:36
Pues entonces, antes de 00:24:39
hacer todo esto de aquí. 00:24:40
Vamos a crear un objeto gestor 00:24:44
de ubicación y le vamos a hacer jefe del panel. 00:24:46
Y ahora ya sí, el panel 00:24:49
seguirá las órdenes de su jefe, 00:24:50
que es el gestor de ubicación. 00:24:52
Que ahora no tenía ningún jefe, gestor de ubicación, 00:24:54
uno encima del otro. 00:24:55
Bueno, pues entonces, vamos a crear 00:24:57
un gestor de ubicación. 00:25:00
¿Gestores de ubicación cuántos hay? 00:25:07
Hay muchos tipos distintos. 00:25:09
Cada gestor de ubicación se corresponde 00:25:11
con un tipo diferente de ubicación 00:25:13
ubicación dándole yo coordenadas 00:25:15
ubicación uno detrás de otro 00:25:18
ubicación en celdilla 00:25:20
hay un montón de gestores de ubicación 00:25:22
como nosotros no nos vamos a perder 00:25:24
ni a volver locos 00:25:26
haciendo ubicaciones manuales 00:25:27
porque no tiene sentido 00:25:29
que perdamos el tiempo en eso 00:25:31
vamos a ver simplemente 00:25:32
cómo usar un gestor de ubicación 00:25:33
el más sencillo 00:25:35
que es el gestor de ubicación 00:25:36
que coloca los componentes 00:25:37
uno tras otro 00:25:38
y ya está 00:25:40
al menos con uno tras otro ya veremos algo 00:25:42
ya veremos, porque están uno tras otro 00:25:44
¿vale? si queremos hacer 00:25:46
ubicaciones ya más personalizadas 00:25:48
tendríamos que usar gestores de ubicación 00:25:50
a los que hay que darles 00:25:52
además luego la coordenada en la que tú quieres 00:25:54
etcétera, que es muy fácil de usar también 00:25:56
pero no nos vamos a perder en eso 00:25:58
venga, vamos a crear un gestor de ubicación ¿de qué tipo? 00:25:59
del tipo 00:26:03
uno detrás de otro 00:26:04
entonces vamos a ponerlo aquí 00:26:06
como lo vamos a subir esto 00:26:08
cada gestor de ubicación 00:26:09
está asociada a un tipo de 00:26:12
a una forma de ubicar diferente 00:26:16
los componentes 00:26:18
bueno, pues repito, hay muchos gestores de ubicación 00:26:19
cada uno de ellos está asociado a una forma 00:26:34
uno de los gestores 00:26:36
de ubicación es este 00:26:38
el flow layout, este es uno 00:26:39
y es el más sencillo, porque este 00:26:44
está asociado a los componentes uno detrás 00:26:46
de otro 00:26:48
pues vamos a instanciarlo 00:26:49
vamos a instanciarlo 00:26:53
llamadlo como 00:26:55
venga, pues este 00:26:58
como es muy sencillo, no hay que darle ni parámetros 00:27:04
ni nada, porque este es uno detrás de otro 00:27:07
no hay que 00:27:08
pues ala, instanciado 00:27:09
ahí está 00:27:12
flow layout 00:27:14
lo importamos de su librería, que los gestores 00:27:15
de ubicación no se han reescrito, porque no ha hecho 00:27:20
falta, están aquí 00:27:22
vale, ahora el gestor de ubicación 00:27:24
ya está, este es el que 00:27:28
es capaz de mandar uno detrás de otro 00:27:29
pero claro, hay que decírselo al panel 00:27:32
hay que decirle, oye panel, que tu jefe 00:27:34
es ese gestor que yo he dado 00:27:36
tu jefe es ese 00:27:37
vale, pues vamos a darle un jefe al panel 00:27:39
darle un jefe 00:27:42
al panel, pues ese panel tendrá un método 00:27:44
para fijarle un jefe 00:27:46
de ubicación 00:27:48
pues sí que lo tiene, ese método setLayout 00:27:49
el método setLayout dice 00:27:52
tú, tu gestor de ubicación 00:27:56
jefe es el que yo te paso 00:27:58
por parámetro, es este que yo 00:28:00
te paso 00:28:02
¿vale? 00:28:03
entonces vamos a ponerlo aquí 00:28:06
flow layout 00:28:07
gestiona 00:28:12
pone uno detrás de otro 00:28:14
y ahora con set layout 00:28:18
con esto que estamos 00:28:25
haciendo aquí, asociamos 00:28:27
el gestor 00:28:29
al panel 00:28:30
porque no me sirve de nada crear el gestor 00:28:32
Si luego al panel no le digo 00:28:35
Oye, hazle caso a este gestor 00:28:37
No me vale de nada 00:28:39
Pues con este método 00:28:40
Ya hemos hecho caso 00:28:42
Ya el panel le va a hacer caso a este gestor 00:28:43
Ahora ya volvemos a ejecutar esto 00:28:46
Y bueno, hombre 00:28:49
Ya vemos los tres componentes 00:28:52
Los tres 00:28:55
Lo que pasa es que el text field 00:28:57
Es una racané de text field 00:28:59
Meter ahí un número 00:29:01
Pinchar ahí es prácticamente complicado 00:29:03
claro, porque yo es que el text field 00:29:05
lo he creado sin personalizar 00:29:08
y el text field por defecto es enano 00:29:09
bueno, pues tendríamos que personalizar 00:29:11
el tamaño que queremos que tenga 00:29:13
eso lo podemos hacer con un método aparte o el propio 00:29:14
constructor, si yo al constructor 00:29:17
le digo, oye, ¿qué vas a meter? un año 00:29:19
pues con cuatro posiciones tengo suficiente 00:29:21
lo que yo le pongo al 00:29:23
constructor es el número 00:29:25
de caracteres que le caben 00:29:26
venga, vamos a ponerle cuatro 00:29:29
a ver si así 00:29:31
nos gusta más 00:29:33
bueno 00:29:35
pues bueno, vale 00:29:37
ya es una interfaz con la que podemos hacer algo 00:29:39
vale 00:29:42
no es bonita 00:29:44
porque es un pedazo bicho 00:29:45
¿eh? 00:29:46
no, posiciones, caracteres 00:29:49
yo pongo 00:29:52
sí, sí, sí 00:29:52
porque se estira, me refiero a que son visibles 00:29:55
que se ven, o sea, el tamaño que se ve 00:29:58
pero si tú escribes, va a estar ahí 00:29:59
aunque no se vea, vale, o sea, es el tamaño 00:30:01
visible 00:30:03
o sea, caber ahora mismo 00:30:04
1, 2, 3 y 4 00:30:07
bueno, hace visibles 5 00:30:08
ah, bueno, de la 0 hasta 4 00:30:10
claro, si yo pongo 4, será de la 0 hasta 4 00:30:12
te hace visibles 5, ya más no te los hace 00:30:15
visibles, pero caber, caben, o sea, yo ahora mismo estoy metiendo 00:30:17
tropecientas L's, vale 00:30:19
vale, bueno, entonces cada 00:30:21
componente de estos luego tiene su mundo 00:30:25
que uno puede investigar y personalizar y probar 00:30:27
y todo eso, nosotros vamos a ver 00:30:29
el funcionamiento un poquito 00:30:31
para arrancar. Vale, pues 00:30:32
ala, esta aplicación está, pero es que 00:30:35
no me hace absolutamente nada. 00:30:37
Claro, porque no le 00:30:40
he asociado ningún evento. No me hace 00:30:41
nada. De hecho, 00:30:43
le faltaría un componente incluso. 00:30:47
Porque cuando esta aplicación 00:30:49
funcione y yo le dé al botón 00:30:51
es bisiesto, en algún 00:30:53
sitio me tendrá que aparecer 00:30:55
si no. 00:30:56
Si no es un texto que tiene que estar en algún sitio. 00:30:58
¿Dónde coloco yo ese texto? Podría 00:31:01
a colocarlo en una etiqueta. 00:31:03
Vale, una etiqueta. Pues entonces aquí me falta una etiqueta 00:31:05
que ahora mismo no tendrá nada. Pero que 00:31:07
cuando yo le dé a SBC esto, ya me dirá 00:31:09
sí, no, sí, no. 00:31:11
Pero ese texto que me 00:31:13
aparece tiene que estar en algún sitio. Todo lo 00:31:15
que está en la interfaz tiene que 00:31:17
estar en algún componente. 00:31:19
Vale, pues entonces por lo 00:31:21
menos una label en algún sitio, aunque 00:31:23
ahora mismo esté vacía, me 00:31:25
falta. Pues vamos a ponerle 00:31:27
un JLabel. Para verla 00:31:29
donde está, vamos a ponerle que ponga resultado 00:31:31
y luego ese resultado que se vaya cambiando, así no 00:31:32
pues vamos a 00:31:34
ponerle además aquí otra JLabel 00:31:37
con el resultado 00:31:39
de la 00:31:45
vale, yo puedo dejarla así 00:31:45
puedo dejarla así 00:31:55
bueno, tendría que añadirla al panel, claro que no se la he añadido 00:31:57
.app 00:32:00
result 00:32:11
vale 00:32:12
vale, la etiqueta 00:32:13
pensada para mostrar el resultado está 00:32:16
no olvidéis 00:32:18
ir parando los procesos 00:32:21
o andándola a este, porque si no 00:32:24
podéis tener ahí ciento y la madre 00:32:26
entonces ahora mismo 00:32:28
la etiqueta yo no la estoy viendo, pero está 00:32:30
no la estoy viendo porque no tiene un texto 00:32:32
si le hubiera cambiado el color, si le hubiera puesto otro color 00:32:33
le hubiera puesto un borde, la vería 00:32:36
imagino que esto tendrá 00:32:38
el label, tendrá algún método para ponerle 00:32:39
borde o algo 00:32:42
lo digo de cara a verla 00:32:43
set border 00:32:45
set background 00:32:48
me cambiará el color 00:32:50
Para ponerle fronteras 00:32:51
Le pongo un border 00:32:56
Pero el border hay que dárselo instanciado 00:32:59
Yo no sé si el borde básico sin instanciar 00:33:01
Se ve ya o no se ve 00:33:04
Vamos a probar a ver poniéndole un borde 00:33:06
A ver, aquí da igual 00:33:08
Que lo ponga antes o después 00:33:13
Porque 00:33:15
Vale 00:33:15
Vamos a importar 00:33:19
Vale, es que el constructor de border 00:33:30
Necesitará algo 00:33:33
Para decir cómo es el borde 00:33:34
Habría que ver cómo es 00:33:35
Pero es que no, que no perdamos el tiempo 00:33:37
A borde hay que pasarle 00:33:40
Ah, vale, hay que pintarlo 00:33:44
Con este método, hay que pintarlo con la clase 00:33:48
Graphics 00:33:50
Bueno, pues nada 00:33:51
Y background, no sé si lo va a poner un background 00:33:52
Es solamente para ver la etiqueta 00:33:55
Vamos a 00:33:57
Le ponemos un texto, le ponemos un texto y la vemos 00:33:58
Pero por 00:34:01
New color 00:34:03
No sé si me deja instanciarlo así 00:34:08
A ver si me la ponen azul 00:34:18
Pero me da a mí que no 00:34:27
Nada, el background ese no me la ponen 00:34:28
Vale, bueno, da igual 00:34:45
Ya la veremos cuando aparezca el texto 00:34:46
O si no, para ver que está, siempre podemos poner aquí 00:34:48
Resultado 00:34:51
Ahí está la etiqueta 00:34:54
el resultado lo pondré ahí 00:35:00
en mi caso 00:35:03
porque he añadido la etiqueta 00:35:05
después del text field y antes del botón 00:35:07
bueno, en cualquier caso 00:35:08
la aplicación ya está construida y está hecha 00:35:11
pero esto no vale para nada 00:35:13
ahora ya sí que una vez le hemos enseñado 00:35:14
al cliente, dice sí, vale, justo 00:35:16
esta es la interfaz que yo quiero, así es como quiero 00:35:18
pues ahora ya 00:35:20
nos ha aceptado el diseño 00:35:22
tenemos que hacer la captura de eventos 00:35:24
bueno, pues a ver 00:35:27
para hacer una captura de eventos 00:35:30
de nuevo 00:35:34
necesitamos que en la aplicación haya 00:35:35
un objeto 00:35:37
que sea capaz de ponerse 00:35:39
a la escucha de eventos 00:35:41
esa es la idea 00:35:43
esto de aquí 00:35:45
cada vez que yo hago esto 00:35:46
cada vez que yo doy aquí 00:35:48
cada vez que pulso 00:35:51
está ocurriendo un evento del cual 00:35:52
el proceso se está enterando 00:35:55
porque el JFrame 00:35:57
El JFrame tiene un montón de cosas dentro 00:35:59
Y el JFrame está hecho de tal manera 00:36:02
Que cada vez que yo le doy aquí 00:36:04
El programa se puede enterar 00:36:07
Entonces necesitamos un objeto 00:36:10
Necesitamos un objeto 00:36:13
Que se entere 00:36:15
Que se especialice en esto 00:36:17
Que se especialice en esto 00:36:21
Y meter dentro de él 00:36:22
El código que yo quiero 00:36:24
Que se haga como resultado de esto 00:36:26
Entonces, el proceso de captura de eventos es 00:36:29
hay que crear un objeto 00:36:32
que sea capaz de capturar el evento 00:36:34
y crear un objeto que sea capaz de capturar el evento 00:36:39
como declaramos una clase 00:36:42
que sea capaz de capturar un evento. 00:36:43
Nosotros no sabemos hacerla. 00:36:46
Afortunadamente ya hay clases 00:36:47
que son capaces de capturar eventos. 00:36:49
Entonces lo que tenemos es que instanciar 00:36:51
un objeto de esa clase 00:36:53
y esa clase personalizarla 00:36:54
para que el código que tenga dentro 00:36:57
haga lo que nosotros queremos. 00:36:59
A ver, escrito se va a entender mejor. 00:37:01
A ver, aquí el tema es, 00:37:04
necesitamos instanciar un objeto 00:37:06
que tenga dentro el código de respuesta a ese evento. 00:37:07
¿Ese objeto de qué clase será? 00:37:12
De una clase que habrá que hacer. 00:37:14
De una clase que habrá que hacer. 00:37:16
Entonces, aquí, 00:37:18
pues yo haré una clase, por ejemplo, 00:37:21
que la llamo como me dé la gana, 00:37:23
porque es una clase mía. 00:37:24
captura 00:37:25
pulsar botón 00:37:27
¿vale? 00:37:30
bueno, a ver, en todo caso 00:37:43
implementarla, heredar no, pero no puede ser heredar de dos 00:37:45
de JFrame tienes que heredar sí o sí 00:37:47
porque es un frame 00:37:49
lo que me estás diciendo es darle doble personalidad 00:37:49
que además de heredar, implemente de la otra 00:37:52
pero 00:37:54
vamos, espera 00:37:55
vamos por partes, hilos, sin liarnos 00:37:58
la clase ventana 00:38:01
tiene una única función, que es 00:38:02
es mi ventana, esa es mi ventana y se construye 00:38:04
ahora tendré otro objeto 00:38:08
otro objeto que tendrá otra función 00:38:10
que es capturar el evento, entonces voy a tener 00:38:13
en mi main, yo aquí tengo mi objeto ventana 00:38:16
cuya función es ser una ventana que aparece 00:38:19
y luego tendré otro objeto cuya función es otra 00:38:22
que es enterarse de que el evento ha ocurrido 00:38:25
y ejecutar el código 00:38:28
de respuesta, entonces me falta 00:38:31
hacer esa otra clase, la clase que es capaz 00:38:33
de enterarse de que el evento ha ocurrido 00:38:36
y ejecutar el código de respuesta 00:38:38
entonces esta es esa clase, esta clase tiene otra función 00:38:39
diferente a la ventana, la ventana es 00:38:41
una ventanita con sus cosas 00:38:43
y ahora tengo mi otra clase, esta otra 00:38:45
clase es la clase que es 00:38:47
capaz de enterarse de que yo he pulsado 00:38:49
y dentro de ella 00:38:51
aquí dentro 00:38:53
habrá que meter el código de respuesta 00:38:54
vale, meter el código de respuesta 00:38:57
es muy fácil, me pongo yo ahí lo que quiero 00:39:00
que pase como respuesta a pulsar 00:39:02
meter el código de respuesta es escribir las líneas 00:39:03
pero ¿cómo la hago capaz 00:39:06
de enterarse de que he pulsado un botón? 00:39:08
eso es complicadísimo, ¿cómo programo 00:39:10
yo que esta pille 00:39:12
lo que se ha activado dentro en el 00:39:13
hardware que yo he pulsado el botón 00:39:16
en el ratón? 00:39:18
yo no puedo programar eso 00:39:19
claro, es que afortunadamente ya está hecho 00:39:21
en una clase que se llama 00:39:23
ActionListener, la clase ActionListener 00:39:25
tiene todo eso 00:39:28
capaz de enterarse de que yo he dado al ratón 00:39:29
que me ha llegado la señal por los buses 00:39:32
de señalización de la placa 00:39:34
esa clase ya existe 00:39:36
entonces lo único que tengo que hacer yo 00:39:37
es una interfaz, perdón 00:39:39
lo único que tengo que hacer yo es implementar 00:39:40
de ActionListener 00:39:43
entonces si yo implemento de ActionListener 00:39:45
implemento de ella 00:39:51
esta clase mía, toda esa parte 00:39:52
de ser capaz de enterarse 00:39:55
de que han pasado cosas 00:39:57
vía teclado, vía ratón, ya la tiene 00:39:58
ya la tiene, no tiene que hacer nada 00:40:00
ya es capaz de enterarse 00:40:03
por el simple hecho de implementar ActionListener 00:40:04
ya ha cogido esa personalidad 00:40:07
ser clase capturadora 00:40:08
tendremos que importar ActionListener 00:40:11
claro que como veis 00:40:13
también está en 00:40:14
JavaWT 00:40:16
en concreto en el paquete de eventos 00:40:18
ala, esta clase ya está 00:40:22
¿qué ocurre cuando implementamos una interfaz? 00:40:24
que estamos obligados 00:40:28
a sobreescribir todos los métodos 00:40:29
vacíos 00:40:32
de esa interfaz. Es lo que me está 00:40:33
diciendo el compilador. Me dice, oye, 00:40:35
tú implementas Action Listener 00:40:38
estupendo. Te conviertes en una clase capaz 00:40:39
de escuchar del teclado del ratón de donde 00:40:41
te dé la gana. Pero tienes 00:40:43
que implementar los métodos vacíos. 00:40:45
¿Y cuáles son esos 00:40:48
métodos vacíos? 00:40:49
Pues este. Este de aquí. 00:40:51
Este 00:40:56
método es el método vacío 00:40:57
de Action Listener que tenemos que implementar. 00:40:59
y justo 00:41:01
casualmente en este método 00:41:03
es en el que tiene que estar 00:41:05
el código de respuesta al evento 00:41:07
que yo quiero capturar 00:41:09
¿vale? entonces para ver primero 00:41:10
que funciona 00:41:13
lo que yo quiero como código de respuesta 00:41:14
será 00:41:17
al evento del botón 00:41:18
coger el texto 00:41:20
hacer el cálculo de bisiesto 00:41:22
y ahora ya poner en la etiqueta 00:41:25
es bisiesto o no, todo eso es lo que querré hacer ahí dentro 00:41:27
pero antes de hacer eso 00:41:29
vamos a probarlo 00:41:31
viendo que funcione y que realmente captura el evento 00:41:32
poniendo un mensajito por consola sin más 00:41:35
para que veamos en la consola 00:41:37
esto 00:41:38
pulsaste botón 00:41:40
vale, pues ya tenemos 00:41:43
una clase que por el hecho 00:41:47
de implementar ActionListener es capaz 00:41:49
ya de enterarse de que han pasado cosas 00:41:51
en el teclado y en el ratón, es capaz de enterarse 00:41:53
y además tiene 00:41:55
sobre escrito un método 00:41:57
dentro del cual 00:41:58
tiene el código que va a ocurrir 00:42:00
cuando eso pase, eso es lo que va a ocurrir 00:42:02
¿con eso hemos terminado? 00:42:04
pues no, porque ahora 00:42:08
hay que crear ese objeto 00:42:10
yo he declarado la clase 00:42:12
pero no lo he creado, entonces este objeto no existe 00:42:14
¿no? 00:42:16
vale, pues entonces 00:42:19
en el constructor 00:42:20
que es en el que se hace todo lo del frame 00:42:21
una vez que he creado 00:42:23
el aspecto 00:42:26
que mi aspecto es este, una vez que lo he creado 00:42:27
y he terminado y ya está aquí, 00:42:29
ahora tendré que instanciar las clases 00:42:31
capturadoras, 00:42:34
las que solemos llamar capturadoras, 00:42:36
las que son capaces de enterarse de los eventos. 00:42:37
Pues venga, vamos a instanciarla. 00:42:40
Captura, 00:42:43
pulsar botón, la he llamado. 00:42:44
Tendrá un constructor por defecto, como no 00:42:59
le he puesto, tendrá un constructor. Venga, la instancio, 00:43:01
captura, pulsar botón, ala. 00:43:03
La importamos de 00:43:06
donde sea, ya está instanciada. 00:43:07
Y con esto hemos terminado, 00:43:09
no, nos falta el último paso, ya sí que es el último 00:43:11
el objeto está 00:43:13
pero oye, tenemos que decirle 00:43:14
cuidado 00:43:17
tienes que 00:43:17
especializarte en este componente 00:43:20
o sea, un objeto 00:43:23
capturador como estos 00:43:25
no puede estar a todo 00:43:26
un objeto capturador 00:43:28
hay que decirle tú estate atento aquí 00:43:31
entonces 00:43:33
¿a qué tiene que estar atento? 00:43:35
pues tiene que estar atento 00:43:38
a este botón. 00:43:40
Yo quiero que esa clase 00:43:45
capturadora se despierte 00:43:47
cuando le doy a este. 00:43:48
Quiero que se despierte cuando le doy a este. No quiero que se despierte 00:43:51
cuando navego con mi ratoncito por aquí, 00:43:53
ni quiero que se despierte cuando meto 00:43:55
aquí datos, ni quiero que se despierte 00:43:57
cuando redimensiono esto, no quiero que 00:43:59
se despierte con cualquiera de esas cosas. 00:44:01
Quiero que se despierte cuando 00:44:03
le doy al botón. 00:44:05
Luego, las clases capturadoras 00:44:07
hay que decirles tú, 00:44:09
especialízate en este componente 00:44:10
e ignora todo lo demás 00:44:13
porque si no se despertaría cuando 00:44:14
para cualquier cosa 00:44:16
¿vale? pues entonces 00:44:18
¿cómo le decimos tú 00:44:21
clase capturadora 00:44:23
especialízate en este botoncito 00:44:24
pues al botón le decimos 00:44:26
add action listener 00:44:29
y le damos ese objeto 00:44:30
y ya está 00:44:32
entonces el botoncito aparte de construirlo 00:44:33
y añadirlo al panel 00:44:39
el botón tiene algo más que el resto 00:44:41
el botón tiene un objeto 00:44:43
que está ahí pendiente de él siguiéndole todo el rato 00:44:45
que es este que acabo de crear antes 00:44:47
el resto de componentes 00:44:49
no tienen ningún objeto 00:44:52
ahí siguiéndoles 00:44:53
porque el resto de componentes yo me da igual 00:44:54
hacer click sobre ellos, hacer lo que me dé la gana 00:44:57
me da igual, no tienen ningún componente 00:44:59
siguiéndoles, pero el botón sí 00:45:01
el botón sí que tiene un componente siguiéndoles 00:45:02
porque cuando yo den él, quiero que salte 00:45:05
la clase, pues ahora ya sí 00:45:07
El botón tiene un capturador 00:45:09
Siguiendoles, tiene un capturador 00:45:12
A través de este método 00:45:14
Y este capturador yo lo he instanciado 00:45:16
Y es este 00:45:18
Entonces ahora ya sí que 00:45:18
Cuando 00:45:22
Vale, cuando 00:45:25
Yo lanzo mi aplicación 00:45:37
Aquí está, no pasa nada 00:45:41
Ahí está 00:45:44
Vale, no pasa nada 00:45:45
Y ahora doy a SBC esto 00:45:48
Y paz, efectivamente 00:45:50
la clase, el objeto 00:45:52
ha capturado el evento 00:45:54
lo ha capturado porque me ha aparecido esto 00:45:55
que le vuelvo a dar 00:45:57
otra vez 00:46:00
que le vuelvo a dar, que le vuelvo a dar, que le vuelvo a dar 00:46:01
claro, porque ya está, hay un objeto 00:46:03
que está ahí pendiente de este todo el rato 00:46:06
está todo el rato pendiente 00:46:08
y no está pendiente de los demás, yo puedo pulsar 00:46:09
en cualquier otro sitio y no pasa nada 00:46:12
porque ese objeto no está pendiente de los demás 00:46:13
ese objeto está solo pendiente del botón 00:46:15
y está pendiente del botón 00:46:17
y solo del botón 00:46:20
porque yo le he dicho 00:46:21
botón, añádete 00:46:24
a ese 00:46:26
pendiente de ti 00:46:28
añádetelo 00:46:29
a este 00:46:31
bueno, pues esta es la 00:46:33
filosofía de construcción de una interfaz 00:46:37
lo más 00:46:40
el esqueleto básico 00:46:40
¿qué es eso? yo tengo que instanciar un frame 00:46:43
tengo que instanciar un frame en algún momento 00:46:46
a través de un constructor 00:46:48
como siempre, pues el constructor 00:46:50
es el que tiene que construirlo y hacerlo todo 00:46:52
porque fuera del 00:46:54
constructor lo único que he hecho yo 00:46:56
ya es darle tamaño y hacerlo visible 00:46:58
que ni siquiera tendría 00:47:00
por qué hacerlo fuera, podría aquí mismo 00:47:02
al final hacer un 00:47:04
this.setSize 00:47:06
y this.setVisible, me da igual 00:47:08
pero bueno 00:47:10
lo dejamos así, vale, entonces el constructor 00:47:11
ya hace todo lo que yo tenga que hacer 00:47:14
que es añadir los componentes 00:47:16
al panel, personalizar 00:47:18
los componentes si yo quiero 00:47:20
y si algún componente tiene que tener 00:47:21
alguien ahí pendiente, porque al 00:47:24
interaccionar con él quiero que pasen cosas 00:47:26
pues a ese componente 00:47:28
le tendré que añadir lo que se 00:47:29
llama un listener, un escuchador, un listener 00:47:32
y ese escuchador lo tendré 00:47:34
que instanciar antes de añadírselo 00:47:36
y ese escuchador 00:47:38
que yo instancio tendrá que ser 00:47:40
heredero de ActionListener 00:47:42
porque si no lo es, no tiene la capacidad 00:47:44
de escuchar, y además de ser 00:47:46
heredero de ActionListener, yo pondré aquí 00:47:49
lo que quiero que ocurra 00:47:51
vale, paramos unos segundos 00:47:52
y ahora, claro, lo que tenemos es que completarlo 00:47:55
porque esto, yo no quería 00:47:58
que después de hacer esbis y esto 00:47:59
me saliera a pulsar este botón 00:48:01
yo lo que quería es que me cogiera lo que yo pongo aquí 00:48:03
y me pusiera el resultado 00:48:06
entonces no nos vale este evento 00:48:08
claro, hay que hacer ya el bueno 00:48:10
vale, vamos a parar unos 00:48:11
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
21 de abril de 2024 - 19:04
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
48′ 15″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
225.99 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid