Saltar navegación

20250313 GUI_Ahorcado_1 - 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.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues para ver, a ver, para el que esté un pelinín perdido sobre ese ejercicio. 00:00:00
Cuando lo hicimos, lógicamente lo que primero hay que tener claro es lo que uno quiere conseguir, ¿vale? 00:00:08
¿Cuál es la vista que tiene que ver el usuario? 00:00:18
Entonces, el usuario lo que tiene que ver es un botoncito de jugar, está claro, 00:00:21
y además tiene que haber 00:00:26
tantos text fill pequeñitos 00:00:28
para que quepa una letra 00:00:31
como letras sean necesarias 00:00:32
como máximo 00:00:36
a ver si acertamos aquí una de 12 00:00:37
no es que hay pocas de 12 00:00:40
vale, y luego aquí el text fill 00:00:41
para poner la letra 00:00:45
esto es lo que tiene que aparecer 00:00:46
pero lo que dijimos es 00:00:48
bueno, vamos a colocar esto 00:00:50
en la interfaz gráfica, colocar esto es sencillo 00:00:52
pero 00:00:55
como text field 00:00:56
¿cuántos tienen que aparecer? 00:00:59
seleccionamos que como mucho 12 00:01:01
porque en nuestro conjunto de palabras 00:01:02
la más larga tenía 12, es lo que dijimos 00:01:04
pues entonces vamos a hacernos 00:01:06
12 text field 00:01:09
y según le demos al botón de jugar 00:01:10
como es en ese momento 00:01:13
en el que se crea la palabra aleatoria 00:01:14
pues en ese momento contamos 00:01:16
cuántos caracteres tiene esa palabra aleatoria 00:01:19
y hacemos visible 00:01:21
solo los que nos hagan falta 00:01:22
ahora mismo cada vez que yo le estoy dando a jugar 00:01:24
cambia mi palabra 00:01:27
por eso en el evento del botón jugar 00:01:29
cada vez que le doy 00:01:32
está generando una palabra nueva 00:01:33
contando cuantos espacios hay 00:01:35
y haciendo visibles tantos textfield como espacios 00:01:37
entonces el evento de jugar 00:01:40
estaba claro lo que tenía que hacer 00:01:43
hacer visibles tantos de estos 12 00:01:44
que están aquí puestos fijos 00:01:47
pero ocultos como hagan falta 00:01:49
y luego hacer aparecer 00:01:51
este text field para que el usuario 00:01:52
ponga la letra, ¿vale? y ya está 00:01:55
y luego teníamos otro evento 00:01:57
que es el evento de este text field 00:01:59
que es cuando le dábamos al enter 00:02:01
pues nada, tenía que coger la letra 00:02:02
verificar en 00:02:05
qué posiciones de la palabra aleatoria 00:02:07
elegida estaba esa letra 00:02:09
y en las que lo 00:02:11
encontrara, pues lo ponía en la misma 00:02:13
posición idéntica del text field correspondiente 00:02:15
¿vale? 00:02:17
y ya está 00:02:20
ya que estamos vamos a adivinarlo 00:02:20
No, tiene la B 00:02:26
La M sí 00:02:30
Mada 00:02:33
Aún la he puesto 00:02:39
Justo, muy bien 00:02:42
Esa sí que es 00:02:44
Lo que pasa es que yo no lo completé el otro día 00:02:47
Lo ideal sería que cuando 00:02:50
La aplicación detecta que ya están 00:02:51
Todos estos textfields 00:02:54
Completos, pues que te salga el mensajito 00:02:56
has ganado y reinicie el juego, ¿vale? 00:02:57
pero bueno, eso no lo hice, entonces tú puedes seguir 00:02:59
aquí poniendo letras hasta el infinito 00:03:01
bueno, aquí como ya 00:03:03
consumí los intentos, pues perdiste 00:03:05
vale, entonces uno primero entiende lo que tiene que hacer 00:03:07
está claro, vale, entonces lo más 00:03:09
importante fue la clave 00:03:11
para hacerlo todo, que a partir de ahí era sencillo 00:03:13
lo más importante era 00:03:15
identificar 00:03:17
lo más importante era identificar 00:03:18
que íbamos a necesitar 12 00:03:21
de estos, 12 text fill, íbamos a 00:03:23
necesitar 12 de estos, entonces 00:03:25
ponerlos uno por uno, textfield 1, textfield 2 00:03:27
textfield 3, era un poco locura 00:03:30
porque luego en mi evento de jugar 00:03:32
yo tengo que ir uno por uno 00:03:34
haciéndolos visibles o no 00:03:35
y tener que ir recorriéndolos 00:03:37
como variables separadas 00:03:40
sería un rollo, porque sería 00:03:41
si la palabra es de una letra 00:03:43
tendría que hacer un if, el save enorme 00:03:45
que si la palabra es de una letra, textfield 1 00:03:47
set visible true, el save 00:03:49
la palabra es de dos letras 00:03:51
textfield 1 set visible true, textfield 2 00:03:53
set visible true, el save 00:03:55
palabra de tres letras 00:03:57
textfield1 set visible true, textfield2 00:03:58
set visible true, textfield3 set visible 00:04:01
true, un código horrible 00:04:03
entonces mucho mejor si los tengo 00:04:05
todos metidos en un array 00:04:07
y me limito a recorrer el array 00:04:09
bueno pues entonces 00:04:11
¿qué fue lo que hicimos? pues ya está, ahora si nos 00:04:13
vamos a nuestro código 00:04:15
en nuestro código 00:04:16
dijimos, venga ¿qué variable vamos a necesitar? 00:04:19
el panel, por supuesto 00:04:22
y mi array de 12 textfield 00:04:23
mi array de 12 00:04:26
12 objetos textfield 00:04:27
que son 00:04:29
estos 12 que están aquí 00:04:30
aquí hay 4 visibles pero hay otros 00:04:33
8 escondidos 00:04:35
estos son mis 12 textfield 00:04:39
y este es el textfield de la letra de usuario 00:04:41
vale, esta variable 00:04:43
es para guardar la palabra seleccionada 00:04:45
ya está 00:04:48
este es para el número de intentos 00:04:49
para que se vaya decrementando 00:04:52
según se van haciendo intentos 00:04:53
y esta es la etiqueta 00:04:55
que he usado aquí simplemente 00:04:57
para ir marcando las que he usado 00:04:59
¿vale? 00:05:01
aquí abajo hay una etiqueta 00:05:03
en las que voy marcando las que se han usado 00:05:04
¿vale? 00:05:07
bueno, pues ya está 00:05:10
y ahora, ¿qué es lo que hace el constructor 00:05:11
de la interfaz gráfica? primero 00:05:13
coloca las cosas, las coloca 00:05:15
en su sitio y luego ya 00:05:17
crea los eventos y se acabó 00:05:19
vale, Adrián y Gonzalo 00:05:21
primero coloca las cosas en su sitio 00:05:23
y luego ya hace los eventos 00:05:26
pues venga, vamos a colocar las cosas en su sitio 00:05:28
primero, el array de 12 00:05:30
textfield 00:05:32
hay que instanciarlo 00:05:33
porque ahora mismo yo tengo aquí creado 00:05:36
como recordáis perfectamente los arrays 00:05:38
porque nunca jamás deberíais 00:05:39
olvidarlos, yo tengo aquí instanciado 00:05:42
espacio para 12 textfield 00:05:44
pero no están creados todavía, no están instanciados 00:05:46
bueno, pues lo primero que hacemos 00:05:48
Vamos a instanciar todos y cada uno de los textfields de este array. 00:05:50
Pues recorro mi array de letras y voy instanciando cada uno de los textfields. 00:05:55
Aquí en el constructor pongo 1 porque este 1 es para indicar cuántos espacios quiero que tenga ese textfield. 00:06:02
Cuántos caracteres quiero que sean visibles. 00:06:08
Si le pusiera 10 es que me quedarían unos textfields muy grandes. 00:06:12
Ah, bueno, es que luego cuando lo hago aquí 00:06:14
Ya le cambia, al fijar la letra ya le cambia el tamaño 00:06:32
Sí, luego cuando lo 00:06:35
Se construya ahí abajo 00:06:39
¿Vale? Pero bueno, inicialmente 00:06:40
Yo le doy espacio 1 00:06:43
O podría no darle ninguno, el constructor admite muchas variantes 00:06:44
Uno va probando 00:06:47
Ya está, ya los tengo instanciados 00:06:49
Entonces ya tengo instanciados todos los textfield 00:06:50
Tengo instanciados, por supuesto 00:06:53
Bueno, la letra usuario no 00:06:54
La instanciaré debajo, etc. 00:06:57
vale, pues venga, ahora vamos a 00:06:59
colocar, a construir 00:07:01
la interfaz, esta ya 00:07:03
sabemos que línea era, era la que hacía que 00:07:05
se cerrara la interfaz cuando le dábamos a la X 00:07:07
esta es la que fija el tamaño 00:07:09
del panel 00:07:11
vale, esta 00:07:12
es la que da el borde del panel, todo esto 00:07:15
lo ha generado el builder 00:07:17
vale, todo esto lo ha generado el builder 00:07:19
ahora ya le decíamos 00:07:21
al frame, esto es como si pusiéramos 00:07:23
dis, es lo mismo, le decíamos al frame 00:07:25
que su panel fuera este que acabo de hacer 00:07:27
y ahora 00:07:30
al panel le decíamos que setLayout 00:07:31
null, ningún layout, para poder 00:07:34
colocar exactamente las coordenadas que yo quiera 00:07:35
¿vale? 00:07:38
todo esto 00:07:39
nos lo había generado ya el builder 00:07:40
si yo aquí cambiara el tamaño del panel 00:07:46
o cambiara algo 00:07:48
pues ya me cambiaría todo en el código 00:07:50
si cambiara el color de este panel 00:07:53
o lo que fuera, pues ya me cambiaría todo 00:07:54
vale 00:07:57
pues nada, seguimos 00:07:59
ahora ya, estamos 00:08:00
colocando la letra de usuario, que es 00:08:03
este, que es este de aquí 00:08:05
este lo hicimos arrastrando 00:08:07
a, tanto la etiqueta 00:08:09
esta, prueba letra, como el text field, la letra de usuario 00:08:11
lo hicimos arrastrando, bueno 00:08:13
pues como consecuencia de arrastrar, se nos generó 00:08:15
este código, letra de 00:08:17
usuario en un j text field 00:08:19
y aquí ya añadíamos 00:08:20
el evento a dar la letra de usuario 00:08:23
que ese le vemos luego, vale 00:08:25
este es el evento 00:08:27
que asociamos a AddActionListener. 00:08:27
Se asocia a darle a la letra de usuario, 00:08:31
se asocia a este código, 00:08:34
que ya lo vemos luego, ¿vale? 00:08:35
Este código es lo que saltará 00:08:37
cuando se accione este componente 00:08:39
y este componente, ¿qué componente es? 00:08:43
Pues este, este JTESFIL de aquí, este. 00:08:46
Por lo pronto lo hemos colocado, ¿vale? 00:08:49
Lo estamos colocando aquí. 00:08:52
Le fijamos dónde va a estar, 00:08:54
posición X, posición Y y tamaño 00:08:56
y lo agregamos 00:08:58
al panel, le decimos que tenga 10 00:09:00
columnas e inicialmente lo hacemos 00:09:02
oculto, ocultado, se queda 00:09:04
vale, ya tenemos la letra de usuario colocada 00:09:06
entonces esto 00:09:08
lo podemos cambiar y la letra 00:09:10
de usuario se moverá de un sitio a otro, cambiará 00:09:12
su tamaño, esto me lo generó 00:09:13
directamente el builder cuando yo arrastré 00:09:16
cuando yo arrastré 00:09:18
y me lo generó, pero luego yo lo cambio desde aquí 00:09:20
y se acabó, vale, esto es para 00:09:22
la etiqueta de prueba de letra. La etiqueta 00:09:24
de prueba de letra es esto de aquí. 00:09:26
Bueno, pues la etiqueta de prueba de letra 00:09:28
me creo la etiqueta con este texto. 00:09:30
Se le fija su posición 00:09:33
X, posición Y y tamaño. 00:09:34
Se añade al panel 00:09:36
y se la oculta para que de partida 00:09:37
esté oculta. 00:09:40
Este es el botón jugar. Seguimos 00:09:42
construyendo la interfaz. Pues se instancia 00:09:44
el botón jugar. 00:09:46
Este sí que tiene evento. Cuando demos a jugar 00:09:47
tiene que pasar algo. Pues como este sí que 00:09:50
tiene evento, se le hace la acción 00:09:52
listener y aquí se le pone 00:09:53
su evento, que luego ya entramos a él 00:09:56
vale, se le coloca en la 00:09:58
interfaz, posición x, posición y 00:09:59
ancho y alto 00:10:02
y se añade al panel 00:10:05
y ahora ya empezamos a colocar 00:10:06
los 12 textfield 00:10:09
pues venga, ahora los 12 textfield 00:10:10
se llaman, como está en un mismo array 00:10:13
se llaman letras 0, letras 1, letras 2 00:10:15
así se llaman los textfield 00:10:18
bueno, pues eso fue lo que empezamos a hacer 00:10:20
empezamos a colocarnos, el primer text fill 00:10:23
letras 0, lo instanciamos 00:10:25
decidimos donde se colocaba 00:10:26
lo añadimos al panel 00:10:29
y le dijimos que 00:10:31
letras 0, set columns 10 00:10:32
¿vale? es curioso porque 00:10:35
me aparece como uno solo 00:10:39
si aquí ese text fill tiene 10 00:10:41
en algún sitio me ha generado 00:10:43
o me habrá generado algo 00:10:46
para no lo sé, yo le doy 00:10:47
y me aparece 00:10:49
solo con tamaño para 1. 00:10:51
Ah, no, no, no, no, me aparece con tamaño 00:10:54
para 10. Vale, vale. 00:10:56
1, 2, 3, 4, 5, 6, 00:11:00
7, 8. 00:11:02
No, parece que solo se ven 8. Bueno, da igual. 00:11:04
Vale. 00:11:07
Vale, pues así 00:11:09
uno por uno. Entonces, 00:11:10
cada text field 00:11:13
es un elemento del array. 00:11:14
Aquí lo que 00:11:17
pasa es, ¿de dónde sacamos estas coordenadas? 00:11:18
¿De dónde las sacamos? Bueno, pues inicialmente 00:11:20
los habíamos arrastrado 00:11:22
habíamos hecho unos text fill 00:11:24
que habíamos arrastrado por aquí 00:11:27
los habíamos hecho 00:11:28
inicialmente así, los habíamos arrastrado 00:11:33
y nos habíamos quedado 00:11:35
con el código que había generado 00:11:37
en este caso, por ejemplo 00:11:39
lo que yo acabo de hacer 00:11:43
es esto 00:11:44
pues nos habíamos quedado 00:11:46
con los 12 códigos 00:11:49
que nos había generado para quedarnos con esto 00:11:51
que era lo que nos interesaba 00:11:53
Y una vez que teníamos esto, ahora ya cambiábamos el texto de esa etiqueta por la que nos interesaba, que era o letras 0, letras 1, letras 2, ¿vale? 00:11:54
Entonces, aquí ya son los 12 text fill, letras 0 en esta posición y añadido, letras 1 en esta posición y añadido, letras 2, etc. 00:12:08
Y ahora ya la etiqueta, esta es la etiqueta en la que me voy a poner las letras que ya he usado, que ya he marcado, esta es esa etiqueta, que esa etiqueta está aquí, esa etiqueta está aquí, esta es la etiqueta donde voy a poner las letras ya usadas, vale, es esa, vale. 00:12:16
Y luego ya por último, lo último que hacía después de construir la interfaz, recorría todo mi array de textfield, todo mi array de letras, todo mi array de textfield, lo recorría para ocultarlos todos, ¿vale? 00:12:47
Entonces, primera ventaja que nos encontramos de tenerlas todas en un array, que podemos ocultarlas todas recorriendo el array, no tenemos que ir letras 0, set visible, false, letras 1, set visible, false, recorremos el array y las ocultamos. 00:12:59
vale, pues con esto la interfaz ya estaba construida 00:13:11
aquí aunque no lo veamos 00:13:14
están todos los componentes 00:13:16
lo que pasa es que los 12 textfile están 00:13:18
escondidos y 00:13:20
el huequecito para el usuario está escondido 00:13:22
vale, ahora ya solo falta 00:13:24
hacer el evento, que es 00:13:26
darle comportamiento al botón jugar 00:13:27
y darle comportamiento al botón 00:13:29
pruebe letra, ya está 00:13:31
pues vamos 00:13:34
con el evento del botón jugar 00:13:36
primero hay que tener claro que queremos que pase 00:13:37
cuando le demos al botón jugar. 00:13:39
Lo que queremos que pase es 00:13:41
que se genere una palabra aleatoria. 00:13:42
Hacer visibles 00:13:46
tantos text field de estos 00:13:47
como letras tenga la palabra aleatoria. 00:13:50
Y ya está. 00:13:53
No hay que hacer nada más. 00:13:55
Pues venga, vámonos al botón, 00:13:57
al evento del botón jugar. 00:13:59
Pues el evento del botón jugar está aquí. 00:14:01
Vale, pues justo, ¿qué hacíamos? 00:14:04
Generaba yo aquí un número aleatorio 00:14:06
en principio entre 0 y 199 00:14:07
aunque el 0 no va a salir nunca 00:14:09
seguramente, pero bueno 00:14:11
aquí genero un número aleatorio entre 0 y 199 00:14:13
porque mis palabras 00:14:16
¿vale? 00:14:18
aquí, en esta primera línea 00:14:20
número aleatorio entre 0 y 199 00:14:21
porque mis palabras, recuerdo que están aquí 00:14:23
en este array estático 00:14:26
de la clase palabras 00:14:27
aquí están mis palabras y tenía 200 00:14:29
bueno, pues entre 0 y 199 00:14:31
pues genero un número 00:14:34
aleatorio entre 0 y 199, vale, ahora ya selecciono esa palabra, dentro de mi array que es este, 00:14:36
este es mi array, selecciono esta palabra y la guardo en la variable global, en la variable 00:14:43
de clase que tiene mi aplicación, para guardar esa palabra generada, vale, palabra ya está 00:14:51
inicializada, vale, está claro, palabra es esta variable que está aquí, en la clase, 00:14:59
Para guardar esa palabra generada aleatoriamente 00:15:04
Inicialmente ninguna 00:15:07
Bueno pues 00:15:08
Como respuesta darle al botón jugar 00:15:10
Ya está generada 00:15:12
Si le pusiéramos aquí un 00:15:15
Por ejemplo 00:15:17
Una verificación para que me la muestre 00:15:20
Y volvemos a ejecutar 00:15:22
Jugar 00:15:24
Pues 00:15:25
¿Dónde está mi huevo? 00:15:26
Es huevo, la que me ha generado huevo 00:15:30
Entonces 00:15:32
podría ir a tiro fijo 00:15:32
lógicamente 00:15:35
efectivamente era huevo 00:15:36
vale, bueno pues ya 00:15:43
tengo la palabra inicializada 00:15:49
porque eso es lo que me hace el botón, inicializarme la palabra 00:15:51
vale, ahora 00:15:53
voy a contar, voy a hacer visibles 00:15:54
tantas letras 00:15:57
como caracteres tenga esa palabra 00:15:59
bueno pues venga, me voy a sacar 00:16:01
el número de caracteres de la palabra 00:16:03
está claro, palabras.len 00:16:04
es el número de caracteres de la palabra 00:16:07
lo guardo en numletras 00:16:08
es el número de caracteres 00:16:11
que tiene mi palabra 00:16:13
y ahora me meto en el for 00:16:13
y hago visibles todas las letras 00:16:16
que van desde 0 00:16:19
hasta numletras menos 1 00:16:20
es decir, de mis 12 textfield 00:16:22
hago visible los 00:16:24
numletras primero 00:16:27
este for va de 0 a numletras menos 1 00:16:28
si numletras fuera 4 00:16:31
me hace visibles el 0, 1, 2 y 3 00:16:32
justo 00:16:35
si numletras fuera 7 00:16:35
me haría visibles el 0, 1, 2 00:16:38
hasta 6, que es justo lo que quiero 00:16:40
me hace visibles 00:16:42
tantos textfield de los 12 que hay 00:16:43
como necesito para cubrir 00:16:46
todas las letras de la palabra 00:16:48
aleatoria generada 00:16:50
vale, y el resto 00:16:51
los hago invisibles 00:16:54
bueno, pues el resto 00:16:55
que son 00:16:58
desde el tamaño de la palabra 00:17:00
hasta 12, es decir 00:17:02
si el número de letras fuera 3 00:17:04
hago visibles de 0 a 2 00:17:06
e invisibles 00:17:08
de 3 a 11 00:17:10
pues es lo que estoy haciendo 00:17:11
de 0 a numletras menos 1 00:17:12
los hago visibles 00:17:15
y de numletras 00:17:16
si lo veis más claro así 00:17:18
desde el final de la palabra hasta 12 00:17:22
invisibles 00:17:25
entonces me podríais decir 00:17:26
oye pero porque te hace falta 00:17:32
poner el resto invisibles si ya de partida 00:17:34
estaban invisibles 00:17:36
bueno, están invisibles al arrancar la aplicación 00:17:37
pero la primera vez que he jugado 00:17:41
se han puesto ya visibles a lo mejor 12 00:17:43
si luego yo le vuelvo a dar a jugar y me sale una palabra de 4 00:17:45
los 4 primeros se pondrán visibles otra vez 00:17:49
pero los que estaban visibles del juego anterior 00:17:53
los seguirán 00:17:56
entonces, una vez que yo selecciono el número de letras 00:17:57
de la palabra aleatoria, pongo visibles 00:18:02
las numletras primeras 00:18:05
e invisibles las restantes hasta 12 00:18:07
vale 00:18:10
y que es lo siguiente que hago 00:18:10
hago visible la etiqueta que me dice 00:18:12
pruebe letra 00:18:15
y hago visible 00:18:16
la letra de usuario 00:18:18
el espacio para meter la letra 00:18:22
inicializo el número de intentos 00:18:23
porque se pueden haber quedado 00:18:26
a cero del último juego que yo hice 00:18:28
lo reinicializo a 6 00:18:30
para que tenga 6 intentos 00:18:32
o los que yo quiera 00:18:34
y la etiqueta que me muestra 00:18:35
las usadas 00:18:39
la reinicializo y la pongo a hacer otra vez 00:18:40
porque puedo venir de un juego anterior 00:18:42
donde la etiqueta ya tenía 00:18:44
vale, pues todo este código de aquí 00:18:46
es el código de iniciar juego 00:18:52
entonces ya este action perform 00:18:54
ya se está haciendo 00:18:57
muy largo, ya se me queda una clase muy larga 00:18:59
sería mucho más bonito 00:19:01
sacar esto a un método aparte 00:19:02
iniciar juego, por ejemplo 00:19:04
y queda mucho más claro 00:19:06
Saco todo esto a iniciar juego y llamo desde aquí iniciar juego, porque lo que hace esto es iniciar juego. 00:19:08
Crea palabra aleatoria, hace visibles e invisibles los text fields que toquen y hace visible la letra de usuario, reinicializa intentos y reinicializa etiqueta de letras usadas. 00:19:16
Pues todo esto de aquí, mejor si lo meto en un método de iniciar juego. 00:19:29
Fijaos, podemos empezar a usar la refactorización del entorno de desarrollo y así nos ahorramos trabajo. 00:19:41
¿Qué es refactorizar? 00:19:53
Que ya en entornos de desarrollo igual ya habéis mencionado esa palabra. 00:19:55
¿La habéis mencionado la palabra refactorizar? 00:19:59
Creo que no. 00:20:01
Vale. 00:20:02
bueno, pues refactorizar 00:20:02
un código 00:20:06
es cambiarlo 00:20:06
para que sea más bonito 00:20:08
a los ojos del usuario 00:20:11
pero su funcionalidad 00:20:14
y su comportamiento no cambia 00:20:16
nada 00:20:17
es decir, cuando uno termina 00:20:18
justo 00:20:20
cuando uno acaba un código 00:20:23
ese código yo lo he verificado, funciona perfectamente 00:20:24
quiero que haga esto porque funciona estupendamente 00:20:28
vale, pero que código más feo 00:20:30
pues tengo unos métodos así de largos 00:20:32
unos métodos así de largos 00:20:34
quedan feísimos 00:20:36
me gustaría más partirlo en trocitos 00:20:37
y cada trocito llevarlo a un método aparte 00:20:40
y entonces de ese método largo 00:20:42
me limito a hacer las llamadas 00:20:44
lo que va a hacer la máquina virtual es lo mismo 00:20:45
va a hacer el mismo código, no va a cambiar nada 00:20:48
pero para el usuario 00:20:50
es más legible 00:20:52
pues eso es refactorizar, refactorizar no cambia 00:20:53
para nada el funcionamiento del código 00:20:56
va a hacer lo mismo 00:20:58
pero el código queda como más legible y más ordenadito 00:21:00
eso es refactorizar 00:21:03
y realmente hay diferencias 00:21:04
entre un código legible 00:21:07
y un código no legible 00:21:09
hay diferencias 00:21:10
a la hora de incorporar algún cambio 00:21:12
encontrar algún error que te ha salido 00:21:15
luego después de un mes usándolo 00:21:17
etcétera 00:21:19
hay cosas 00:21:20
hay procedimientos de refactorización 00:21:22
muy estándar, por ejemplo 00:21:25
cuando uno tiene un método larguísimo 00:21:27
eso te pide rápidamente 00:21:29
el cuerpo una refactorización 00:21:31
que es, perdona, ese método larguísimo 00:21:33
lo voy a sacar a otro sitio 00:21:35
otro método, lo llamo desde este, etc. 00:21:37
Hay una refactorización 00:21:40
que ya estamos haciendo muchas veces 00:21:41
que es cambiar el nombre de una variable 00:21:43
eso es, ahí también estamos 00:21:45
cambiando el código para hacerlo más legible 00:21:47
por ejemplo, esta variable de aquí 00:21:49
button new button, lo hemos dejado 00:21:51
porque va, nos da igual, este es el botón 00:21:53
de jugar 00:21:55
el botón de jugar 00:21:56
entonces 00:21:57
una refactorización interesante 00:21:59
sería cambiar el nombre 00:22:02
de esta variable y llamarla botón jugar 00:22:04
por ejemplo 00:22:06
pero claro, hay que tener cuidado porque 00:22:08
tendríamos que cambiársela en todas partes 00:22:10
donde aparece, en todas partes 00:22:12
el eclipse te ayuda, afortunadamente 00:22:14
si seleccionamos esto 00:22:16
le damos al botón derecho 00:22:18
y os vais a refactor 00:22:20
¿vale? pues en refactor 00:22:22
tenemos un rename, que es 00:22:24
Por favor, refactorízame cambiando el nombre de esta variable. 00:22:25
Entonces, el entorno de desarrollo te va a cambiar el nombre ahí 00:22:32
y en cualquier parte donde aparezca esa variable. 00:22:37
¿Vale? Un segundito, vamos a hacerlo. 00:22:40
Un momento. 00:22:41
Le damos a rename. 00:22:42
¿Qué nombre le quieres poner? 00:22:44
Botón jugar. 00:22:46
Enter. 00:22:47
Y veis, la ha cambiado en todas partes automáticamente. 00:22:48
¿Vale? Luego esta es una refactorización típica. 00:22:52
Cambiar el nombre de una variable 00:22:55
Y la hacemos mediante pues esto 00:22:56
Botón derecho 00:22:58
Si yo quisiera cambiar este, que no quiero 00:23:00
Pues le digo 00:23:02
Oye refactor, cámbiamelo 00:23:04
Papi, pones ahí lo que sea 00:23:06
Enter y te lo cambia en todas partes 00:23:08
Vale, esta es una refactorización típica 00:23:10
Dime 00:23:12
No, no, en general 00:23:13
Una variable 00:23:18
De una aplicación normal 00:23:19
Claro, en general tú tienes un código 00:23:21
Y el nombre de la variable no está muy bien elegido 00:23:25
porque no es muy claro, porque recordad 00:23:27
de principio de curso que decíamos 00:23:30
que los nombres de las variables y los métodos 00:23:32
tenían que ser lo más explicativos posibles 00:23:34
aunque fueran muy largos 00:23:36
una variable x 00:23:37
es una variable muy mal elegida 00:23:38
a menos que represente la coordenada x 00:23:41
de un algo 00:23:44
pero una variable que se llame x o que se llame num 00:23:45
son nombres horribles 00:23:48
entonces es mucho mejor que la variable se llama 00:23:49
número de intentos 00:23:51
aunque sea un nombre muy largo, ¿qué más da? 00:23:53
pues entonces 00:23:55
un código que no tenga las variables con nombres 00:23:56
bien elegidos, lo puedes refactorizar cambiando 00:23:59
el código y no tienes que ir tú 00:24:01
aparición por aparición, la herramienta 00:24:03
de refactorización del entorno de desarrollo ya te 00:24:05
las busca en todas partes, vale 00:24:07
bueno, pues esto venía a cuento de que aquí hay una 00:24:09
refactorización que nos interesa 00:24:11
que es la de un código 00:24:13
que ha quedado muy largo, extraerlo 00:24:15
a otro método auxiliar y así 00:24:18
desde el original llamamos a este 00:24:19
y el código queda más bonito 00:24:21
vale, venía a efectos 00:24:23
de lo que había dentro del evento de jugar 00:24:26
que era todas estas sentencias 00:24:28
que son las 00:24:30
sentencias que lo que 00:24:32
significan es inicia juego 00:24:33
significan eso, significa inicia juego 00:24:36
entonces como el juego 00:24:38
puede que yo quiera iniciarlo 00:24:39
en otros puntos, no solamente ahí 00:24:41
lo pueda iniciar, igual 00:24:43
mi aplicación va aumentando 00:24:45
y hay otros puntos de mi aplicación donde yo 00:24:47
quiera iniciar juego, pues 00:24:49
hombre, tiene sentido que todo ese código 00:24:51
que se ha quedado ahí ya muy largo dentro 00:24:54
de la clase anónima, con lo cual 00:24:55
ya esto se me ha quedado 00:24:57
ahí un código larguísimo 00:24:59
dentro del otro, pues tiene 00:25:01
sentido que yo saque eso, un método auxiliar 00:25:03
y ya llame a ese método auxiliar 00:25:05
desde donde quiera, el código va a ser más legible 00:25:07
pues o lo hacemos a mano 00:25:10
nos hacemos un método dentro de mi propia 00:25:11
clase, simplemente 00:25:13
que ponga iniciar 00:25:15
hago corta copia y pega de eso 00:25:17
que tardo 3 segundos 00:25:19
o lo hago refactorizando 00:25:21
con la herramienta del eclipse que tardo 00:25:24
cinco segundos, da igual 00:25:25
a elegir, a mí siempre me gusta hacer las cosas 00:25:27
manualmente, pero a vosotros 00:25:30
no, porque sois muy vagos 00:25:32
es verdad, lo sois 00:25:33
a ver, yo os enseño a sobrevivir, os enseño 00:25:35
a que parezca que sepáis, a que 00:25:41
se la consigáis colar 00:25:43
a los entrevistadores en las entrevistas 00:25:45
de trabajo, entonces os tengo que dar todos los recursos 00:25:47
posibles para que parezca que sepáis 00:25:50
y en el periodo de prueba digan 00:25:52
hostia como controla este tío 00:25:54
es importante parecer 00:25:55
si luego encima sabes 00:25:59
ya eres el crack 00:26:00
al refactorizar 00:26:02
bueno pues 00:26:08
dios mío 00:26:09
has cambiado de opinión y te has venido primero 00:26:12
si se puede 00:26:13
si si si 00:26:16
Con garantía de vuelta, me responsabilizo. 00:26:17
Pablo, ¿tú has dicho que tienes? 00:26:34
¡Hala, mira qué majo! 00:26:37
Venga, pues vamos a sacar esto a otro método. 00:26:40
Pues bueno, seleccionamos todo el código a sacar. 00:26:45
botón derecho, refactor 00:26:47
que es la palabra clave 00:26:50
botón derecho, refactor 00:26:51
y de todas las opciones 00:26:54
que me da 00:26:56
hay una, o debería dármela 00:26:56
que la he visto antes 00:26:59
ah, extract method, vale 00:27:00
que no la veía, ¿veis? 00:27:03
de todas las opciones que me da 00:27:06
el refactor 00:27:08
me dice, extrae method 00:27:10
justo lo que quiero 00:27:12
saca eso a otro método 00:27:14
sí o no, sácalo a otro método 00:27:15
el move es como move 00:27:17
no sé qué es lo que move 00:27:22
no lo sé, que yo no me meto a probar 00:27:24
cosas en los botoncitos 00:27:26
claro, yo soy experta 00:27:27
en aparentar que sé 00:27:32
hace el favor 00:27:33
entonces si somos vagos no pasa nada 00:27:34
a ver 00:27:37
lo que querías es llevar las dos cosas 00:27:41
porque hay que saber muchísimo 00:27:43
de eso no hay ninguna duda, tienes que controlar 00:27:45
y tienes que haber currado un juego 00:27:47
un huevo 00:27:49
tienes que haber currado muchísimo 00:27:50
y saber mucho y echarle muchas horas 00:27:53
eso sí que es incuestionable 00:27:55
pero además 00:27:57
tienes que saber demostrarlo 00:27:59
desgraciadamente la imagen 00:28:01
desgraciadamente cuenta un montón 00:28:03
entonces si tú sabes un montón 00:28:05
pero no consigues venderlo 00:28:07
no consigues que parezca que sabes 00:28:09
con esas chorradas 00:28:11
que los jefes y la gente 00:28:12
que no tienen idea interpretan 00:28:14
que significa saber, pues si tú no sabes 00:28:16
esas chorradas que ellos interpretan que significa 00:28:18
saber, pues entonces a lo mejor 00:28:21
no se creen que sabes, entonces 00:28:22
hay que moverse un poco en el terreno de 00:28:24
la realidad, en el terreno de lo que 00:28:26
vale y en el terreno de la apariencia 00:28:28
tenéis que saber moverse en el de la apariencia 00:28:31
en el de aparentar también, desgraciadamente 00:28:32
¿por qué la gente va tan bien vestidita 00:28:34
a los curros? ¿eso les hace mejores trabajadores? 00:28:37
en absoluto, pero 00:28:39
parece que hay que 00:28:40
venga, pues extraemos método 00:28:42
vale 00:28:47
vale, y te dice aquí 00:28:48
¿qué nombre le quieres dar a ese método? 00:28:51
a ese método le queremos 00:28:54
dar iniciar 00:28:55
iniciar juego 00:28:57
¿vale? 00:28:59
iniciar juego 00:29:02
venga 00:29:03
¿a dónde queremos mandar ese método? 00:29:06
ahorcado, me dice 00:29:12
a la propia, porque tengo dos clases 00:29:15
aunque no lo parezca, recordad 00:29:16
que yo tengo dos clases en esta 00:29:19
en esta clase, la app 00:29:21
ahorcado, la frame y tengo la anónima 00:29:22
que está ahí dentro, la anónima 00:29:25
tengo dos, pues me dice 00:29:26
ese método que quieres que sea 00:29:28
un método de tu clase 00:29:30
ahorcado o un método de la anónima 00:29:32
si lo hago como método de la 00:29:34
anónima, no he ganado nada 00:29:36
porque lo que yo quería precisamente era que ese 00:29:38
newActionListener no estuviera así de gordo. 00:29:40
Si lo saco como a método de la anónima 00:29:43
tampoco ha ganado tanto, ¿verdad? 00:29:45
Vamos a sacarlo a método de la clase anónima. 00:29:46
Vale. 00:29:50
Si lo sacamos a método de la clase anónima, 00:29:52
esta es mi clase anónima, que llama 00:29:54
a iniciar juego 00:29:56
e iniciar juego está justo aquí debajo, pero dentro 00:29:57
de la misma clase anónima. 00:30:00
No he ganado nada, porque yo lo que 00:30:02
quería era que este 00:30:04
adActionListener no me quedara tan largo. 00:30:06
No he ganado nada, entonces vamos a deshacer esto. 00:30:08
esto no queremos, vale, vamos a sacar este método, Ana, hoy no me voy a equivocar, ni una sola vez, 00:30:10
y me temo que voy a llamarte la atención muchas veces, así que, justo, efectivamente, ahí le has dado, 00:30:24
extraemos método otra vez 00:30:36
iniciar juego 00:30:38
iniciar juego 00:30:40
a qué clase 00:30:44
queremos que pertenezca ese método 00:30:45
de todas las 00:30:48
él me detecta que hay dos, la anónima 00:30:50
podría haber clases internas 00:30:52
de todo, o la propia 00:30:54
quiero sacarlo a aparcado 00:30:56
se llama iniciar juego 00:30:58
ok, ala 00:30:59
ahora ya, mi clase anónima 00:31:01
llama a iniciar juego 00:31:03
y ya se queda esto más cortito. 00:31:06
Ya este constructor que construye la aplicación 00:31:08
en el AdaptionListener ya tiene 00:31:11
algo más corto. ¿Qué ahora yo quiero ver? ¿Qué hace 00:31:12
iniciar juego? Pues, hombre, 00:31:14
iniciar juego está 00:31:17
aquí debajo, justo 00:31:18
cuando ya acaba mi constructor, es un método de la clase 00:31:20
e iniciar juego 00:31:23
pues hace lo que yo le he metido. 00:31:24
Fijaos que listo ha sido. 00:31:28
Él ha detectado 00:31:30
que esta variable que usa iniciar 00:31:31
juego, la variable esta tan 00:31:34
fea de 00:31:36
escoja letra 00:31:37
ha detectado que es una variable 00:31:39
local del constructor. 00:31:42
Vámonos arriba a mi constructor 00:31:44
de aparcado. Esta 00:31:46
variable, esta 00:31:49
la de pruebe letra, es local 00:31:51
del constructor. 00:31:53
Luego hay que pasársela 00:31:55
al método si quiere trabajar con él. 00:31:57
Si esta variable no fuera local 00:31:59
del constructor, sino que fuera una variable 00:32:01
de mi clase como estas, 00:32:03
no habría que habersela pasado al método. 00:32:05
¿vale? porque el propio método ya habría 00:32:07
podido acceder a ella, porque sería 00:32:10
una variable de clase, de mi clase app 00:32:12
ahorcado, pero 00:32:14
el builder me la ha metido 00:32:16
aquí, dentro del constructor, me la ha metido 00:32:18
local al método, la declaración 00:32:20
me la ha metido ahí 00:32:22
esta variable, entonces como me la ha metido ahí 00:32:23
la herramienta de refactorización ha dicho 00:32:26
oye, como esta variable es 00:32:28
local al método, no es de la clase 00:32:30
te la tengo que 00:32:32
pasar a ti, iniciar juego para que trabajes 00:32:34
con ella y se la ha pasado. 00:32:36
¡Qué feo esto! 00:32:38
¡Qué feo! Vamos a sacar 00:32:41
la variable de clase 00:32:42
y ya está. Y no hace falta que se la pasemos 00:32:43
a iniciar juego. Porque si no estamos 00:32:46
condenados, cada vez que ya hemos iniciado juego, 00:32:48
pasarle esa etiqueta. 00:32:50
¡Vaya birria! ¿Vale? Nosotros sabemos 00:32:52
programar, sabemos hacer las cosas bien, independientemente 00:32:54
de que nos hagan las cosas. 00:32:56
Vale, pues vamos a sacar 00:32:58
esta variable de aquí 00:32:59
a variable de clase. 00:33:01
Facilísimo. 00:33:07
la declaro 00:33:07
la clase 00:33:11
la declaro aquí 00:33:12
ya es variable de clase 00:33:14
y aquí me limito a 00:33:23
instanciarla solamente 00:33:25
ya es variable de clase 00:33:27
la he declarado fuera 00:33:31
está aquí 00:33:32
con lo cual ahora ya mi constructor 00:33:34
mi método de constructor que construye y lo hace todo 00:33:38
lo único que tiene que hacer es 00:33:41
instanciarla y colocarla 00:33:42
pero ya está declarada como variable de clase 00:33:44
entonces al estar declarada como variable de clase 00:33:47
este método iniciar juego 00:33:49
que está aquí 00:33:52
puede acceder a ella 00:33:54
sin que se la pasemos por parámetro 00:33:55
no necesita que se la pasemos 00:33:57
porque es una variable de clase 00:33:59
que está arriba 00:34:01
entonces ya no lo necesita 00:34:02
antes sí porque era una variable local 00:34:05
al constructor 00:34:07
ahora no porque es una variable que está arriba 00:34:08
no hace falta que se la pasemos 00:34:11
entonces mucho mejor me queda iniciar juego más limpio 00:34:11
vale, entonces ahora ya cuando le llamemos 00:34:14
desde el este, iniciar juego 00:34:17
pues esto fuera 00:34:19
vale 00:34:20
bueno, pues estos 00:34:22
pequeños detalles, esto es lo que tenéis 00:34:24
que controlar como si fuera beber agua 00:34:27
o coca cola 00:34:29
o lo que fuera, porque esto 00:34:31
es programar, vale, el tener todo esto 00:34:33
claro, el saber el ámbito local de las variables 00:34:35
el paso de parámetros, el cómo, todo esto 00:34:37
vale, todo esto 00:34:39
nadie va a programar por vosotros 00:34:40
es que ni siquiera ChatGPT va a programar 00:34:43
ChatGPT 00:34:45
no, que no, no os engañéis 00:34:47
ChatGPT te hace muchísimas cosas 00:34:49
y te ahorra muchas horas de trabajo 00:34:51
solo eso 00:34:53
pero no te puede sustituir 00:34:55
nunca va a programar como tú 00:34:57
ni te va a hacer tu trabajo porque no puede hacerlo 00:34:59
como tú, pero ayuda así 00:35:01
tú tienes un esclavo 00:35:03
maravilloso 00:35:05
claro, pero esa ya la tienes que 00:35:06
controlar a alguien. Entonces, ¿tú quieres ser 00:35:13
de los que han echado o quieres 00:35:15
ser de los que sabe 00:35:17
usar el resultado de esas sillas? Porque esas sillas no se 00:35:18
suben a producción directamente. Si suben a producción, 00:35:21
se cae el planeta. 00:35:23
Esas sillas, luego las utiliza 00:35:25
alguien para todo lo que ha generado, 00:35:27
ya darle la vuelta y ya subirlo 00:35:29
a producción. Entonces, 00:35:31
lógicamente, 50 personas no hacen falta. 00:35:32
Pero 4 sí. Pues bueno, 00:35:35
ser de esas 4. 00:35:37
Dime. 00:35:39
A ver, siempre puedes 00:35:43
Y es lo recomendable, hacerlo a mano 00:35:45
Tú te has dado cuenta de que esto 00:35:47
Es demasiado código 00:35:48
Pues te haces un método en la clase 00:35:50
Te haces un método y lo metes 00:35:53
Luego lo llamas y ya está 00:35:55
Que quieres usar la refactorización del eclipse 00:35:56
Que te va a liar más que otra cosa 00:35:59
Y puede que te lo haga mal, pero si controlas mucho 00:36:00
Pues a lo mejor no 00:36:02
Pues lo único que he hecho ha sido 00:36:03
Seleccionar 00:36:05
A ver 00:36:07
ya lo tengo, vale 00:36:08
pues este era todo el código 00:36:16
que estaba dentro del action perform 00:36:19
todo este código que quería yo sacarlo a método auxiliar 00:36:21
pues he seleccionado todo el código 00:36:23
refactor 00:36:25
porque refactor 00:36:27
sabes lo que es, no te he pillado dormido 00:36:29
cuando lo he explicado 00:36:31
vale, pues refactor 00:36:32
porque lo que quiero es cambiar el código 00:36:35
refactor, extrae a método 00:36:36
y ya está 00:36:38
y que hemos hecho en extraer a método 00:36:40
le hemos dicho 00:36:43
el nombre que queremos que tenga ese método 00:36:46
y aquí 00:36:49
a cual de las dos clases 00:36:50
que tiene el fichero, porque el fichero 00:36:53
tiene la clase anónima 00:36:55
tiene la clase anónima 00:36:57
y la clase 00:37:00
grandota, la clase que 00:37:02
tiene el frame, me dice, ¿quieres que sea 00:37:04
método de la clase anónima o quieres 00:37:06
que sea método de tu frame? hombre, quiero que 00:37:08
sea método de mi frame, si lo estoy sacando 00:37:10
de la clase anónima no es para que sea un método 00:37:12
de la propia clase anónima, entonces no he ganado 00:37:14
nada en cuanto a legibilidad 00:37:16
quiero que sea 00:37:18
un método del pre, pues lo he sacado de ese método 00:37:20
y ya está, y luego reviso que el código esté 00:37:22
bien y al revisarlos cuando veo 00:37:24
¿para qué pasar la etiqueta? 00:37:26
hazla como variable global y no se la tienes que pasar 00:37:28
¿vale? 00:37:30
y ahora, ¿cómo hago yo para ir para adelante 00:37:34
todo lo que he deshecho? ¿se puede? 00:37:36
Control Y, ¿no? 00:37:42
Pues venga, vamos a... 00:37:48
Vale, ya estoy en el futuro. 00:37:54
Vale, pues ya estamos en el futuro. 00:38:01
Venga, pues entonces... 00:38:04
El evento del botoncito ya está. 00:38:08
¿Alguien tiene alguna duda sobre el evento del botoncito? 00:38:12
todo recogido en un método, iniciar juego y listo, ¿vale? 00:38:15
Que lo podríamos llamar desde cualquier sitio, ¿vale? 00:38:20
Entonces, al iniciar juego vamos a ponerle un set test jugando, 00:38:23
sí, ahora paramos, para que el botón también se ponga jugando 00:38:28
y así, el botón jugar, ¿cómo se llamaba? 00:38:34
Le refactorice y le cambia el nombre, ¿verdad? 00:38:40
Botón jugar, vale. 00:38:43
Entonces, voy a cambiarle el texto también desde iniciar para 00:38:45
que se ponga jugando y se haga set visible, 00:38:49
set enable, false, para que se vea. 00:38:52
Entonces, botón jugar. 00:38:54
Voy a añadir ya en el método, botón jugar, punto, 00:38:57
set test, jugando y que lo deshabilite para que no se pueda 00:39:05
volver a dar en medio del juego. 00:39:15
botón jugar 00:39:16
punto set enable 00:39:19
false 00:39:21
vale 00:39:23
ahora antes de que nos vayamos 00:39:25
porque el compilador me dice 00:39:27
se me pone rojo 00:39:29
perfecto muy bien porque botón jugar 00:39:30
está dentro del método 00:39:37
constructor declarado 00:39:39
entonces como está dentro 00:39:40
declarado pues no puedo acceder 00:39:42
desde 00:39:45
como está dentro declarado 00:39:47
no puedo acceder desde aquí fuera 00:39:50
pues hombre, no pasa nada 00:39:52
lógicamente 00:39:54
vale 00:39:56
a ver, aquí 00:39:58
estas cosas 00:40:02
dejad de hacerlas desde ya 00:40:04
lógicamente, que es 00:40:06
solucionarlo con lo que me dice el eclipse 00:40:07
el eclipse te dice burradas, obviamente 00:40:10
que me ofreces 00:40:12
para cambiar esto, créame una variable 00:40:14
local jugar, que bien, que bonito 00:40:16
Ya está, estupendo 00:40:18
Ya se me puede quitar ese error 00:40:21
Tengo una variable local, jugar 00:40:22
Pero no ha arreglado nada 00:40:24
Y así podría seguir hasta el infinito arreglando 00:40:28
Vale, inicializa variable 00:40:30
¡Hala! Se acabó el error de compilación 00:40:32
Ahora uno entrega el examen 00:40:35
Y dice, hostia, un examen que te cagas 00:40:37
Pero que burrada ha hecho uno 00:40:40
Yo no quiero 00:40:41
Crear un botón local 00:40:43
Y cambiarle a ese el texto 00:40:45
Quiero cambiárselo al otro 00:40:46
vale, cuidado con lo de 00:40:47
ti, ti, ti, el Eclipse me dice esto 00:40:50
lo hago, el Eclipse me dice 00:40:52
que me tire por un puente, me tiro, porque me subís 00:40:54
exámenes que son de tirarse por un puente 00:40:56
vale, entonces no es esto 00:40:57
estoy harta de mi familia 00:40:59
botón jugar, lo que quiero es sacarlo 00:41:04
a variable 00:41:07
variable 00:41:09
de clase, pues venga, no pasa 00:41:11
nada, nos vamos a botón jugar 00:41:13
y como os gustan 00:41:15
las vaguerías y ya con esto para 00:41:17
Digitamos, tú, ¿cómo te llames, Pedro? 00:41:19
Botón jugar, puedo sacar la variable de clase como hemos hecho antes con la etiqueta. 00:41:23
La hemos declarado fuera. 00:41:28
Pero si nos vamos a la herramienta de diseño, como botón jugar está en la de diseño. 00:41:31
Botón jugar está en la herramienta de diseño. 00:41:38
¿Veis que aquí hay un botoncito muy mono? 00:41:40
Pues leed la ayuda que te dice este botoncito cuando lo pulsáis. 00:41:44
este botoncito te dice 00:41:48
lleva esta variable de variable local 00:41:51
a campo de la clase 00:41:53
pues otra cosa que me permite hacer 00:41:54
si soy vago 00:41:57
cambiarla de variable local 00:41:58
a variable de la clase 00:42:00
que es justo lo que yo quería 00:42:02
en lugar de hacerlo por el código 00:42:04
que tardó un segundo 00:42:06
lo puedo hacer por aquí que tardó tres 00:42:07
he tardado más pero como lo he hecho a lo vago 00:42:10
pues se puede hacer desde aquí 00:42:12
pero vamos es por lo que os decía antes 00:42:16
para que no digáis que no os enseño 00:42:18
las cosas para adolescentes vago 00:42:20
bueno, eso 00:42:21
entonces vamos a subirlo 00:42:23
ya está 00:42:26
te habría ahorrado mucho tiempo, ¿verdad? 00:42:27
muchísimo 00:42:30
vale, como veis, si ya la habéis 00:42:30
subido a variable de clase 00:42:34
el botón cambia de forma 00:42:36
el botón cambia porque ahora 00:42:37
podríamos hacer el inverso, que es pasar 00:42:40
de campo de clase a variable local 00:42:42
¿vale? pero 00:42:44
bueno, ya la hemos pasado 00:42:45
y efectivamente, patapum 00:42:48
ya se ha 00:42:51
subido ahí 00:42:52
se ha subido ahí 00:42:54
y ahora ya mi método 00:42:57
de inicializar, ahora ya puede 00:42:59
acceder, o sea, ya he dado la solución 00:43:01
correcta al error de compilación 00:43:03
no la solución incorrecta 00:43:05
y ahora efectivamente, pues esto ya funciona 00:43:06
pone jugando 00:43:09
y ya está, vale 00:43:10
venga, ahora sí que paramos 00:43:13
Gracias. 00:43:14
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:
12
Fecha:
17 de marzo de 2025 - 10:23
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 17″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
204.94 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid