Saltar navegación

20250304 GUI_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 8 de marzo de 2025 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

comportamiento de este frame 00:00:00
dígame 00:00:01
si esto era para 00:00:02
enfrentarnos a la experiencia de colocarlo 00:00:06
a mano, darnos cuenta de que es 00:00:08
muy complicado 00:00:10
y decir, mejor vamos a ver si 00:00:11
a ver, no seas tan literales 00:00:14
de verdad 00:00:21
he dicho 20.000 veces 00:00:23
¿qué es lo que hemos querido ver con esto? 00:00:26
pues que nos enfrentemos a 00:00:28
que se puede colocar a mano 00:00:29
que tiene su complejidad 00:00:31
entonces como tiene su complejidad 00:00:33
aunque unos cuantos chavales de prácticas 00:00:34
en una empresa o tesis 00:00:38
se han pasado meses y meses 00:00:39
donde su trabajo es 00:00:42
medir la pantalla para 00:00:43
sacar las ubicaciones perfectas 00:00:45
hasta no hace mucho 00:00:47
no lo sé pero les podríamos preguntar 00:00:49
porque era lo que hacían a mano 00:00:52
directamente para que quedara ahí colocado 00:00:53
eso no tiene gracia 00:00:55
Ya, ya, por eso se quejaban un poco 00:00:58
Decían que estaba haciendo un trabajo un poco tonto 00:01:01
Y poco práctico 00:01:03
No sé cómo lo harían, pero bueno 00:01:04
Sí, no sé cómo lo harían 00:01:13
Pero bueno, dedicaron mucho tiempo 00:01:17
A algo tan como eso 00:01:19
Vale, a ver, pues vamos a darle comportamiento 00:01:20
Bueno, pues ¿en qué se basa? 00:01:23
La aplicación está arrancada 00:01:25
Y el programa está ahí, ¿vale? El programa está ahí, esperando. Hay un hilo y lanzado. Y ahora yo le doy a las cosas y no pasa nada, lógicamente. Vale, pues para que pase algo, ¿qué tiene que ocurrir? 00:01:27
para que pase algo 00:01:42
tiene que ocurrir 00:01:45
que tiene que aparecer otro objeto 00:01:46
ese otro objeto 00:01:48
tiene que ser capaz 00:01:50
de estar pendiente 00:01:52
de estar escuchando 00:01:54
que pasen estas cosas 00:01:56
y ese objeto 00:01:58
que será capaz de estar pendiente 00:02:01
de que pasen estas cosas 00:02:04
tendrá dentro el código de la respuesta 00:02:05
luego tenemos 00:02:08
que instanciar un objeto 00:02:10
que se llama en general 00:02:12
como traducción rara, un objeto 00:02:13
escuchador. ¿Por qué es objeto 00:02:15
escuchador? ¿Qué va a estar ahí 00:02:17
todo el rato? Pues cruzado de brazos, 00:02:19
viendo a ver, ¡ostras! ¿Qué han pulsado? 00:02:21
¡Pum! Me despierto 00:02:23
y ejecuto 00:02:25
el código que tengo dentro. 00:02:27
¿Vale? Entonces, objetos escuchadores 00:02:29
yo puedo instanciar 00:02:31
muchos, tantos como eventos 00:02:33
distintos haya. Aquí, por ejemplo, tengo 00:02:35
dos eventos. El evento 00:02:37
darle aquí, pues un objeto 00:02:39
escuchador de este evento. Cuando detecte 00:02:41
que esto ocurre, salta, 00:02:43
se despierta y ejecuta 00:02:46
el código que tiene dentro. 00:02:47
El evento darle a despedir, 00:02:50
que es otro evento. Pues 00:02:51
un objeto escuchador que yo tendré que 00:02:53
haber instanciado, se ha quedado ahí 00:02:55
esperando desde el momento en que lo instancié 00:02:57
y como él está escuchando, enganchado a ese 00:02:59
evento, cuando vea que ese evento ha ocurrido, 00:03:01
pum, se despierta y ejecuta el 00:03:03
código que tiene dentro. ¿Vale? 00:03:05
Eso es lo que nos hace falta. 00:03:07
Crear, instanciar esos objetos 00:03:09
que tienen la propiedad de ser 00:03:11
escuchadores y meterles 00:03:13
dentro el código con el que queremos 00:03:15
que respondan cuando se despierten. 00:03:17
Luego, 00:03:21
un objeto que 00:03:22
tenga la capacidad de hacer algo, 00:03:23
eso 00:03:27
en nuestro lenguaje significa 00:03:27
un objeto que implemente una interfaz. 00:03:29
¿Verdad? 00:03:32
Entonces, la capacidad de escuchar un evento, 00:03:33
yo no puedo programarla, es muy complicado. 00:03:35
Pero ya hay una interfaz que 00:03:37
tiene ese comportamiento. ¿Qué es la 00:03:39
interfaz, ActionListener. 00:03:41
Pues yo lo único que tengo que 00:03:44
hacer es crear un objeto 00:03:45
que implemente esa interfaz 00:03:47
para que incorpore ese comportamiento 00:03:49
de ser capaz de escuchar 00:03:51
y luego ya ponerle dentro, 00:03:53
personalizarle con el código 00:03:55
de respuesta que yo quiero. 00:03:57
Sí, pero 00:04:04
¿cómo? El método de respuesta, 00:04:04
pero todo el código necesario para 00:04:06
engancharlo al hilo 00:04:08
que detecte que tú has llegado con todo y has dado 00:04:10
ahí, todo eso, ¿cómo lo programas? 00:04:12
Eso ya lo tiene en la acción 00:04:13
Eso no es tan fácil 00:04:15
Hombre claro 00:04:16
Por supuesto que se puede programar desde cero 00:04:19
Claro que se puede 00:04:21
Programame desde cero 00:04:24
Detectar 00:04:26
Un evento de pantalla 00:04:27
Con tu dedito con el ratón 00:04:29
Vale pues entonces 00:04:30
Vamos a hacer 00:04:35
Esa clase 00:04:37
Pues venga 00:04:38
Nos hacemos esa clase 00:04:40
venga 00:04:43
escucha 00:04:44
a saludar 00:04:47
tú vas a ser 00:04:49
el objeto 00:04:52
tú vas a ser el objeto que vas a estar ahí pendiente 00:04:54
del evento 00:04:57
de darle al botón de saludar 00:04:58
entonces 00:05:01
como tienes que tener 00:05:03
esa capacidad de estar a la escucha 00:05:08
de que alguien le dé a un botoncito, 00:05:11
pues implementas 00:05:14
ActionListener. 00:05:15
ActionListener, tendremos que importarlo 00:05:17
de Java 00:05:19
a WT Event. 00:05:21
Así. 00:05:26
Vale. 00:05:28
Ahora, 00:05:29
como escucha 00:05:30
saludar e implementa esta interfaz, 00:05:32
tiene que darle 00:05:34
código al método que esta 00:05:35
interfaz tiene vacío. Lógicamente 00:05:38
Esta interfaz tiene hecha toda la parte de ser capaz de engancharse a la pantalla, 00:05:40
a los eventos, pero el código concreto no lo tiene. 00:05:44
Ese código lo tenemos que meter en un método que en ActionEaser está vacío. 00:05:47
¿Ese método cómo se llama? 00:05:51
Ese método se llama ActionPerformance, como no podía ser de otra manera, 00:05:54
que es acción que vas a realizar cuando yo me despierte. 00:05:59
¿Qué acción vas a realizar? 00:06:03
Vale. 00:06:07
Pues, ¿qué acción vas a realizar? 00:06:08
aquí tenemos un problema 00:06:09
gordo, gordísimo 00:06:12
que la acción que queremos 00:06:13
realizar 00:06:16
¿qué? 00:06:17
no entiendo nada 00:06:21
tenemos un problema muy gordo 00:06:22
y es que la acción que queremos 00:06:28
realizar implica 00:06:30
tocar 00:06:32
cambiar el texto 00:06:33
de una variable 00:06:35
que está aquí local 00:06:38
que complicado 00:06:40
por ahora vamos a hacerlo 00:06:43
más fácil, vamos a hacer una primera versión 00:06:46
que es que la respuesta 00:06:47
sea mostrar por consola 00:06:49
y así no tengo que tocar nada 00:06:51
para ver que realmente el escuchador 00:06:53
se salta, se despierte y responde 00:06:55
y luego ya vemos como solucionamos 00:06:58
el problema de que será 00:06:59
un tema de paso de parámetros 00:07:01
al fin y al cabo es un tema de paso de parámetros 00:07:03
vale, pues entonces vamos a hacer 00:07:05
la versión sencilla 00:07:08
hala 00:07:11
no, porque como pongan lo que tengo ganas de poner 00:07:16
no, hola 00:07:25
me has quitado el apetito 00:07:29
para toda la vida 00:07:35
bueno, venga 00:07:35
se va a cagar 00:07:38
Mira, déjale 00:07:41
Pobrecito 00:07:47
Vale, el objeto está 00:07:48
Que le van a envenenar entre todos 00:07:52
Es verdad 00:07:58
Hasta los que creía 00:08:04
Que estaban a su favor, nada 00:08:06
Venga, pues entonces 00:08:08
el objeto está, pues vámonos 00:08:10
ya a mi main, o sea mi main no 00:08:13
a donde estaba ya construida la interfaz 00:08:14
y oye tú, botón saluda 00:08:16
primero, ¿qué vamos a hacer? crear el objeto 00:08:18
que escucha, escucha 00:08:20
saludar 00:08:23
ya tenemos ese objeto 00:08:25
capaz de escuchar 00:08:30
new, escucha 00:08:32
saludar 00:08:34
ahí, ya lo tenemos 00:08:37
este objeto ya está 00:08:39
ya es capaz de estar 00:08:41
escuchando eventos 00:08:42
eventos 00:08:44
¿pero qué evento? 00:08:45
¿a quién escucha saludar? 00:08:48
si miráis esta clase que hemos hecho 00:08:50
en ningún sitio hemos puesto 00:08:51
que el evento al que reaccione 00:08:53
sea al de hacer clic al botón 00:08:55
en ningún momento lo hemos puesto 00:08:58
aquí hemos puesto un evento 00:09:00
que cuando se despierte 00:09:02
reaccionará con este código 00:09:04
es lo que hemos hecho 00:09:06
evento que cuando se despierte reaccionará con este código 00:09:07
vale, pues evento ya está aquí creado 00:09:10
pero ahora hay que asociarlo 00:09:13
al componente 00:09:14
al que queremos que esté asociado 00:09:16
¿a quién queremos que esté asociado? 00:09:19
a Saluda 00:09:21
vale, pues Saluda, el componente tiene un método 00:09:21
y todos los componentes tienen un método 00:09:25
que es el AddActionListener 00:09:27
donde tú le pasas ese objeto 00:09:28
y ya está, tema resuelto 00:09:31
tema resuelto 00:09:34
Vale, nosotros hemos hecho primero, hemos instanciado un objeto, un objeto que tiene la capacidad de estar ahí pendiente de que pasen cosas en la interfaz, pendiente, esa capacidad la tiene porque implemente acción listener y además cuando se despierte porque ha pasado algo, reaccionará con este código, porque es el que hemos metido ahí. 00:09:40
claro, pero ahora nos falta 00:10:04
una cosa, este objeto genérico 00:10:06
que yo he instanciado, que es capaz de escuchar 00:10:08
y de responder con un código 00:10:10
tengo que decir, si ya, pero a qué componente 00:10:12
te engancho 00:10:14
a qué componente te engancho 00:10:15
pues al botón 00:10:17
al saluda 00:10:19
te engancho al botón saluda, porque si no 00:10:21
él no sabe a quién escuchar, a los eventos 00:10:23
del botón este, a los eventos de este, a quién escucho 00:10:25
yo, escucha los eventos 00:10:28
del botón saluda 00:10:30
¿y si le pasa al mismo al del botón de escuche? 00:10:31
Pues cualquiera de los dos, 00:10:34
desde el momento que haga clic, haría lo mismo. 00:10:36
¿Vale? O sea, no hace falta 00:10:39
que cada componente tenga un... 00:10:39
¿Cómo hace el saludo? 00:10:41
Dependiendo de cuál le da, 00:10:44
si a despedir o saludar. Ahora lo hacemos. 00:10:45
¿Vale? Entonces vamos a ver, 00:10:48
añadiendo solo el saluda, hemos visto 00:10:50
que esto lo hace, ¿verdad? Yo le doy a saludar 00:10:51
y me sale aquí hola. 00:10:53
Ahora, pero quiero que también 00:10:58
me responda cuando yo le doy a despide. 00:10:59
Pues venga, también le añado 00:11:03
este ActionListener 00:11:05
a despide. 00:11:06
Vale. 00:11:11
Entonces, para que me, ahora lógicamente 00:11:12
me va a, con los dos 00:11:14
me hace lo mismo. 00:11:18
Pues claro, no. Yo quería cosas diferentes. 00:11:20
Sí, pero hemos dicho que, claro, 00:11:26
pero hemos dicho, si hubieras estado conectado. 00:11:28
No. 00:11:31
Claro, has escuchado que 00:11:33
para que lo muestre la propia 00:11:34
interfaz, desde aquí dentro, 00:11:36
desde este método local, tendríamos 00:11:38
que acceder a esta 00:11:40
JLabel que está aquí perdida 00:11:42
un método, entonces 00:11:45
¿cómo accedo yo a esta JLabel que es 00:11:48
una variable local de aquí? 00:11:50
Es un problema trivial de resolver. 00:11:52
¿Vale? De hecho hay muchas alternativas 00:11:54
para resolverlo. Entonces 00:11:56
lo dejamos aparcadito hasta el próximo 00:11:58
día y vamos a 00:12:00
hacer la opción fácil que es que me lo muestre por 00:12:02
consola. ¿Vale? 00:12:04
Entonces, ahora 00:12:06
si yo le pongo el mismo 00:12:08
escuchador a los dos, efectivamente 00:12:10
con los dos hace lo mismo 00:12:11
siempre tendríamos la opción fácil 00:12:13
que es hacer un action listener para cada uno 00:12:15
escucha, saluda, escucha, despide 00:12:17
escucha, que es lo que se hace 00:12:19
normalmente 00:12:21
¿vale? que es lo que se hace normalmente, aunque no como 00:12:22
clase aparte, sino como clase anónima, etc 00:12:25
que eso es lo que tenemos que ver 00:12:27
el escuchador le puede poner cualquier línea de código para que haga 00:12:29
claro 00:12:31
claro 00:12:31
tú te haces todas las escuchadoras que quieras 00:12:35
y en cada una el código que tú quieras 00:12:38
y cada clase escuchadora lo asocias a un componente 00:12:39
distinto y tienes el problema resuelto 00:12:42
que somos vagos 00:12:44
en este ejemplo concreto 00:12:45
y queremos usar el mismo para los dos 00:12:47
bueno, aún así 00:12:50
podemos salir de esta situación 00:12:52
porque justo 00:12:54
¿quién te llama? pues este 00:12:56
esto es como lo de la excepción, cuando se 00:12:57
crea la excepción 00:13:00
se instancia un objeto, pues cuando 00:13:00
se hace el evento 00:13:03
ha aparecido este objeto escucha saludar 00:13:04
Ha aparecido. 00:13:07
Es como si se hubiera hecho un throw 00:13:08
de este escucha-saludar. 00:13:10
Ha aparecido. 00:13:12
Y dentro de este objetito E 00:13:13
se mete toda la información del evento. 00:13:15
Entre ellas, el objeto que lo causó. 00:13:18
Entonces, nosotros, si somos así más, 00:13:21
pues podríamos decir, 00:13:23
oye, vamos a hacer 00:13:24
if E.getSource, 00:13:25
que es el objeto. 00:13:31
GetSource es el objeto que lo creó. 00:13:33
¿Te devuelve el nombre del objeto? 00:13:34
No, te devuelve el objeto. 00:13:36
resulta que es una 00:13:37
no, va a ser una instancia Jbuton seguro 00:13:39
GetSource 00:13:42
va a ser un Jbuton 00:13:43
saco el texto del Jbuton 00:13:45
porque para eso tiene un GetTest 00:13:48
pero como GetSource me duele como hoy 00:13:50
le hago el casting 00:13:51
si el 00:13:52
esto 00:13:54
todo esto se lo decís a Ana 00:13:55
que si lo he metido ahora es porque ella ha preguntado 00:13:58
así que 00:14:00
reclamaciones a ella 00:14:02
claro 00:14:04
vale 00:14:06
entonces este tiene 00:14:07
get source 00:14:11
jbutton 00:14:12
get source y ahora 00:14:18
un get test 00:14:19
no pero yo creo que no me 00:14:22
donde me falta el paréntesis 00:14:25
jbutton es para el casting de get source 00:14:29
ahora este me cierra este 00:14:35
y ahora me debería hacer el get test 00:14:37
espérate que es que igual está atascado 00:14:41
por el 00:14:48
si igual es que se me ha atascado ya el compilador 00:14:49
por el 00:14:52
no importa, bueno y ya está 00:14:53
javax 00:14:55
swing 00:14:58
vale 00:15:03
time misman no puedo convertir 00:15:09
de string a boolean 00:15:13
Ah, han hecho el equals 00:15:14
Vale 00:15:16
Si el texto que salgo del botón 00:15:18
Equals 00:15:21
¿Cómo era el texto del botón? 00:15:22
Saludar y despedir 00:15:28
Ahora 00:15:29
¿Vale? 00:15:39
Pues entonces 00:15:41
Me cojo el objeto del action event 00:15:42
Como sé que es un jbutton 00:15:44
Seguro le hago el casting sin miedo a jbutton 00:15:46
Me saco con el método gettest 00:15:48
El texto que tiene el botón 00:15:50
pues si es igual a saludar hola 00:15:52
y si no es que será el otro 00:15:54
porque solo tengo asociados los dos 00:15:56
no lo sé 00:15:58
vale 00:16:02
bueno pues efectivamente 00:16:05
podríamos en el mismo 00:16:08
action listener distinguir 00:16:10
que objeto es el que despertó 00:16:12
el evento 00:16:14
si el action listener está asociado a varios 00:16:15
no sabemos quien lo despertó 00:16:18
pues lo podríamos sacar de aquí 00:16:20
con el método getSource 00:16:21
pues me dice que objeto lo despertó y ya está 00:16:23
y ahora este ya sí que sí 00:16:25
pues en función de quién 00:16:27
pues os saluda 00:16:29
o se despide o lo que sea 00:16:35
y ya está 00:16:36
¿y cuáles? 00:16:39
no, no es la de la acción 00:16:44
pero ha puesto después 00:16:46
porque getTest me saca el texto que hay en el botón 00:16:48
bueno pues entonces 00:16:56
conclusión 00:17:03
hemos hecho una arquitectura 00:17:04
desde el principio 00:17:06
desmenuzándolo todo 00:17:06
para ver que es cada cosa 00:17:08
luego todo eso 00:17:09
se programa mogollón 00:17:10
en la misma clase 00:17:11
con clases anónimas 00:17:12
que ya lo haremos 00:17:13
el próximo día 00:17:14
para allá es para donde 00:17:17
para acá 00:17:18
vale entonces 00:17:19
esta arquitectura 00:17:22
no se hace con tantas clases 00:17:23
se hace toda en la misma 00:17:24
metiendo unas clases 00:17:25
dentro de otras 00:17:26
como clases internas 00:17:27
ya lo vamos haciendo 00:17:28
el próximo día, eso por un lado 00:17:29
y por otro lado 00:17:31
hemos hecho la versión patatera 00:17:34
que me muestra en consola 00:17:36
porque no me es tan fácil acceder 00:17:38
a la etiqueta que está en el método local 00:17:40
de no sé dónde para cambiar el texto 00:17:42
no me es tan fácil 00:17:43
¿qué hacemos? pues la tendremos que pasar como parámetro 00:17:44
pero ¿cómo? a la acción performance no puedo 00:17:47
porque le cambié la cabecera 00:17:49
¿qué hacemos? etc 00:17:50
pues nada, lo solucionamos el jueves 00:17:52
Pero tendría que 00:17:56
No te entiendo 00:18:08
Ah, vale 00:18:11
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
11
Fecha:
8 de marzo de 2025 - 19:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
18′ 18″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
80.61 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid