Saltar navegación

20250311 GUI_Ejer2_ArranqueAhorcado - 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 17 de marzo de 2025 por Raquel G.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, nos vamos a la pestaña diseño, que mal se me ve aquí todo, así mejor, vale, y ahora ya, vamos a trabajar solamente con un panel, el panel por defecto, pues este mismo, botón para arrancar el juego, pues venga, nos vamos a componentes, botón para arrancar, bueno, primero que no se nos olvide en el panel ponerle como gestor de ubicación absoluto. 00:00:03
si tú quieres colocar 00:00:31
los componentes donde te dé la gana 00:00:35
y darles el tamaño que tú quieras, sí 00:00:37
porque si pones otro gestor de ubicación 00:00:38
imagínate que pones el de grid 00:00:40
te va a obligar 00:00:42
a colocarlos en una 00:00:44
posición de rejilla, no te va a dejar en cualquier 00:00:47
sitio, ves 00:00:49
te obliga aquí porque es la primera posición de la rejilla 00:00:49
entonces tú no quieres ahí 00:00:53
entonces, absoluto 00:00:54
vale, pues entonces 00:00:57
como ya lo tenemos absoluto, queremos colocarlo a mano 00:00:59
venga, botoncito de jugar, pues el botoncito 00:01:01
de jugar 00:01:03
en medio 00:01:03
vale 00:01:05
el nombre de variable que le ha dado es feísimo 00:01:09
como veis a la izquierda 00:01:13
le ha dado como nombre de variable 00:01:14
btn new button, no nos gusta nada 00:01:16
vamos a cambiárselo a 00:01:18
botón jugar, por ejemplo 00:01:20
y el texto que ha puesto arriba 00:01:22
por defecto tampoco nos gusta 00:01:27
pues vamos a cambiárselo aquí en propiedades 00:01:28
a jugar 00:01:31
bueno, pues este es el botón de jugar 00:01:33
que no nos gusta el tipo de letra 00:01:39
no nos gusta el borde 00:01:41
pues se lo cambiaríamos 00:01:42
vale 00:01:45
¿qué más tiene que tener esto? 00:01:47
pues cuando se dé a jugar, cambiará jugando 00:01:51
ahí no aparecerá, pero nos tiene que dar 00:01:53
la opción de meter el número 00:01:55
para adivinarlo, pues el número para 00:01:57
adivinarlo en un área de texto 00:01:59
Pues venga, en un área de texto, el número para adivinar 00:02:00
Entonces vamos a ponerle una etiqueta para que sepa que ahí tiene que meter el número 00:02:10
Y a esta etiqueta le ponemos el texto 00:02:14
Introduzca número 00:02:19
Introduzca número 00:02:26
A ver, se me ha colado una 00:02:36
No me deja ir a la derecha para cambiar eso 00:02:43
Ahí, introduzcan 00:02:56
Vale, ya está 00:02:58
Entonces el usuario irá metiendo numeritos aquí 00:03:02
Cuando acierte 00:03:07
De alguna manera le tienen que avisar 00:03:09
Entonces, en principio 00:03:11
Con lo que hemos visto, pues pondríamos una etiqueta 00:03:13
Para que avisara, has acertado 00:03:16
Pero en lugar de con una etiqueta 00:03:17
Lo vamos a hacer con 00:03:19
Con una ventanita emergente 00:03:20
Que quede más bonito, has terminado 00:03:23
Entonces no ponemos la etiqueta 00:03:25
¿cómo haremos la ventana emergente? 00:03:27
pues la ventana emergente no es un componente 00:03:29
que se meta aquí, porque la ventana emergente 00:03:31
es algo que se va a abrir 00:03:33
solamente en un momento concreto 00:03:34
¿es más fácil que esa parte? 00:03:36
no, es más fácil que eso 00:03:39
la posibilidad de abrir una, no, porque 00:03:40
si es otro JFrame estaría 00:03:43
o sea, la aplicación tiene un único 00:03:45
JFrame y a ese se asocia todo lo demás 00:03:47
entonces, se le puede asociar una ventana 00:03:49
emergente, no todas las ventanas tienen que ser 00:03:51
frame, pueden estar, puede ser 00:03:53
un jdialog, un j no sé qué, que están asociados 00:03:55
a ese frame, pero lo que pasa es que 00:03:57
nosotros queremos que aparezca 00:03:59
solo en un momento concreto 00:04:01
que es cuando ha acertado 00:04:03
cuando se verifica que ha acertado 00:04:05
se podría poner una ventana que esté siempre ahí 00:04:06
se haga visible y no, pero 00:04:11
hay una forma sencilla de hacerlo, que es 00:04:12
en el momento en el que se verifique la condición 00:04:14
de acierto, se instancia la 00:04:17
ventana y ya está 00:04:19
entonces como lo vamos a hacer así, que es más sencillo 00:04:20
pues aquí ya no hay más componentes que poner 00:04:23
¿Vale? Entonces como no hay más componentes que poner 00:04:25
Pues se ha quedado así solamente 00:04:28
Jugar, se pondrá jugando 00:04:30
Introduzca número, enter, enter, enter 00:04:31
Y nos irá diciendo 00:04:34
Si no, si no 00:04:36
Y cuando se ha acertado, pues avisa 00:04:37
¡Hala! Como ya no vamos a poner más en la interfaz gráfica 00:04:39
Pues 00:04:43
Ahora ya vamos a hacer el 00:04:44
Comportamiento 00:04:46
¿Qué necesita 00:04:46
Tener respuesta? 00:04:49
El hacer clic al botón jugar 00:04:52
necesita respuesta, porque cuando hagamos clic 00:04:53
al botón jugar, se tiene que crear 00:04:55
un número aleatorio y además 00:04:58
tiene que cambiar el texto del botón 00:04:59
por ejemplo 00:05:01
se puede poner este 00:05:07
set visible aquí 00:05:09
esto que esté en 00:05:11
false y esta 00:05:16
también 00:05:17
que esté en false 00:05:18
entonces se le habilite, se le haga visible 00:05:20
después de haber dado a jugar 00:05:23
entonces inicialmente esta interfaz 00:05:25
bueno, no, la ha puesto 00:05:27
habilitada, no visible 00:05:29
pero bueno, lo podemos dejar así, para que vea el usuario 00:05:30
que está inhabilitada, que no puede introducir número 00:05:33
hasta que no estemos jugando 00:05:35
vale, entonces esto 00:05:36
efectivamente si nos vamos a la pestaña 00:05:39
de fuente 00:05:41
pues aquí al text fill le ha puesto 00:05:42
false 00:05:46
entonces no tenemos que buscar el método 00:05:47
que tampoco sería tan complicado 00:05:50
buscar el método 00:05:52
ya con el window builder lo tenemos más fácil 00:05:53
nos viene aquí esto 00:05:55
a recordar que el nombre de variable 00:05:58
de este campo de texto es muy feo 00:05:59
en este caso que es una aplicación tan pequeña 00:06:02
pues no importa 00:06:03
pero en una aplicación más grande sería un rollo 00:06:04
entonces se lo podemos cambiar 00:06:07
y en lugar de que se llame text field 00:06:08
eso 00:06:10
número, es el campo para meter el número 00:06:11
Número del usuario, ya está 00:06:16
Número usuario, yo que sé 00:06:18
Lo que fuera, vale 00:06:20
Bueno, pues entonces 00:06:22
Evento del botón 00:06:24
El botón, ¿cómo va a responder? 00:06:26
Generando el número aleatorio 00:06:29
Cambiando el texto a jugando 00:06:30
Y habilitando estas dos cosas 00:06:32
Para que ya sean accesibles 00:06:35
Pues ahora ya que tenemos claro 00:06:36
Lo que tiene que tener que jugar, solamente eso 00:06:39
Pues venga, vamos a hacerle un 00:06:40
añadirle un 00:06:44
even handler 00:06:46
es que 00:06:47
igual está más abajo 00:07:08
y como tengo el 00:07:09
claro 00:07:10
no es que 00:07:12
donde está el even handler 00:07:16
aquí 00:07:18
que no, que no es 00:07:18
Mira, sí, claro 00:07:23
Pero yo es que lo quiero para el botón 00:07:26
¿Por qué no me sale para el botón at even hander? 00:07:27
¿En select? 00:07:30
Que es que me tendría que salir 00:07:32
De aquí directamente 00:07:33
¿Por qué no es un botón y ya por eso lo has aplicado? 00:07:34
No, es que 00:07:38
Pero si normalmente sale 00:07:39
Claro, de toda la vida ha salido 00:07:41
¿Por qué no me sale? 00:07:44
Está desconocido 00:07:46
Está desconocido 00:07:46
A lo mejor es por eso 00:07:48
Porque está desconocido 00:07:51
¿Y por qué está desconocido? 00:07:53
No sé 00:07:56
¿Por qué no sale? 00:07:56
Lo tengo guardado 00:08:02
Qué raro 00:08:04
Si me salen todos los... 00:08:06
A ver, no pasa nada 00:08:10
Lo hacemos a mano y ya ves tú qué problema 00:08:11
Pero no pasa nada 00:08:13
Vamos a hacerlo a mano 00:08:15
A ver, vámonos al botón 00:08:15
Venga 00:08:18
Botón jugar 00:08:20
setEnableTrue 00:08:21
que es por defecto la 00:08:24
y vamos a añadirle el listener 00:08:25
pues venga, a mi botón 00:08:27
jugar le vamos a añadir 00:08:30
una actionListener 00:08:32
que sea una nueva instancia 00:08:34
de este 00:08:36
una nueva instancia de este 00:08:38
entonces si va a ser una nueva instancia 00:08:42
de actionListener pues tenemos que 00:08:44
primero 00:08:46
Pero, new action, eh, pero espérate, aquí está pasando algo un poco raro, jbutton value, java x swing, espera, se lo voy a poner a mano a ver si se calla, public void, 00:08:48
Están pasando cosas extrañas 00:09:15
Bueno, espera 00:09:33
Espera, voy a importar a 00:09:34
Ah, ya sé lo que me está pasando 00:09:36
No, a ver 00:09:40
Esto, yo creo que me está pasando 00:09:47
Por como he hecho el proyecto 00:09:49
Porque como, vale 00:09:50
Es que, acción lisa 00:09:52
vale, entonces ahora ya me deja 00:10:01
importar 00:10:05
y ahora, acción 00:10:07
más simplemente dije acción performance 00:10:09
acción event 00:10:13
public void, acción performance 00:10:15
acción event, vale 00:10:17
entonces 00:10:18
yo juraría que lo he escrito igual 00:10:20
pero bueno 00:10:24
vale, ya está 00:10:24
bueno, me obliga a hacer la mano 00:10:28
pero 00:10:29
enseñanza 00:10:30
muchas veces 00:10:34
entonces, no confiemos siempre 00:10:38
en que, ah, implementame 00:10:41
el método, no sé qué, importame, no, tenemos 00:10:42
que saber dónde hacer las cosas 00:10:44
bueno, pues nada, lo hemos añadido 00:10:46
mucho a la clase, he tenido que hacer el import 00:10:49
a mano, del ActionListener 00:10:51
y ya está 00:10:53
vale 00:10:55
eh? 00:10:56
Vale, pues entonces, ¿qué necesitábamos hacer en el botón? 00:11:02
Ahora vamos a ver por curiosidad, a ver si aquí me apetece. 00:11:05
Fijaos que listo. 00:11:10
Ahora ya sí me aparece, ahora ya sí me aparece la Diven Handler y me aparece que aquí he añadido yo uno en la línea 55, que es este. 00:11:11
No sé por qué antes no me aparecía, pero no pasa nada. 00:11:22
Lo importante es que nosotros lo sabemos. 00:11:24
Sí, tendría igual algo que ver con eso. 00:11:28
Conclusión, menos mal que sabemos hacer las cosas 00:11:30
¿Seguro? A ver, dímela 00:11:34
Bueno 00:11:41
Vale, pues a ver, vámonos a lo que acabamos de hacer 00:11:44
Ahora, ¿qué queríamos hacer aquí? 00:11:48
Queríamos, primero, generar un número aleatorio 00:11:51
Entonces, uno hace aquí 00:11:54
Aleatorio 00:11:57
Vale 00:11:59
Para que el juego no nos estemos mil horas con él 00:12:03
Vamos a 00:12:06
Hacer un número aleatorio entre 1 y 10 00:12:08
Solo, ¿verdad? 00:12:09
¿No? 00:12:15
¿Os parece un aleatorio entre 1 y 10? 00:12:15
Sí, sería random 00:12:18
Es que lo confundo con 00:12:19
Con otros lenguajes 00:12:21
Que esto lo cambia cada vez 00:12:24
¿Eh? 00:12:25
Sí, para que esté entre 1 y 10 00:12:30
¿Vale? Entonces va a generar uno entre 1 y 10 00:12:32
Si lo pones dentro del paréntesis de math random 00:12:34
En plan, si pones 00:12:37
El int 00:12:39
No, no, dentro del math random del paréntesis 00:12:40
Creo que ahí te deja meter el argumento 00:12:42
¿Sí? 00:12:44
¿Puede ser? 00:12:44
Yo pensaba que lo ibas a entrar 00:12:47
Igual hay otro método 00:12:49
Pero no el random 00:12:51
¿Puedo ir aquí adentro? 00:12:51
A lo mejor 00:12:54
Pues 00:12:54
El método random 00:12:58
para math no se aplica para el argumento entero 00:13:02
entre 0 y 00:13:04
no, pero a ver, lo que me está diciendo es que el método random 00:13:05
no aplica 00:13:08
para el argumento entero 00:13:10
pero a ver, que math tiene muchos más métodos para generar 00:13:11
cosas aleatorias, igual tiene uno 00:13:14
que si 00:13:16
no lo sé 00:13:17
bueno 00:13:18
pero como le va a dejar, que no le puede dejar 00:13:21
es imposible 00:13:24
vale, entonces 00:13:25
¿qué más cosas había que hacer? poner el texto 00:13:28
del botón a jugando, bueno pues el botón 00:13:30
menos mal que le hemos puesto 00:13:32
ya un nombre que entendemos 00:13:34
con lo cual podemos 00:13:36
jugando 00:13:37
y estaría bien 00:13:41
a este botón 00:13:44
ahora ponerle en enable 00:13:46
da false, porque a este botón 00:13:48
no le queremos, el usuario ya no le tiene 00:13:49
que dar más mientras se está jugando 00:13:52
entonces pues aquí a lo mejor 00:13:53
tendría sentido hacer 00:13:55
Pues si quiere dejar de jugar 00:13:57
Entonces el juego te lo tendrían que haber explicado de la manera 00:14:02
Se hace otro botón de 00:14:04
Me voy o lo que sea 00:14:06
Vale, a jugando 00:14:07
False y se habilitan los otros 00:14:11
Componentes que estaban deshabilitados 00:14:14
Que eran la etiqueta, que a la etiqueta no la habíamos 00:14:15
Cambiado el nombre 00:14:18
La etiqueta, veis aquí 00:14:18
El botón 00:14:22
Está local al método, no está como propiedad 00:14:23
De la clase frame 00:14:26
está local, pero 00:14:27
al ser clase anónima y estar 00:14:29
aquí dentro, tiene acceso 00:14:31
porque la clase anónima 00:14:33
tiene como ventaja, como truquito 00:14:34
que está dentro del método 00:14:38
la clase interna nunca puede estar dentro 00:14:39
de un método, la clase interna está dentro de una clase 00:14:41
entonces al estar dentro de una clase 00:14:44
solamente puede acceder a las variables de la clase 00:14:45
pero la clase anónima 00:14:47
está dentro de un método, entonces puede 00:14:49
acceder a lo que está en el método 00:14:51
y botón jugar es accesible 00:14:53
desde aquí 00:14:55
no hemos tenido que sacarlo fuera 00:14:56
vale, que lo podríamos haber sacado 00:14:58
pero no ha hecho falta 00:15:02
vale, la etiqueta del texto 00:15:03
para habilitarla, pues la etiqueta 00:15:06
del texto se llama 00:15:08
un nombre raro 00:15:09
porque no se lo hemos cambiado 00:15:12
¿dónde está la etiqueta? 00:15:13
la etiqueta no se puede llamar text field 00:15:16
se llamará, es esta 00:15:18
label blue new label 00:15:19
pero claro, esta etiqueta 00:15:21
sí que está después 00:15:23
entonces esta no la va a reconocer 00:15:25
¿veis? 00:15:27
la etiqueta 00:15:29
el window builder 00:15:29
te la ha metido aquí después del botón 00:15:32
con lo cual si yo me hago este action list 00:15:35
como clase interna aquí dentro 00:15:37
el compilador me va a decir ¿quién es? 00:15:38
porque aún todavía 00:15:42
el compilador es una regla muy estricta 00:15:43
entonces dice 00:15:45
a ver esto no sé todavía lo que es 00:15:47
entonces no pasa nada pues todo esto 00:15:48
lo ponemos delante 00:15:50
y ya está 00:15:52
lo ponemos aquí, por ejemplo 00:15:54
vale 00:15:56
bueno, porque cuando nosotros 00:15:59
hemos construido, hemos ido, primero 00:16:02
hemos añadido el botón, luego hemos añadido no sé qué 00:16:03
vale, y ahora 00:16:06
aquí, el sedenable de este 00:16:08
pues a true 00:16:10
y el texto que se llamaba 00:16:11
número usuario 00:16:16
el sedenable 00:16:17
a true también 00:16:22
entonces, este 00:16:24
evento, esa parte la hace 00:16:28
y funciona, pues si 00:16:30
lo ponía jugando 00:16:32
vale 00:16:33
esa parte está, ahora 00:16:35
necesitamos el action performance 00:16:38
de este 00:16:40
porque cada vez que el usuario 00:16:42
meta un numerito, hay que verificar 00:16:43
si es el número correcto 00:16:46
sin avisarte si lo es 00:16:48
o si no lo es, y si además lo fuera 00:16:50
volver a reiniciar el juego 00:16:52
bueno, pues aquí si que me ofrece 00:16:54
el event handler 00:16:56
¿Qué evento queremos? 00:16:57
El por defecto del text fill 00:17:02
Que es darle al enter 00:17:04
Pues venga, action performer 00:17:04
¿Qué tenemos que hacer aquí? 00:17:07
Verificar 00:17:10
Coger el numerito 00:17:10
Que haya introducido el usuario 00:17:13
El numerito que haya introducido el usuario 00:17:15
Llamémosle en esta, en el área de texto 00:17:18
Que se llama número usuario 00:17:19
Pues entonces 00:17:21
Número usuario 00:17:23
vamos a coger el texto que tiene el metido 00:17:26
get test, vale 00:17:28
pero eso nos va a dar 00:17:30
el número en formato texto, en formato cadena 00:17:32
en formato cadena lo queremos 00:17:34
pero sabemos como convertir un numerito 00:17:35
que está en formato cadena 00:17:38
al integer que representa 00:17:39
que es esto 00:17:42
usuario 00:17:44
vale 00:17:51
lo ponemos 00:17:53
ahí abajo 00:17:54
ala, pues ya hemos leído el número 00:17:56
que ha metido el usuario 00:17:59
lo hemos cogido del text fill y lo hemos convertido en t 00:18:00
y ahora es cuando 00:18:03
tenemos que compararlo con el número aleatorio 00:18:05
que se generó 00:18:07
pero 00:18:08
tenemos un problema, ¿dónde está ese número aleatorio 00:18:10
que se generó? 00:18:13
está aquí 00:18:16
ese número apareció y cuando el evento 00:18:17
terminó desapareció, luego esto no tiene sentido 00:18:21
¿qué tenemos que hacer 00:18:23
con esta variable? 00:18:25
sacarla 00:18:29
a un ámbito de variable 00:18:29
que sea accesible tanto desde aquí 00:18:31
como desde aquí 00:18:33
entonces no será aquí donde lo tengamos que declarar 00:18:34
aquí le damos valor, eso sí 00:18:37
pero la declaración la hacemos 00:18:38
en el ámbito superior a esas dos 00:18:40
por ejemplo 00:18:42
aquí al principio del método 00:18:44
como variable de clase depende 00:18:47
de nuestras necesidades 00:18:49
uy, que tontería esa 00:18:51
vale, quería darle un valor cualquiera 00:18:59
para que no me dijeran 00:19:01
podría estar sin inicializar 00:19:03
Vale, entonces 00:19:04
Como las dos clases que acceden a él 00:19:06
Son internas 00:19:09
A este método 00:19:10
Son anónimas y que están dentro 00:19:11
Podríamos meterlo aquí dentro 00:19:14
Normalmente cuanto más local 00:19:15
Sea una variable dentro de lo posible 00:19:18
Mejor porque menos va a afectar al resto 00:19:20
Vale 00:19:22
Bueno, pues entonces 00:19:24
Más bien 00:19:26
Vale, vale 00:19:29
Vale, sí 00:19:31
No, pero en este caso no podemos declararla ahí 00:19:34
Porque 00:19:36
Sí, ya, ya 00:19:37
Pero 00:19:42
Claro, no, pero 00:19:44
Tenemos que ponerla como variable de clase 00:19:52
Porque 00:19:55
No sabría 00:19:56
Decírtelo con precisión 00:20:05
¿Por qué? 00:20:07
¿por qué el ámbito 00:20:07
de aquí 00:20:10
no se considera un ámbito 00:20:10
interno a este? 00:20:14
vale 00:20:17
si abriéramos un if o un for 00:20:17
ahí estaría claro 00:20:19
pero este ámbito que hemos abierto es un ámbito especial 00:20:20
porque es un ámbito de una clase interna 00:20:23
una clase anónima 00:20:26
sí, pero según eso 00:20:27
tampoco nos tendría que haber dejado acceder 00:20:33
a los botones 00:20:35
y eso sí que nos deja 00:20:37
entonces a esto sí que nos deja 00:20:38
y no se ha dejado hacer el número aleatorio 00:20:40
no sabría precisar 00:20:42
exactamente por qué 00:20:47
habría que 00:20:48
en cualquier caso la solución está clara 00:20:49
que es ponerlo como variable de clase 00:20:52
y ya está 00:20:54
lo ponemos como variable de clase 00:20:55
y ahí siempre va a poder acceder 00:20:57
vale 00:20:59
ahora ya sí 00:21:01
Ahora ya sí, lo que le faltaba al ActionPerformer del texto, que era si n es igual al número aleatorio, pues si es igual, entonces el juego ha terminado. 00:21:05
¿Y qué significa que el juego haya terminado? 00:21:23
Primero avisamos. 00:21:25
Avisamos con una ventanita emergente. 00:21:27
¿Cómo hacemos sacar una ventana emergente sencilla asociada al frame? 00:21:29
Eso es muy fácil. 00:21:33
sacar una ventana emergente 00:21:34
asociada a un frame 00:21:37
en una 00:21:39
situación concreta 00:21:42
se puede hacer a través de un método 00:21:44
estático de la clase 00:21:46
JOptionPanel 00:21:48
vale 00:21:49
la clase JOptionPanel 00:21:55
esta clase que es otra clase de Java 00:21:57
XSwing 00:21:59
esta es una clase que tiene métodos estáticos 00:22:00
para sacar ventanas aleatorias 00:22:03
son todas estas que empiezan con el 00:22:05
Show, Confirm, Dialog, Show Message. 00:22:07
Son ventanitas aleatorias. 00:22:09
Esta es la típica para confirmar la que te sale. 00:22:11
Aceptar, cancelar. 00:22:13
Las hay solamente para informar, 00:22:16
como es la Show Message, que está más abajo. 00:22:18
Las hay para que además te ofrezca un texto 00:22:21
y tú le metas un texto. 00:22:23
Y entonces vamos a simplemente elegir la de informar. 00:22:25
Podéis explorar todas las otras para que sirven. 00:22:28
Vamos a elegir la de informar, que es esta. 00:22:30
Vale. 00:22:35
pues esta te saca 00:22:35
una ventanita de diálogo solamente para 00:22:39
informar y que parámetro 00:22:41
le pones, pues como primer 00:22:43
parámetro 00:22:45
como primer parámetro 00:22:45
se le pone el frame al que esa ventana 00:22:48
va asociado, si le ponemos null es el frame 00:22:51
en el que está, ese método 00:22:53
declarado, luego le ponemos null siempre y ya está 00:22:55
y aquí el mensajito que 00:22:57
queramos ponerle 00:22:59
ala 00:23:01
ya está 00:23:03
Has ganado 00:23:03
Como estamos en español 00:23:06
Pues interrogación tanto antes como después 00:23:08
Perdón, exclamación 00:23:11
La niebla mental 00:23:15
Vale, y ahora ya pues ya está 00:23:16
Poner al botón, le volvemos a habilitar 00:23:18
Le volvemos a cambiar el texto 00:23:21
Para que ahora tenga 00:23:33
Jugar 00:23:38
Sí, claro 00:23:39
Claro, vamos 00:23:44
O a la forma que tú lo hicieras 00:23:46
Pero tendría mucho sentido, efectivamente 00:23:48
Claro, si has decidido 00:23:50
Si no has definido los estados 00:23:52
Pues efectivamente un estado 1 te construye el estado 1 00:23:53
Y cuando tú has lanzado el evento 00:23:56
Pues llamas al método que te lo construye 00:23:57
Claro, efectivamente 00:23:59
Vale 00:24:01
Botón jugar, set test 00:24:02
Y ahora hay que deshabilitar lo otro 00:24:05
Que lo otro era 00:24:07
la lbl 00:24:09
newlajlabel 00:24:10
tal vez 00:24:12
pues no 00:24:13
newlabel 00:24:17
eso era lo siguiente que iba a probar 00:24:20
vale, esta si era 00:24:22
vale, pues set enablet 00:24:25
false 00:24:28
y el texto que este era 00:24:29
número 00:24:34
usuario 00:24:35
enablet false 00:24:37
otra vez 00:24:42
Bueno, pues si el jugador ha ganado, bien 00:24:43
Y si no, pues mostramos la ventanita emergente y nada más 00:24:50
Pero diciendo que no ha acertado 00:24:56
Bueno, lo comparas y le dices más alto o más bajo 00:24:59
Sí 00:25:03
Que era de hecho lo que decía denunciada 00:25:06
Vale 00:25:10
Pues el save 00:25:12
Si el número es menor 00:25:14
pues ala, se lo gritamos 00:25:22
es mayor 00:25:29
y en el único 00:25:35
caso que resta 00:25:39
pues lo otro 00:25:41
y ya está, ya no hay nada más que hacer en este 00:25:42
en este evento 00:25:56
ya no hay nada más que hacer 00:25:58
el numerador ya está 00:26:01
37 no va a ser 00:26:07
5, a ver 00:26:10
nos ha faltado una cosa 00:26:13
que es volver a poner 00:26:15
pues cuatro, no hay otra 00:26:16
cuatro 00:26:18
vale, entonces volver a poner 00:26:20
el área de texto vacía para que no lo tenga que borrar 00:26:23
todo el rato es un detalle 00:26:25
entonces 00:26:26
aquí cuando 00:26:28
el set test 00:26:30
volverlo a poner a cero pues directamente 00:26:33
cuando acaba este 00:26:35
de aquí, en cualquiera de los casos 00:26:39
Pues 00:26:41
Número aleatorio 00:26:43
Punto 00:26:47
Sextest 00:26:48
Uy, número aleatorio no, número usuario 00:26:49
Sextest 00:26:51
Vacío 00:26:57
Es que está fuera de list 00:26:58
O sea, en cualquiera de los casos 00:27:05
En cualquiera de los casos 00:27:06
Ya te lo va a poner 00:27:08
Vale, y ya está 00:27:09
Pues nada, así nos 00:27:11
Lógicamente el procedimiento óptimo es empezar por la mitad 00:27:13
¿Verdad? Vas acotando 00:27:21
Claro 00:27:22
Siempre por mitad 00:27:23
¿Qué es eso? 00:27:25
¿Qué es lo que se llama? 00:27:27
No para de ganar 00:27:29
No para de ganar 00:27:30
Jolín, pues 00:27:32
Yo nunca puedo ir peor 00:27:36
Siempre es por mitad 00:27:39
Por mitad es 00:27:41
Sí, lo que pasa es que si el número está justo 00:27:41
en el extremo, si es 9 o 2 00:27:47
es la peor 00:27:50
sí, sí, sí, pero que en mi caso 00:27:51
siempre me está generando como aleatorio o el 9 o el 2 00:27:53
así que no hay una 00:27:56
vale, pues ya está 00:27:57
bueno 00:27:58
pues ya está 00:28:00
esto, una tontería 00:28:03
porque es meter números 00:28:05
e ir mostrando 00:28:07
la media que llevas acumulada 00:28:10
aquí lo único es que tendrás que tener una variable 00:28:11
también de clase 00:28:14
que cada vez que le das al enter 00:28:15
pues te incorpora ese numerito 00:28:17
a la media y ya está 00:28:19
claro y aparte tienes que hacer un contador 00:28:21
efectivamente y cada intento se incrementa 00:28:25
divides, entonces este tampoco tiene 00:28:27
y es que este nada, metes aquí 00:28:28
a cada evento del botón, pues coges 00:28:31
lo que hay en el text field, haces la operación 00:28:33
que sea y la pones como resultado 00:28:35
vale 00:28:37
vale, pues a ver 00:28:39
Vamos a plantear ahora el juego 00:28:43
Ese del arcado, que está muy chulo 00:28:45
Para que 00:28:47
Se me ha ocurrido sobre la marcha 00:28:47
¿Qué vista podría tener? 00:28:50
Y luego ya hacéis el comportamiento vosotros 00:28:54
Claro, claro 00:28:56
Es que si no es una locura 00:29:00
La idea del juego es 00:29:01
Hacer una raid string 00:29:03
Una raid además, que a ti te encantará 00:29:05
Y no pasa nada, le decimos a ChagPT 00:29:07
Generanos una raid string 00:29:10
Con 200 palabras 00:29:13
con todas las palabras del diccionario español 00:29:14
espérate 00:29:16
no, con todas no sé si va a ser capaz de hacerlo 00:29:20
a ver 00:29:22
un par de palabritas 00:29:23
a ver, es el mejor esclavo que he tenido nunca 00:29:25
si te pide todas las palabras del diccionario español 00:29:32
no te vas a echar 00:29:35
prepárate 00:29:35
pues no, claro que no 00:29:37
a ver 00:29:40
Uy, le estoy gritando 00:29:47
Esto no le gusta, pero bueno, da igual 00:30:01
No le gusta que le griten 00:30:03
¿A ti te gusta que te griten? 00:30:05
Venga, todas las del diccionario 00:30:10
No, es que me da miedo, porque voy a colgar el ordenador 00:30:12
hala pues 00:30:13
ya está 00:30:22
van a ser 200 frutas 00:30:23
no me lo puedo creer 00:30:26
bueno pues 00:30:27
papa 00:30:32
papa 00:30:33
claro claro 00:30:46
pero tenemos que aprender a leer de ficheros 00:30:47
que ese es el siguiente tema 00:30:49
vale, pero bueno, ya vemos de qué 00:30:50
coge a él, no, mira, ha cambiado 00:30:53
a silla, mesa, periódico, cojín, manta 00:30:55
colchón, estantería 00:30:57
vale, pues bueno 00:30:59
este array nos podría valer, para la aplicación 00:31:01
en orden 00:31:03
inmenso 00:31:05
que no, que luego se cree que me río de él 00:31:06
a ver, que yo me gusta tener contentos a los esclavos 00:31:09
sí, sí, para que no sea 00:31:11
no, pues por ética 00:31:12
no se trata mal a nadie 00:31:15
la ética es 00:31:18
inteligencia artificial 00:31:22
interesante pregunta 00:31:22
pero según eso tampoco lo llames inteligencia artificial 00:31:24
es que es complejo 00:31:28
el concepto de inteligencia 00:31:30
claro, porque es complejo 00:31:31
el concepto de ser humano también 00:31:33
¿dónde está la frontera? 00:31:35
vale, bueno, pues a ver, entonces 00:31:38
¿cómo nos podríamos plantear el juego del ahorcado? 00:31:39
vamos a arrancarlo y luego lo seguís 00:31:42
Por ejemplo, venga 00:31:44
Ahorcado 00:31:46
Vale 00:31:52
Entonces tendrá un botoncito 00:31:53
Arrancar juego 00:31:57
Vale, eso está claro 00:31:58
Vale 00:32:01
Frame 00:32:08
No sé que estoy haciendo 00:32:10
Bueno, es una clasecita 00:32:12
Entonces 00:32:14
Vale 00:32:15
entonces, ahora 00:32:27
el botoncito de arrancar juego es el más sencillo 00:32:30
de pensar 00:32:32
pero 00:32:33
luego nos viene ya la parte interesante 00:32:36
botón 00:32:38
el leyado que siempre se me 00:32:40
olvida 00:32:45
de verdad 00:32:46
que estrés 00:32:48
vale 00:32:51
botoncito 00:32:54
jugar, venga 00:32:56
y ahora, ¿cómo se os 00:33:04
ocurriría. La idea es que cuando 00:33:06
le demos a jugar 00:33:08
se selecciona aleatoriamente 00:33:10
una palabra 00:33:14
de esa bolsa de palabras que tiene la aplicación 00:33:15
que efectivamente, como 00:33:17
dice Pablo, sería mejor en lugar 00:33:19
de tenerlas en una raíz de string así de largo 00:33:21
tenerlas en un fichero y leer 00:33:23
del fichero. Pero en realidad es una 00:33:26
cuestión estética, porque 00:33:27
tener una raíz de string así de largo 00:33:29
en mi 00:33:31
programa es 00:33:33
mucho más eficiente que conectarme a un fichero 00:33:35
y leer lo del fichero. Lo que pasa es que 00:33:37
mi programa es así, pero eso a Java 00:33:39
le da lo mismo. Las líneas de código. 00:33:41
Claro, depende 00:33:48
de cómo leas del fichero. Claro, si vas a 00:33:49
volcar todo el fichero, le da igual. 00:33:51
Si vas a ir leyendo de una en una, va a ser siempre 00:33:53
mejor ir leyendo de una en una el fichero que tener todo 00:33:55
el array en RAM. Pero en cualquier caso, 00:33:57
como ahora no tenemos, 00:33:59
no sabemos leer de ficheros, 00:34:01
pues no tenemos esa opción, pero la tendremos en breve. 00:34:03
¿Vale? Bueno, pues entonces 00:34:05
ahora que se os ocurre, cuando vemos al botón 00:34:07
jugar, está claro que habrá 00:34:09
que seleccionar una palabra aleatoria 00:34:11
de todo ese stream 00:34:13
y luego, esto debería 00:34:14
hacer aparecer, debería hacer visible 00:34:17
tantos huequitos 00:34:19
como tantas 00:34:21
letras tenga esa palabra 00:34:23
cada huequito podría 00:34:25
ser un text field de tamaño 1 00:34:27
¿verdad? un text field de tamaño 1 00:34:29
luego, ahora 00:34:31
pregunto yo, pregunto 00:34:33
¿cómo se os ocurriría eso? 00:34:35
de conseguir 00:34:37
Juanjo, escucha 00:34:39
ahora 00:34:40
que se las apañe con sus llaves 00:34:42
tú tus llaves, controlalas 00:34:47
¿vale? pero en el examen has tenido que controlar 00:34:49
solo las llaves 00:34:51
entonces la pregunta es 00:34:51
¿cómo se os ocurriría a vosotros 00:34:55
hacer que cuando le deis 00:34:57
al botón jugar 00:34:59
aparezcan aquí, pum 00:35:00
tantos textfield con tamaño 1 00:35:02
como sean necesarios 00:35:04
para la palabra que aleatoriamente 00:35:06
has seleccionado? 00:35:08
Bueno, cuentas 00:35:10
cuentas el tipo de 00:35:10
sacas el número y el número ese 00:35:13
lo utilizas para formar el número de 00:35:16
habilitas, creas un 00:35:18
y habilitas solo 00:35:20
claro, no instanciarlo 00:35:21
en ese momento, porque entonces se está convirtiendo 00:35:24
en una variable local 00:35:26
claro, esa es una buena opción 00:35:28
tú piensas 00:35:31
de mi bolsa de palabras, ¿cuál es 00:35:32
la más larga, la palabra más larga 00:35:34
tiene 12, pues me voy 00:35:37
a hacer yo aquí 12 textfield 00:35:39
pero los voy a dejar 00:35:40
ocultos, los voy a dejar ocultos 00:35:42
y ahora ya después del botón jugar 00:35:44
selecciono la palabra aleatoriamente 00:35:46
cuento cuantos caracteres tiene 00:35:48
y hago visibles tantos textfield 00:35:50
como necesite 00:35:53
para eso lo mejor es que 00:35:54
toda esa colección de textfield 00:35:56
esté metida en una array de textfield 00:35:58
para yo luego en un bloque 00:36:00
ir haciendo set visible 00:36:01
pa pa pa hasta que termine con eso 00:36:03
¿no? 00:36:05
¿no sería esa la mejor opción? 00:36:07
entonces, eso si los queremos 00:36:09
dejar aquí colocaditos, tampoco es trivial 00:36:11
los dejaríamos primero colocaditos, él me los va a generar 00:36:13
como variables separadas, pero luego lo retocas 00:36:15
tú en el código 00:36:17
claro, entonces una vez que 00:36:17
ya está y luego ya 00:36:21
el text field tiene que tener 00:36:23
un evento cada vez que tú 00:36:25
pones una 00:36:27
bueno, luego tienes que tener una letra 00:36:29
un espacio abajo para la letra 00:36:31
entonces el espacio abajo para la letra 00:36:33
cuando hayas puesto la letra 00:36:35
él tiene que verificar 00:36:38
en la palabra en cuanto está 00:36:39
en la posición en que haya visto que está 00:36:41
colocar esa letra en el text field 00:36:43
¿vale? 00:36:45
bueno, pues os veis capaces de hacerlo 00:36:47
si verdad 00:36:49
tenéis claro lo que habría que hacer 00:36:50
¿no? que es la clave 00:36:54
pues venga, arrancadlo 00:36:55
a ver hasta donde llegamos 00:36:57
en un rato vamos a ver por donde vamos 00:36:58
venga, no seáis perezosos 00:37:01
ni vagos 00:37:03
ahora 00:37:04
no, no, no, no, HGPT lo queremos 00:37:07
yo solo puedo hablar 00:37:11
con HGPT 00:37:13
porque yo soy vuestra intermediaria 00:37:14
con HGPT 00:37:17
la verdad es que la palabra es imprescindible 00:37:18
entonces, a ver 00:37:22
vamos a, si queréis arrancarlo hasta llegar a la raíz 00:37:25
de texto y luego ya vais siguiendo 00:37:27
vosotros, vale 00:37:29
A ver, se me está hablando sobre la marcha. 00:37:30
Igual lo que yo hago aquí también son borradas. 00:37:32
Vamos a colocar, por ejemplo, 00:37:35
tantos text field como máximo. 00:37:37
A ver, nos vamos a quedar con este array de chat GPT. 00:37:40
¿Nos ha gustado? 00:37:42
¿Se lo habéis pedido vosotros y os ha dado el mismo? 00:37:46
No, ¿verdad? 00:37:49
Bueno, pues poned vosotros el que os haya dado vosotros. 00:37:50
Da igual. 00:37:53
Yo voy a copiar el mío. 00:37:54
Venga, yo voy a copiar mi array. 00:37:59
y este array se va a quedar aquí 00:38:01
en una clase 00:38:04
aparte, para no emborronar 00:38:06
esto, para no emborronarlo 00:38:08
voy a ponerlo en una clase aparte 00:38:10
palabras, y ahí pongo las palabras, porque es que 00:38:12
si no, mi frame, mi vista, se queda 00:38:14
ahí con un array horroroso 00:38:16
entonces, vamos a hacer, vais a 00:38:18
hacer una clase aparte 00:38:20
para las palabras 00:38:22
palabras 00:38:23
y en esta clase aparte, palabras 00:38:27
Como variable estática 00:38:33
Está este string 00:38:35
Y ya está 00:38:36
Y yo cuando tenga que acceder a mi array de palabras 00:38:38
Accedo aquí 00:38:40
La verdad es que lo de la tilde 00:38:43
Nos ha jodido un montón 00:38:45
Con perdón 00:38:47
Porque para hacer la comparación 00:38:48
Entonces le voy a decir a hgpt que me las escriba sin tilde 00:38:50
Porque es que luego para comprobar si está 00:38:52
Tienes que ver 00:38:55
No hay un método que te diga si es variable 00:38:55
Es que eso es muy raro 00:38:59
Claro, entonces vamos a decirle a CharGPT 00:39:01
Pero sin las tildes 00:39:07
Venga, pedíselo también vosotros sin las tildes 00:39:18
No ha dicho claro, como siempre 00:39:23
Porque no le gusta nada lo de hacer faltas de ortografía 00:39:26
Vale 00:39:28
Sería capaz, si le digo esto mismo 00:39:32
Pero con palabrotas, sería capaz de pensar en 200 palabrotas 00:39:41
O sea, existen estas palabrotas 00:39:43
Venga, pues esto ya nos ha gustado más 00:39:48
Prueba, prueba 00:39:51
A ver qué te dice 00:39:52
Venga 00:39:53
Este stream ya me gusta más 00:39:57
No nos leas las 200 00:40:11
Por favor 00:40:13
Vale, ahora ya tenemos palabras sin tilde 00:40:14
Y palabras bonitas. Manta, micrófono, auriculares, genial. Vale. Ahora. Que se está grabando, claro que se está grabando. Vale, ahora. 00:40:17
que es lo siguiente 00:40:38
que es lo siguiente que necesitamos 00:40:42
el tamaño de la palabra 00:40:46
más larga, para los 3 fin 00:40:48
dígame 00:40:50
lo puse en una clase aparte como variable estática 00:40:51
para que no esté en la misma 00:40:58
porque es que si no, si tengo que poner todo 00:41:00
esta array en mi aplicación 00:41:02
me queda un código ahí horrible 00:41:04
entonces lo pongo en una clase aparte 00:41:06
como variable estática y accederé a ese string 00:41:08
con palabras.palabras 00:41:10
y ya está, ahora 00:41:12
sería interesante saber 00:41:14
cuál es la más larga 00:41:16
pero pedirse la char gpt 00:41:17
ya es el colmo de la vaguería 00:41:20
a ver, hombre 00:41:22
¿no haríais rápidamente aquí un código 00:41:26
rapidísimo 00:41:28
para devolver la más 00:41:30
larga? 00:41:32
venga, los que estén flojos 00:41:41
programando 00:41:43
Que aproveche 00:41:44
¿Cómo harían esto? 00:41:45
Pues la más larga es 00:41:51
Pues ya está, claro, efectivamente 00:41:53
El código de toda la vida 00:41:54
La más larga inicialmente es la primera 00:41:56
Que es palabras de cero 00:42:03
Inicialmente esta es la más larga 00:42:06
Y ahora ya recorremos 00:42:08
no creo que es una fobia 00:42:10
la fobia de las palabras largas 00:42:25
palabras de i 00:42:27
punto len 00:42:30
es mayor 00:42:32
que la más larga 00:42:34
entonces 00:42:37
menos i 00:42:43
perdón, menos i, perdón 00:42:45
palabras punto len, Dios mío 00:42:47
supenso 00:42:49
vale 00:42:50
entonces pues ya está 00:42:52
que más larga 00:42:54
punto led 00:43:09
y ahora ya cuando este fuera terminado 00:43:10
ala todo el mundo 00:43:14
habría sabido hacer este 00:43:18
este 00:43:20
pequeño programita ¿no? 00:43:22
de la primera evaluación 00:43:23
se supone que ya esta parte la tenemos 00:43:25
recuperada. Todo el mundo habría sabido hacer esto, ¿no? 00:43:28
Vale, vamos a hacernos un main 00:43:30
rápido para que nos lo diga. 00:43:32
Venga, vamos a ejecutar 00:43:53
este main a ver cuál es la más larga de todas. 00:43:54
La más 00:44:00
larga de las que ha seleccionado ChadGPT 00:44:00
es Enciclopedia. 00:44:02
A ver. 00:44:05
¿Cuál es 00:44:08
la más larga de las 00:44:08
que me has dicho? 00:44:11
Electrodoméstico 00:44:12
Pero no está en la lista 00:44:19
De las palabras que existen 00:44:20
Auriculares y micrófono 00:44:24
Ah, puede ser que enciclopedia 00:44:25
Tenga más que auriculares 00:44:28
Vale, bueno, pues ya está 00:44:29
Pues pídele más 00:44:33
De hecho enciclopedia 00:44:37
Tiene una más 00:44:38
enciclopedia tiene más que auriculares 00:44:40
no lo sé 00:44:43
1, 2, 3, 4, 5, 6, 7, 8, 9, 10 y 11 00:44:45
y enciclopedia 00:44:49
que está en mi array claramente 00:44:51
tiene 4, 4 y 4 00:44:52
bueno pues efectivamente la intuición 00:44:55
se ha equivocado 00:44:57
y si lo decimos, pues no es enciclopedia 00:44:57
a ver que me dice 00:45:00
pues no, es enciclopedia 00:45:01
Vale, pues ya está 00:45:05
Entonces, ¿para qué te pregunto? 00:45:12
Vale, enciclopedia 00:45:14
¿Veis? 00:45:16
No ha sido casual 00:45:17
No ha sido casual 00:45:19
ChatGPT, como bien sabéis, se equivoca muchísimo 00:45:21
Una barbaridad 00:45:27
Entonces 00:45:28
Aquí 00:45:30
Yo no quería preguntárselo, porque vete a saber 00:45:31
Siempre que algo lo podéis hacer vosotros 00:45:35
De forma sencilla, hacedlo 00:45:38
No confiéis tanto en él 00:45:39
Bueno, pues ya está 00:45:40
La más larga es Enciclopedia, que tiene 12 00:45:42
Pues ya está 00:45:44
Lo único que queríamos saber era cuál era efectivamente 00:45:45
La más larga de todas 00:45:48
Para ahora poner aquí 00:45:49
En nuestra aplicación 00:45:52
Tantos textfield 00:45:54
Como necesitamos 00:45:58
12, pues ala, venga 00:46:00
A poner 12 de tamaño 1 00:46:01
Ala, con paciencia 00:46:04
Ya tenemos aquí uno 00:46:06
Hay que poner doce 00:46:10
Otro 00:46:12
No lo sé 00:46:32
Venga 00:46:33
3, 4, 5, 6, 7, 8 00:46:37
¿Cuántas y? 00:47:11
Yo, uno, dos, tres, cuatro, cinco, seis, siete, ocho, nueve, diez, once, una. 00:47:12
¡Hala! 00:47:20
Vale, aquí yo sé de uno que va a necesitar un valium. 00:47:22
Sí, Pablo de la Plaza, hasta que consiga que estén todos simétricamente distribuidas. 00:47:27
Entonces, a las doce de la noche que él habrá conseguido que estén todas simétricamente distribuidas, 00:47:33
ya podemos continuar la clase. 00:47:37
Una que te guste, control-t y control-v. 00:47:38
Sí, no es tan fácil 00:47:40
No es tan fácil 00:47:42
Vale, pues entonces 00:47:43
Ahora, nos gustaría 00:47:46
Trabajar con todas estas en modo array 00:47:50
Para poder 00:47:52
Habilitar, pues 00:47:54
Si tengo que habilitar tres, pues recorrer la array 00:47:56
Hasta tres y habilitar las tres primeras 00:47:58
Si tengo que 00:48:00
¿Qué te pasa? 00:48:01
Dime, dime, ¿qué pondrías? 00:48:03
En vez de poner textil para mostrar las palabras 00:48:04
Podría label 00:48:06
Y luego lo sustituiría por la letra 00:48:06
Ah, bueno 00:48:09
Vale, pero no 00:48:14
Es que a mí estos agujericos me gustan 00:48:18
Pero bueno, lo puedes hacer con un label 00:48:21
Pero a este agujero le puedes poner 00:48:23
A todos ellos que te aparezca un asterisco 00:48:25
Bueno, yo con lo que me ha costado ponerlo 00:48:27
Yo no lo voy a cambiar, pero tú pon lo que quieras 00:48:31
¿Vale? Entonces estaría bien 00:48:33
Si nos pudiéramos poner un array 00:48:35
vámonos al código fuente 00:48:37
el código, a ver 00:48:39
para 00:48:43
fijaos 00:48:43
que horrible esto 00:48:47
vale 00:48:48
entonces, aquí lo ideal sería 00:48:49
meterlo en un array 00:48:55
y ahora, habría que ir a cada una 00:48:56
de estas y cuando estés bien, sustituirlo 00:48:59
por la T1 00:49:01
la T0, la T1, vale 00:49:03
bueno, todo el mundo está situado 00:49:04
a ver, ahora querríamos 00:49:07
sustituir todo esto 00:49:11
por un array, ¿verdad? 00:49:13
por un array 00:49:15
bueno, porque yo he añadido 12 00:49:15
pues me aparecen 12 00:49:19
no, no, no 00:49:20
no te disculpo 00:49:23
las cosas no son tan fáciles 00:49:24
en la vida no es así todo 00:49:26
perdóname, ya estás perdonado 00:49:29
letras 00:49:31
venga 00:49:32
new 00:49:33
text 00:49:37
field 00:49:40
de 12 00:49:41
vale, pues entonces 00:49:46
¿hay que meter 00:49:50
todo eso? 00:49:52
no, hay que meterlos no, ahora hay que instanciarlos 00:49:54
pero eso es fácil, y luego, que ahora 00:49:56
sí que viene lo jodido, es 00:49:58
sustituir, no, bueno, no es tan difícil 00:50:00
porque lo podemos hacer con un 00:50:02
sustituir cada operación de textfield 00:50:03
por letras 0, cada aparición 00:50:06
de textfield 1 por letras 1 00:50:08
¿vale? que no es tantas veces 00:50:10
porque es solamente cuando se pone el código 00:50:12
no es tan complicado, pero primero 00:50:14
vamos a hacer el 00:50:16
for para instanciarlo 00:50:18
dentro de mi app, vamos a hacer primero un for 00:50:20
para instanciar cada textfield 00:50:22
pues venga, vamos a recorrernos 00:50:23
para cada 00:50:26
cuidado con el for each, estamos instanciando 00:50:28
nunca jamás lo haríamos con un for each 00:50:30
con un for de índice 00:50:32
Está claro eso, ¿no? 00:50:33
Pues, ¿qué hacemos? 00:50:45
Ahora, ¿qué está pasando? 00:50:47
Que estamos instanciando todos y cada uno 00:50:48
de los text field de mi array. 00:50:50
Y lo ponemos con tamaño 1. 00:51:01
Lo ponemos con tamaño 1. 00:51:03
Uy, perdón, que le he puesto corchetes, paréntesis. 00:51:05
Ya están instanciados. 00:51:09
Ya tenemos letras 0, letras 1, letras 2. 00:51:11
Y ahora hay que colocarlos. 00:51:13
Vale, pues ya está 00:51:15
Donde estaba textfield, ponemos letras 0 00:51:17
Donde estaba textfield 1, letras 1 00:51:19
Donde estaba textfield 2, letras 2 00:51:22
Y así todo el rato 00:51:24
Bueno, porque este constructor 00:51:25
Si tú le das un parámetro 00:51:30
Lo que te fijas es el tamaño de ese textfield 00:51:31
Como solo va a haber una letra, pues le pongo 1 00:51:33
Para que solo quepa una letra 00:51:35
Y ahora, vamos a sustituir 00:51:36
Cada aparición de textfield 00:51:38
Esto 00:51:41
Refactor 00:51:43
rename 00:51:44
y luego la quitamos. 00:51:45
La vamos a llamar letras cero. 00:51:48
A ver si... 00:51:50
Letras cero. 00:51:51
A ver si me deja... 00:51:55
Claro, no me lo deja porque 00:51:58
no es un identificador válido. 00:51:59
Pues claro. 00:52:01
Yo no puedo declarar una variable así. 00:52:03
No me deja. 00:52:05
No pasa nada. Vamos a mano. 00:52:06
Sí son tres. 00:52:08
O sea, son estas cuatro solo 00:52:09
Pues aquí en estas cuatro hay que poner letras cero 00:52:16
Y ya está 00:52:19
Pues venga 00:52:20
Letras cero 00:52:21
Y ahora este letras cero 00:52:25
Seguramente hay una forma más eficiente de hacerlo 00:52:31
Pero vosotros que 00:52:33
Sois los que os gustan 00:52:34
Los atajos 00:52:37
Pues lo ponéis en práctica 00:52:39
Letras 0 y ya está 00:52:41
Vamos con letras 1 00:52:42
No pasa nada, tú puedes 00:52:44
Letras 1, vamos con letras 1 00:52:49
Que no, hombre, que no 00:52:51
Que hasta yo que voy en plan a lo lento 00:52:58
Vamos a ver 00:53:01
No sé cómo referíais 00:53:06
Pero a mí no me lo han hecho 00:53:10
Pero te admite 00:53:11
un... 00:53:15
No, es que no te lo admite porque no es un identificador válido. 00:53:16
Con corchetes no es válido. 00:53:19
Tiene que ser un nombre de variable válido, identificador. 00:53:21
Esto es mejor 00:53:25
yendo como editor de texto 00:53:26
un sustituir. 00:53:28
Usando esto como un editor de texto, sin más. 00:53:30
Lo copias a un blog de notas, lo usas como editor de texto 00:53:32
y lo vuelves a pegar. 00:53:34
Claro, y seguramente este propio editor 00:53:36
tenga también un sustituir que no esté asociado 00:53:38
al refactor a lo mejor 00:53:40
entonces 00:53:41
pero bueno, que ya llevamos 4 00:53:43
tampoco es tanto 00:53:48
letras 4 00:54:04
Vamos a ver qué pasa 00:54:05
Porque el builder nos da un poco igual 00:54:13
En realidad 00:54:15
Es solamente para construir 00:54:16
Si luego no nos aparece la pestaña de diseño 00:54:18
Porque no le gusta el nombre de identificador que hemos puesto 00:54:22
Pues que le den por saco 00:54:23
No sé 00:54:25
Tiene sentido que se vuelva loco 00:54:31
Y esa parte no nos la quiera mostrar 00:54:33
porque ese identificador no se ha válido para ella. 00:54:34
Sí, se hace un poco pesado, la verdad. 00:55:04
el que de arriba, los de arriba hay que quitarlos directamente 00:55:08
letras 00:55:21
la verdad es que si la palabra más larga hubiera sido más corta 00:55:26
pues habría sido todo más sencillo 00:55:31
pero esto es una prueba de fuego para vuestra 00:55:34
eso, para claro 00:55:39
para cuando tengáis que hacer algo 00:55:43
Absolutamente infumable y aburridísimo 00:55:47
Sí, sí, sí 00:55:49
Como te habías que hacer una migración 00:55:55
La has cagado 00:55:57
Eso nos pasa por improvisar 00:55:58
Venga 00:56:09
Letras 10 00:56:10
Ya casi, ya casi 00:56:12
Letras 11 es la última 00:56:14
pero a ver, vosotros que 00:56:16
sabéis hacer esos atajos 00:56:24
de que te seleccionan hasta el final 00:56:26
y esas cosas 00:56:28
han nacido mayor ya 00:56:28
tú naciste viejo 00:56:35
venga, a ver, lo que estamos es en una situación muy real 00:56:46
te han pedido hacer algo, lo estamos haciendo 00:56:52
sobre la marcha, a ver cómo vamos resolviendo 00:56:54
ala, ya tenemos 00:56:56
todos los textfield 00:56:58
y esto a la porra 00:57:00
hombre, claro 00:57:02
todo esto fuera, ya tenemos 10 letras 00:57:04
colocadas 00:57:09
en su sitio correspondiente 00:57:10
y ahora 00:57:12
Eso es que me está dando miedo, por eso estoy posponiendo 00:57:14
Un momento 00:57:16
¿Ves? No las reconoce 00:57:17
No variable, no variable, no variable 00:57:20
Nos da lo mismo 00:57:21
Pero es que nos da igual 00:57:22
Sí, pero 00:57:25
No las veo, pero que me da igual 00:57:27
Que me aparezcan o no, si yo esto es para construir la interfaz 00:57:30
Ahora tengo que añadir el 00:57:32
Colocar el botoncito 00:57:34
Para que el usuario introduzca el texto 00:57:35
Que estas se vean o no aquí 00:57:38
Me da lo mismo 00:57:39
Bueno, ¿qué? ¿Cómo vais? 00:57:40
Amigos míos, ¿ya habéis terminado? 00:57:43
Lo que sí que estaría bien que comprobáramos, vamos a ejecutar la aplicación a ver si se ven los desfiles bien y están bien colocados, claro. 00:58:00
aquí están, mirad que array tan bonito 00:58:07
de textfield 00:58:14
magnífico 00:58:14
les voy a poner un asterisco 00:58:20
mientras vosotros 00:58:23
acabáis que sois lentitos 00:58:25
en el momento del array 00:58:28
le voy a poner que ponga un asterisco 00:58:33
para que 00:58:35
Letras de 00:58:36
Punto 00:58:42
Sextest 00:58:44
Asterisco 00:58:45
¿Por qué no me pone asterisco? 00:58:48
Sextest asterisco 00:58:55
Letras de i 00:58:56
Ah, no, letras de i es el textfield 00:58:57
Un nuevo jtxtfield 00:59:01
¿Y por qué no me pone el asterisco? 00:59:04
Sextest 00:59:05
Añadir 00:59:06
¿Por qué no aparece el asterisco? 00:59:10
A ver, no estoy en la pestaña de diseño 00:59:20
En diseño no aparece 00:59:22
Pero es que se me da igual 00:59:22
La que me importa es mi aplicación 00:59:24
Esto es una ayuda para colocar 00:59:26
Pero no en la vida 00:59:27
Yo lo ejecuto 00:59:29
Lo que no entiendo es por qué no me los ha puesto 00:59:31
Con un asterisco ahí 00:59:33
No sé, ¿por qué no me pone el asterisco? 00:59:34
Ni el guión tampoco 00:59:50
Bueno, vale 00:59:51
¿Estamos ya? 00:59:57
El array de las letras 00:59:57
Está en otra clase aparte 01:00:06
Ah, está como variable de la clase. 01:00:08
Es un array de TextField. 01:00:12
Este. 01:00:14
Tiene sus 12... 01:00:17
Esto es un array para tener 12 TextField. 01:00:23
Luego ya, cuando ya he entrado en mi aplicación, 01:00:26
en mi constructor, 01:00:29
he recorrido el array para instanciar los TextField. 01:00:30
Y ahora ya los he ido colocando en el... 01:00:32
Y ya está. 01:00:37
vale, pues nos vamos a 01:00:38
entonces verificamos ejecutando esto 01:00:42
que efectivamente están aquí mis 12 textfield 01:00:44
ahora con este truquito 01:00:46
tan tonto hemos conseguido ahora poder manejarlos 01:00:48
todos de golpe, con un array 01:00:50
recorrer, no que si estaban sueltos era un rollo 01:00:52
bueno, pues entonces 01:00:54
¿qué más le falta a esta interfaz? 01:00:56
un área de texto para que el usuario 01:00:58
ponga la letra 01:01:00
con la que quiere probar, pues un área de texto 01:01:01
vámonos a diseño 01:01:04
y ese área de texto 01:01:05
se la vamos a poner aquí abajo por ejemplo 01:01:08
vale 01:01:11
vamos a llamarla 01:01:14
letra usuario por ejemplo 01:01:16
usuario 01:01:18
un poco más pequeñita 01:01:19
ahí letra usuario 01:01:23
y vamos a poner una etiqueta arriba que ponga 01:01:26
introduzca letra y ya está 01:01:30
vamos a poner una etiquetita 01:01:32
una etiqueta 01:01:35
con el texto 01:01:45
pruebe letra 01:01:46
vale, pues si ejecuto 01:01:49
vale, prueba letra 01:01:59
bueno, un poco feo pero da igual 01:02:01
entonces inicialmente estaría bien 01:02:02
hacer lo que esto fuera visible false 01:02:07
y que se hiciera visible true 01:02:09
cuando ya le hemos dado a jugar 01:02:11
y se ha seleccionado la palabra 01:02:13
vale 01:02:14
entonces desde el código 01:02:16
del prueba letra pues vamos a hacerle 01:02:19
aquí un set visible false 01:02:21
a la label new label 01:02:22
esta 01:02:29
un set visible 01:02:29
falso para que no me aparezca de partida 01:02:37
solo me aparezca cuando ya 01:02:40
he dado a jugar y también 01:02:42
un set visible falso de este 01:02:44
de este también un set visible falso 01:02:45
ahora ya cuando 01:02:52
arranquemos no lo vemos 01:02:58
y cuando le demos a jugar cuando hayamos hecho 01:02:59
el evento ya se aparecerá 01:03:02
está pero no está visible 01:03:03
Lo he puesto como no visible 01:03:05
Hasta que no se haya dado al botón de jugar 01:03:07
Bueno, pues nos va a hacer falta algo más 01:03:10
En la interfaz 01:03:13
No, no, jugar 01:03:15
Aparecerán tantos huequitos 01:03:17
Como letras tenga la palabra 01:03:18
Pruebe letra, damos letra 01:03:20
Y no necesita nada más en la interfaz gráfica 01:03:23
Este juego, ¿verdad? 01:03:27
El usuario pondrá letra, le aparecerán en los textfield 01:03:29
y cuando ya tenga la palabra completa 01:03:31
pues que le aparezca un 01:03:35
habría que añadir 01:03:37
entonces 01:03:42
de la interfaz ya no hay nada más que añadir 01:03:44
ya está, no hay nada más que poner 01:03:47
ahora, lo que tenéis que hacer 01:03:49
vosotros ahora, es añadirle 01:03:51
el comportamiento 01:03:53
vale, pues a ver, el botón 01:03:54
jugar, cuando se dé 01:03:57
al botón jugar. ¿Cómo responder 01:03:59
a ese clic? Seleccionando 01:04:02
aleatoriamente una palabra 01:04:04
de la bolsa de palabras. 01:04:05
Mirando 01:04:09
cuántos caracteres tiene y haciendo 01:04:10
visibles 01:04:12
tantos que inicialmente estarán 01:04:13
sin ser visibles. 01:04:15
Haciendo visibles tantos 01:04:18
textfield como sean necesarios 01:04:20
para la palabra. Entonces, yo ahora mismo 01:04:22
lo tengo puesto para que siempre 01:04:24
sean visibles 12. No, tendríamos que hacerlos 01:04:26
invisibles. Entonces, 01:04:28
no porque es un for 01:04:29
ventajas del for 01:04:32
entonces 01:04:35
ahora podemos poner 01:04:36
aquí 01:04:39
para cada j text 01:04:39
fill 01:04:45
text fill en letras 01:04:46
que hacemos 01:04:51
text fill punto set 01:04:53
visible 01:04:56
set visible 01:04:57
false para que arranque 01:04:59
sin que tu lo veas 01:05:01
¿vale? o sea 01:05:02
esto arranca 01:05:05
sí, sí, sí, yo de hecho 01:05:06
lo tengo para que cuando arranca mi aplicación 01:05:13
solo se vea el botón jugar 01:05:15
entonces, cuando uno vea el botón jugar 01:05:16
¿qué tendrá que ocurrir cuando uno vea el botón jugar? 01:05:18
habrá que 01:05:22
seleccionar aleatoriamente una palabra 01:05:23
de la bolsa de palabras 01:05:25
contar cuantos caracteres tiene 01:05:27
hacer visibles 01:05:29
tantos textfields de estos que están aquí ocultos 01:05:31
como sean necesarios 01:05:33
para cubrir la palabra. 01:05:35
Hacer visible la etiqueta y el textfield 01:05:37
para el usuario. 01:05:39
Y ya está. 01:05:42
Nada más. Eso es lo único que habrá 01:05:43
que hacer cuando sea el botón jugar. 01:05:45
¿Qué otro componente 01:05:48
tiene que responder con evento? 01:05:49
El del enter del usuario, el textfield este. 01:05:51
¿Vale? 01:05:54
Este de aquí. Ese también tendrá 01:05:57
que tener un evento. Este de aquí abajo. 01:05:59
¿Cuál será el evento de este? 01:06:01
Pues cuando el usuario del enter 01:06:03
Que tendrá que hacer la aplicación 01:06:04
Coger la letra que hay ahí 01:06:06
En la palabra que tiene aleatoriamente seleccionada 01:06:08
Mirar en qué posiciones está la letra 01:06:11
En las que haya encontrado que está 01:06:13
Colocar esa letra 01:06:15
En el text field correspondiente 01:06:17
Y ya está 01:06:18
Y contar el intento 01:06:19
Porque vamos a hacerlo con un contador de intentos 01:06:22
Lo vamos a dejar hasta el infinito 01:06:24
Le vamos a decir 5 intentos 01:06:25
Entonces incorporar un contador de intentos 01:06:28
Eso es lo que tendrá que hacer el ente 01:06:30
Coger la letra, verificar en qué posición está 01:06:31
En las que esté, colocarla en el textfield 01:06:34
Y contar el intento 01:06:36
Si se ha pasado de intentos 01:06:38
Parar el juego 01:06:41
Y decir se acabó 01:06:42
Si se ha parado de intentos, decirle se acabó 01:06:43
Y si no se ha pasado de intentos 01:06:45
No tiene que hacer nada más 01:06:47
Bueno, en el caso de que haya completado ya todos los textfield 01:06:48
Tiene que avisar, has ganado, la palabra era esta 01:06:51
Eso, efectivamente 01:06:53
Venga 01:06:56
Vale, pues ese es el enter de aquí 01:07:00
Luego lo único que tenéis que hacer ahora vosotros 01:07:06
Es el evento del botoncito jugar 01:07:08
Que es el más sencillo 01:07:10
Y el evento de este de aquí 01:07:11
Y ya se acabó el ahorcado 01:07:13
Elige lo que tú quieras 01:07:14
Pues venga 01:07:20
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:
16
Fecha:
17 de marzo de 2025 - 10:21
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 07′ 23″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
318.96 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid