Saltar navegación

Clase 19-04-24 -3 - Contenido educativo

Ajuste de pantalla

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

Subido el 21 de abril de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

aquí en lo que estábamos ahora es que 00:00:00
bueno, la estructura de la aplicación ya está 00:00:02
esto ya es una aplicación que funciona y hace cosas 00:00:04
pero hombre 00:00:06
no queremos que haga esto, esto no es lo que queremos que haga 00:00:07
lo que queremos 00:00:10
que haga esta aplicación cuando yo le doy 00:00:12
al botón es 00:00:14
leer lo que hay en este 00:00:18
texto, que habrá algún 00:00:24
método, este componente 00:00:25
takes fill tendrá algún método para devolverme 00:00:28
lo que hay dentro, recordad que cada 00:00:29
componente de swing tiene tropecientos 00:00:31
mil métodos para hacer lo que yo 00:00:33
quiera hacer con él, pues si este área 00:00:35
de texto es para meter cosas, algún 00:00:37
método tendrá que me devuelva lo que hay 00:00:39
dentro, claro 00:00:41
cuando ya tengo eso que está dentro 00:00:42
operar 00:00:45
cuando ya he operado 00:00:46
generar el resultado y 00:00:49
ponérselo como texto 00:00:51
a esta etiqueta, la etiqueta 00:00:53
tendrá algún método para cambiar el texto 00:00:55
tendrá métodos para hacer mil cosas, una de ellas 00:00:57
para cambiar el texto, pues todo eso 00:00:59
es lo que yo quiero hacer 00:01:01
todas esas sentencias que he dicho 00:01:03
son las que yo quiero 00:01:05
meter aquí dentro 00:01:07
en lugar de estas, esto no quiero meterlo 00:01:08
vale, pues entonces 00:01:12
lo primero que tendremos que hacer aquí es 00:01:15
hemos dicho, coger el texto que hay en el área 00:01:17
de texto, eso es lo primero 00:01:19
que necesitamos hacer, vale 00:01:21
coger el texto del área de texto 00:01:30
pues ya tenemos el primer problemón, ¿no? 00:01:32
que el área de texto 00:01:35
¿dónde está? 00:01:36
el área de texto es una variable 00:01:38
local del constructor 00:01:40
luego ya está 00:01:42
nos hemos encontrado el primer problema 00:01:46
¿cómo voy a llegar 00:01:48
yo aquí al área de texto? 00:01:50
o sea, si yo consigue el área de texto 00:01:52
algún método tendrá para coger el 00:01:54
contenido, pero es que 00:01:56
esto ya es un problema de programación 00:01:57
el que os planteo 00:02:00
esta variable 00:02:01
mi jtextfield dato 00:02:03
que es a la que yo quiero acceder 00:02:07
dato efectivamente 00:02:09
si yo me pongo 00:02:11
dato efectivamente pues 00:02:12
tiene un 00:02:27
método 00:02:29
estupendo, getText 00:02:32
que si yo leo la ayuda, te dice 00:02:35
te devuelve el texto que está dentro del 00:02:36
componente, ah genial 00:02:38
este es el método 00:02:40
que yo quiero, vale 00:02:42
esta parte la tengo resuelta 00:02:44
pero ostras, el problema 00:02:46
que tengo es que 00:02:49
esta variable dato, esta variable es una variable local 00:02:49
a este método, a este bloque 00:02:56
luego como bien sabemos, una variable solo es visible, accesible 00:02:59
dentro del bloque en el que está declarada 00:03:04
luego esto solo es visible y accesible dentro de este bloque 00:03:07
¿vale? luego 00:03:11
aquí, dato 00:03:15
Que yo querría hacer esto 00:03:18
Pues dato no puedo 00:03:20
Yo querría esto, ¿no? 00:03:24
Yo querría esto 00:03:30
Pero dato no es visible 00:03:31
¿Vale? 00:03:32
Bueno, pues ¿qué arreglos, qué apaños podemos hacer? 00:03:34
¿Qué cosas se os van ocurriendo que podamos hacer? 00:03:38
Hay desde la opción más sencilla y más patatera 00:03:42
Hacia la que es ya más sofisticada 00:03:44
Y que es la que se hace 00:03:47
Que es la que tenemos que aprender 00:03:48
Pero la primera que se os ocurriría con lo que sabéis 00:03:51
Hombre, lo primero que se os ocurriría es 00:03:54
¿Qué es lo primero que se os ocurriría? 00:04:00
Así de buenas a primeras 00:04:04
¿Cómo que importa? 00:04:05
¿Importar es importante? 00:04:08
Habría que sacarla afuera 00:04:11
Eso para empezar 00:04:12
Habría que sacarla afuera 00:04:13
¿No? 00:04:14
Vale, pero sacándola afuera, ¿qué solucionamos? 00:04:17
Sacándola afuera 00:04:20
Ahora es una variable 00:04:21
¿Eh? 00:04:23
Pero podéis llamarla como 00:04:26
Imagínate que yo hará JTextField 00:04:27
Vamos a, en lugar de declararla aquí 00:04:29
Yo aquí la 00:04:30
Puedo instanciar y hacer todo lo que sea 00:04:32
Pero la declaro aquí 00:04:35
Ahí 00:04:36
JTextField 00:04:41
Dato 00:04:47
Está ya declarada afuera, ya es una propiedad 00:04:49
De la clase 00:04:52
Luego sí, luego ya está 00:04:53
Aquí está construida, añadida al panel 00:04:55
Eso es lo de menos 00:04:58
Pero donde está declarada, marca su visibilidad 00:04:59
Está declarada afuera 00:05:02
ahora mismo que ha arreglado 00:05:03
no ha arreglado nada 00:05:08
o sea dato aquí 00:05:10
poniendo la static 00:05:11
ahora ya si tendría más 00:05:15
si yo la pongo static 00:05:17
que más tendría que cambiar aquí 00:05:20
para poder acceder a ella 00:05:25
claro tendría que poner el nombre de la clase 00:05:27
ventana 00:05:32
disiesto 00:05:49
vale 00:05:51
hacerle public porque está en paquete 00:05:58
diferente, ¿no? como lo he puesto 00:06:03
en paquete diferente, en mi caso, no sé en el vuestro 00:06:05
vale, bueno, a ver 00:06:07
así un apaño 00:06:11
tengo hecho 00:06:13
pero tengo que hacer, sacar 00:06:14
todos los componentes que me interesen fuera 00:06:16
hacerlos 00:06:19
estáticos y públicos 00:06:21
entonces, hombre, a ver, hacerlos 00:06:23
estáticos, hacer una variable estática 00:06:25
cuidado, puede tener sus implicaciones 00:06:27
en este caso, con lo sencilla que es mi aplicación 00:06:29
no, ya sabéis la implicación 00:06:31
que tiene hacer una variable estática 00:06:33
es que ahora cualquier instancia 00:06:34
que yo haga de esta misma clase 00:06:37
cualquier instancia 00:06:39
ya va a compartir 00:06:40
esa variable, entonces las variables 00:06:43
estáticas, cuidado, son variables compartidas 00:06:45
por todas las instancias de una clase 00:06:47
luego los efectos secundarios 00:06:49
pueden ser brutales, yo modifico 00:06:51
en una clase 00:06:53
y la 00:06:55
modificación se ve en todas las demás 00:06:57
porque es compartida, en este caso 00:06:59
si yo tuviera varias instancias 00:07:01
de ventana bisiesto 00:07:03
y cambiara text fill en una 00:07:04
el text fill me cambiaría en todas las demás automáticamente 00:07:07
me cambiaría en todas 00:07:09
imaginaos que le cambio el color 00:07:10
a este objeto ventana, le cambio el color 00:07:14
el color me cambia en todas las demás 00:07:17
me ha cambiado en todas, porque es estática 00:07:19
ahora mismo aquí solo tengo una ventana 00:07:21
entonces bueno, no habría problema 00:07:22
pero en general, cuidado, las variables 00:07:25
static se usan de forma 00:07:27
muy medida 00:07:29
y en los contextos 00:07:30
no normalmente para solucionar un problema 00:07:32
de acceso, cuando tengo que solucionar un problema 00:07:34
de acceso me busco otra forma más segura 00:07:36
ahora veremos cómo 00:07:38
las variables static se hacen cuando lo que 00:07:39
representan es esa idea 00:07:42
que es la idea de algo compartido 00:07:43
la idea de algo global 00:07:45
cuando le dan la idea de algo global, sí 00:07:48
pero es que ese text field 00:07:50
él por definición 00:07:52
no es una cosa global 00:07:54
él es un text field que está en una ventana 00:07:55
que está en una ventana 00:07:57
luego, conceptualmente no es global 00:07:59
que solo tengo una 00:08:01
no pasa nada porque sea global, porque solo tengo una 00:08:02
pero yo tengo muchas que pasan 00:08:05
¿vale? 00:08:07
entonces, bueno, efectivamente 00:08:08
con esto soluciona el problema de acceso 00:08:11
pero importante, importante que hagamos los diseños 00:08:12
de manera que respondan a lo que 00:08:15
conceptualmente son las cosas 00:08:17
y aquí, este área de texto 00:08:18
no es una variable global a todas mis ventanas 00:08:21
esta variable texto 00:08:23
es un texto de ese objeto 00:08:25
ventana, vale, entonces bueno 00:08:27
vamos a optar por otras soluciones, vale 00:08:29
dentro de que esta es la que, bueno, la que yo 00:08:31
esperaba que 00:08:33
os surgiera 00:08:34
claro 00:08:37
vale, pues entonces yo no puedo acceder aquí 00:08:37
a dato, no puedo acceder a dato 00:08:41
porque no lo tengo 00:08:42
me lo estáis diciendo, no lo tienes, entonces jo, sería 00:08:44
magnífico, sería magnífico 00:08:47
si yo tuviera esto 00:08:49
como propiedad de mi clase 00:08:51
fuera una propiedad de mi clase 00:08:52
y entonces yo podría acceder a ella 00:08:59
¿vale? imaginaos que 00:09:03
dato es una propiedad de mi clase 00:09:06
entonces yo puedo acceder a ella, está claro, es una propiedad de mi clase 00:09:07
esta es una clase que estoy haciendo yo 00:09:10
puedo añadirle lo que me dé la gana 00:09:11
que implemente Action Leaser 00:09:13
no significa que yo no pueda añadir lo que quiera 00:09:16
significa simplemente que es capaz de escuchar 00:09:17
¿vale? pues si dato es una propiedad 00:09:19
de mi clase, magnífico, puedo acceder 00:09:21
pero claro, este dato 00:09:23
¿con qué valor se tiene que rellenar? 00:09:25
se tiene que rellenar 00:09:28
con el text field de la otra 00:09:29
vale, pero es que entonces 00:09:31
yo aquí no le he puesto constructor 00:09:33
porque no he querido, pues voy a hacerle un constructor 00:09:35
que reciba como parámetro 00:09:37
el text field de la otra 00:09:39
y lo inicia 00:09:40
y inicialice este dato con eso 00:09:43
y queda una estructura de programación 00:09:44
más bonita, algo a lo que 00:09:47
recurrimos siempre, cuando yo no tengo 00:09:53
acceso a algo, lo paso por parámetro 00:09:55
es algo que estamos resolviendo siempre 00:09:57
cuando mi aplicación trabaja con un map 00:09:59
mi método no lo tiene 00:10:01
se lo paso por parámetro 00:10:03
pues aquí igual 00:10:05
hago un constructor al que yo le paso 00:10:06
por parámetro 00:10:10
un text fill 00:10:10
le paso por parámetro un text fill 00:10:13
y uso ese text fill 00:10:17
que he pasado por parámetro 00:10:19
para inicializar 00:10:20
esta variable 00:10:22
¿vale? y ahora yo ya trabajo con esta 00:10:24
sin ningún problema, trabajo con esta 00:10:27
¿pero qué ocurre? 00:10:29
esto public, claro que no me puede instanciar 00:10:31
desde fuera 00:10:33
pues que ahora cuando haga captura 00:10:34
botón, le tengo que pasar el text field 00:10:36
con el que yo quiero que trabaje 00:10:38
con el que yo quiero que trabaje 00:10:40
¿y en qué momento he instanciado captura 00:10:41
pulsar botón? aquí abajo 00:10:44
esto me aparece de que 00:10:45
lo había declarado arriba y ya lo he quitado 00:10:53
ahí, sí, el static lo he quitado 00:10:56
ya, vale 00:11:00
y ahora, ¿dónde me aparece el error? 00:11:01
en el constructor que lo he cambiado 00:11:04
me dice, oye, que el constructor de captura 00:11:05
pulsar botón, el constructor, tienes que pasarle 00:11:08
el text fill, este, para que 00:11:10
lo use para inicializar su variable interna 00:11:12
y ya trabaje con ella 00:11:14
cuidado que ya tienes que pasar, ah, claro, perfecto 00:11:15
voy a pasarte 00:11:18
el text fill con el que quiero que trabajes 00:11:19
con este, fue, con este 00:11:21
text 00:11:24
pues venga, ala, magnífico 00:11:24
ya está 00:11:27
ya hemos solucionado el problema 00:11:29
del acceso a variables de la manera habitual 00:11:32
Mi método tiene que trabajar con algo 00:11:34
Pásaselo por parámetro 00:11:37
Y ya está 00:11:39
Pásaselo por parámetro y ya trabaja con él 00:11:40
Pues nada, se lo pasamos por parámetro 00:11:42
Inicializa la variable interna 00:11:45
Y ya trabaja con él 00:11:47
Para coger el año 00:11:48
Vale 00:11:49
Pues ahora, el text field ya lo tenemos 00:11:51
Para ver si esto no había 00:11:54
Un método que era de time 00:11:57
Que lo habías encontrado tú 00:11:58
Esto era, ¿cómo se llamaba el método? 00:12:02
¿Por qué letra empezaba? 00:12:04
Ah, no, la 00:12:05
Ah, que la dejaba Time 00:12:07
Me he liado yo con la clase, sí 00:12:11
gr.is 00:12:12
No, isLib 00:12:14
Vale, pues entonces 00:12:16
Yo le tengo que pasar este año 00:12:19
Pero este año está en string pasado entero 00:12:21
Pero bueno, el pasar entero 00:12:23
Lo hemos hecho muchas veces 00:12:25
Ya sabemos que hago esto 00:12:26
Y ya está 00:12:29
Y ahora 00:12:30
Este es un boolean que me dice si es vis y esto no 00:12:32
entonces 00:12:35
si es bisiesto 00:12:37
hago lo que tenga que hacer 00:12:40
ahora veremos a ver el que hago 00:12:42
y si no lo es 00:12:43
hago lo otro que tenga que hacer 00:12:45
claro, y ahora viene otra vez el problema 00:12:47
¿qué es lo que tengo que hacer si es bisiesto? 00:12:50
pues coger la etiqueta para el resultado 00:12:52
que es esta 00:12:55
la etiqueta result 00:12:55
y fijarle el texto que yo quiera 00:12:57
que tendrá un método para ello 00:12:59
de nuevo me pasa que no tengo aquí la etiqueta 00:13:00
no pasa nada, se la paso por parámetro 00:13:04
me preparo una variable de clase 00:13:06
para ella 00:13:08
me preparo una variable de clase 00:13:09
y se la paso 00:13:12
por parámetro 00:13:18
pues de nuevo, ya tengo 00:13:19
las dos variables que necesitaba 00:13:37
que las paso por parámetro y las inicializo 00:13:39
pero claro, en el constructor 00:13:41
otra vez 00:13:43
entonces ahora ya al constructor 00:13:44
le tendré que pasar 00:13:48
el text fill y la etiqueta 00:13:49
la etiqueta esta 00:13:52
le tendré que pasar esta 00:13:56
para que trabaje con ella 00:13:58
pues hala 00:14:00
ahora ya puede trabajar con la etiqueta 00:14:02
y que tiene que hacer con esa etiqueta 00:14:05
pues con esa etiqueta 00:14:07
tiene que fijarle un texto 00:14:09
que métodos tiene 00:14:10
si uno busca por aquí, anda, si tiene un método 00:14:12
set test, pues tiene la pinta que el método 00:14:15
set test es el que le pone el texto, no es cuestión de 00:14:17
investigar los métodos 00:14:19
que texto queremos poner si es vici esto 00:14:20
No es bisiesto. 00:14:22
¿Que no? 00:14:28
Pues queremos ponerle el otro. 00:14:29
No es bisiesto. 00:14:43
¡Hala! 00:14:49
Ahora ya sí que está terminada la aplicación. 00:14:50
A menos que hayamos hecho algo mal. 00:14:53
Ahora ya, el problema del método. 00:14:55
Que necesitaba el text field, necesitaba la etiqueta resultado. 00:14:56
Para operar con ella. 00:14:59
Escoger el año y mostrar el texto. 00:15:00
No las tiene porque son variables locales. 00:15:02
locales. Pues creamos aquí dos variables de clase a las que sí tiene acceso, obviamente, 00:15:03
porque son variables de su clase, y las inicializamos a través del constructor. Cuando instanciamos 00:15:10
el objeto, le pasamos los dos componentes con los que tiene que operar. Tienes que operar 00:15:18
con esos dos. Vale, estupendo. Pues ahora ya este, estos dos componentes, operar con 00:15:24
Y ahora ya esta aplicación 00:15:30
Uy, claro, es que no le he puesto el año 00:15:37
Entonces me hace al cojero 00:15:39
Hacer el integer parse in del vacío 00:15:41
Vale, siguiente intento 00:15:43
Voy a poner 00:15:46
El 1987 00:15:47
Es bisiesto 00:15:49
Pues ese no lo era, obviamente 00:15:51
El 2024 00:15:53
Ese sí 00:15:55
Vale 00:15:58
Pues ya está, pues esta es la arquitectura básica 00:16:00
Sobre esta arquitectura básica 00:16:08
ya se puede hacer cualquier cosa 00:16:10
pero claro, hay millones de pequeñas 00:16:12
cosas, millones de pequeñas cosas 00:16:15
que 00:16:16
amplían esto 00:16:18
y que cada una de ellas, luego cuando uno se mete 00:16:20
pues claro, tienes que resolver un montón de pequeñas cuestiones 00:16:22
y para resolver 00:16:25
esas pequeñas cuestiones que surgen 00:16:26
hay que saber programar 00:16:28
no vale con saber consultar bien Youtube 00:16:30
chat GPT, Stack Overflow, no vale 00:16:32
¿vale? 00:16:34
todo eso es una ayuda maravillosa 00:16:36
para hacer las cosas 00:16:37
pero el que no sabe 00:16:38
programar no puede hacer 00:16:40
absolutamente nada más 00:16:42
a lo mejor puede engañar a alguien un mes 00:16:44
pero dos meses de verdad que no 00:16:46
es importante que aprendáis a programar 00:16:48
vale, bueno pues 00:16:51
aquí se me ha abierto 00:16:54
esto por la excepción 00:16:57
vale 00:16:58
entonces aquí la solución que hemos dado 00:17:02
para poder acceder a eso es esta 00:17:04
aunque la habitual será otra 00:17:05
que bueno, que no la voy a meter ahora porque es ya 00:17:07
demasiado rollo, no nos da tiempo 00:17:10
el próximo día y ahora simplemente 00:17:11
en el 00:17:13
en el tiempo que os queda 00:17:15
para ver que todo esto está entendido 00:17:18
pues algo muy parecido 00:17:20
algo muy parecido pero más 00:17:21
vale 00:17:23
pues una aplicación 00:17:28
dos áreas de texto, una otra 00:17:31
y aquí un botoncito 00:17:33
con un más delante, pues nada, aún más 00:17:35
un por lo que os dé la gana, cuando le deis 00:17:37
al botoncito que haga la operación 00:17:39
que le hayáis puesto y muestra aquí 00:17:41
pues la suma 00:17:43
que aquí en el bot 00:17:45
habéis puesto multiplicar 00:17:47
lo que queráis 00:17:47
me da igual 00:17:48
¿vale? 00:17:48
la aplicación tiene 00:17:49
dos áreas de texto 00:17:50
metéis dos datos 00:17:51
y cuando se da el botón 00:17:52
muestra el resultado 00:17:54
de la operación 00:17:55
con recorriente 00:17:56
¿vale? 00:17:57
¿eh? 00:17:58
bueno a ver 00:18:00
yo lo estoy dibujando así 00:18:01
pero como solamente 00:18:02
hemos puesto 00:18:03
gestor de ubicación 00:18:03
flow layout 00:18:04
pues los puntos 00:18:05
van a quedar seguidos 00:18:05
a ver si ajustáis 00:18:06
los tamaños 00:18:08
con el flow layout 00:18:10
él nos va a poner 00:18:11
precisamente así, si ajustáis el tamaño 00:18:12
del frame, de estos componentes, al ponerlos 00:18:14
seguidos, porque cuando no caben es al trabajo 00:18:16
pero vamos, que como queden 00:18:18
colocados es lo de los demás, vale 00:18:20
y una etiqueta para el resultado de la suma 00:18:22
o de la multiplicación o de lo que queráis 00:18:26
claro, que muestre el resultado 00:18:28
vale, pues venga, esa aplicación 00:18:31
es solo para ver que 00:18:34
la hacéis vosotros desde cero 00:18:36
y para ver que vale, que sí, que esta arquitectura 00:18:38
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
21 de abril de 2024 - 19:05
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
18′ 41″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
85.31 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid