Saltar navegación

20250306 GUI_clases_internas - Contenido educativo

Ajuste de pantalla

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

Subido el 8 de marzo de 2025 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues que bien esto ya 00:00:00
problema solucionado 00:00:03
se lo pasamos por parámetro y estupendo 00:00:05
pero 00:00:07
nunca se hace así 00:00:08
claro, pero y lo que habéis pensado 00:00:10
eso es oro, puro 00:00:13
es que eso es lo que tenéis que hacer, os van a pagar por pensar 00:00:14
si, si, si, de verdad 00:00:17
¿por qué? 00:00:21
pues porque y si 00:00:25
el método tiene que acceder a un montón de cosas 00:00:26
no le puedo pasar 00:00:29
hay mil cosas, es un poco engorroso 00:00:31
estoy hablando en términos de 00:00:33
escritura de código 00:00:37
no es que sea computacionalmente 00:00:38
poco eficiente, es estupendísimo 00:00:41
lo que pasa es que es un rollo, constructores enormes 00:00:43
o hacer un montón de set 00:00:46
pues es un rollo 00:00:47
cuando ya tenemos un montón de componentes 00:00:48
que queremos pasarle 00:00:51
¿qué podemos hacer? 00:00:52
pues, mira 00:00:56
vamos a inventarnos, según se han ido inventando 00:00:57
cosas en Java, según iban haciendo falta 00:01:00
pues se han ido inventando cosas en Java 00:01:01
pues de repente se inventa una cosa 00:01:03
que son 00:01:05
las clases internas 00:01:07
que se usan muchísimo 00:01:08
que es, vamos a ver, mi problema 00:01:10
es que esta clase 00:01:13
no puede acceder 00:01:14
a nada de esta otra, porque son 00:01:17
clases separadas, entonces ya sabemos 00:01:19
¿verdad? eso lo tenemos clarísimo 00:01:21
dos clases separadas para acceder 00:01:23
una a lo de la otra 00:01:25
se lo tenemos que pasar por parámetro 00:01:27
a sus métodos, que es lo que hemos hecho 00:01:29
si lo hemos pasado por los set o por constructor 00:01:31
por parámetro, no hay otro 00:01:33
vale, pero 00:01:35
como eso es un rollo, pues 00:01:37
llega en lumbreras 00:01:38
y dice 00:01:41
pues meto una dentro de otra 00:01:42
y magnífico, si meto esta dentro 00:01:44
de esta otra, pues hala, ya puede 00:01:47
acceder esta a lo de aquí, y no tengo ni que pasárselo 00:01:49
pues efectivamente 00:01:52
ese parche, lo llamo parche 00:01:53
pero en realidad es un recurso de programación 00:01:55
muy usado, pues ya está 00:01:57
y ya lo podemos usar 00:01:58
que es meter una clase 00:02:01
dentro de la otra 00:02:03
pero eso no es algo que uno haga 00:02:04
porque le da la gana 00:02:07
tengo aquí un montón de clases en mi aplicación 00:02:08
mis 300, 500 clases 00:02:11
y esta quiero que acceda a esta otra 00:02:13
y a propiedades 00:02:15
de aquí y no me apetece pasárselas 00:02:17
por parámetro porque entonces tengo que ir a 00:02:19
propiedades, meto esta dentro de la otra 00:02:20
A ver, ojo, no 00:02:22
Esas cosas hay que hacerlas con criterio 00:02:23
Entonces, lo de clases internas 00:02:25
Que es lo que estoy diciendo 00:02:28
Que es que una clase está dentro de la otra 00:02:29
Tiene que hacerse cuando a nivel de diseño 00:02:30
Tiene sentido 00:02:34
¿Vale? Tiene sentido 00:02:36
Y a nivel de diseño tiene sentido 00:02:37
Cuando la clase que yo meto dentro de otra 00:02:40
Solo tiene sentido 00:02:42
Que existan objetos de ella 00:02:44
Si existe la otra clase 00:02:45
¿Vale? 00:02:48
Entonces vamos a 00:02:49
Tres minutos para que entendáis esto 00:02:51
Porque es importante 00:02:54
Tienes que ser los mejores 00:02:57
No hacer las cosas así a lo tonto 00:03:00
Porque vais a tener de rodaje un año 00:03:02
Un año y medio 00:03:03
Si sois los buenos, los que sabéis pensar 00:03:04
Los que lo entendéis todo 00:03:08
Pues tendréis rodaje toda vuestra vida 00:03:09
Vale 00:03:11
Y ahora es cuando Juan saca su boli 00:03:19
Y su papel 00:03:41
que eso es lo que tendría que hacer todo el mundo 00:03:42
porque lo que escribes 00:03:44
normalmente es lo que mejor 00:03:46
interiorizas 00:03:48
porque se piensa con la mano 00:03:49
bastante a menudo 00:03:54
no solo piensa el cerebro 00:03:55
piensa el cerebro y la mano 00:03:58
desde que nació 00:03:59
desde que le enseñaron a coger o hacer 00:04:17
las barritas 00:04:20
y aprendió a hacer las barritas y dijo ya está 00:04:22
ojo que yo he hecho 00:04:23
para mi ortografía 00:04:26
hasta que los abandonaste 00:04:28
pero no mejoraron para la caligrafía 00:04:30
son malísimos 00:04:31
bueno 00:04:32
bueno a ver 00:04:33
clases internas 00:04:37
que son 00:04:39
vamos a dejarlas entendidas 00:04:40
y así las podremos aplicar y utilizar 00:04:43
siempre que queramos 00:04:45
Y este es uno de los contextos en los cuales viene bien usado, el contexto de las interfaces gráficas. 00:04:46
Pero no solo, no solo, hay muchos otros. 00:04:52
Bueno, pues cuando yo os dije en su momento que una clase tiene dentro dos partes, 00:04:58
que son las propiedades 00:05:12
que caracterizan 00:05:15
los objetos 00:05:17
que se van a instanciar de esa clase 00:05:19
esa es una de las partes, las propiedades 00:05:21
lo va a caracterizar el color, la altura 00:05:22
no sé cuánto, y los métodos 00:05:25
que es 00:05:27
el código 00:05:29
que esos objetos van a poder 00:05:31
ejecutar 00:05:33
su comportamiento, lo que van a poder hacer 00:05:34
y eso que van a poder hacer pues va a modificar 00:05:37
sus propiedades o lo que haga falta 00:05:39
pues siempre os dije 00:05:41
bueno, os miento un poco pero bueno 00:05:43
os voy mintiendo poco a poco, pues sí efectivamente 00:05:45
os mentí un poco 00:05:47
porque no es sólo eso 00:05:50
lo que puede tener dentro de una clase 00:05:52
aparte de propiedades y métodos 00:05:53
hay otras dos cosas más que puede tener, alguna ya la hemos mencionado 00:05:55
también es lo de estática 00:05:58
la mencionamos un poco por encima pero bueno 00:05:59
como si la hagáis por olvidada 00:06:02
no pasa nada, ya surgirá en proyectos 00:06:04
del año que viene, ya son más grandes 00:06:06
la otra cosa que puede tener 00:06:07
dentro de una clase, es el bloque static, que es esto, static y entre llaves, un código que afecta solamente a propiedades estáticas de la clase 00:06:10
y sería como una especie de inicialización de la parte estática de la clase, una especie de inicialización de las propiedades estáticas 00:06:26
y se puede ejecutar también código, sentencias de código, pero que toquen solo variables estáticas de la clase, 00:06:33
Es como una especie de inicialización de lo que se llama el contexto estático de la clase, 00:06:40
que es las propiedades estáticas que tiene esta clase, 00:06:46
que son esas propiedades que están ahí, que pueden existir aunque no exista ningún objeto de la clase. 00:06:49
Esas son las propiedades estáticas, las que pueden existir aunque no exista ningún objeto de la clase. 00:06:56
Por esas propiedades se puede hacer un bloque estático para inicializarlas, 00:07:01
para hacer comprobaciones con ellas, 00:07:04
y ese bloque estático se va a ejecutar 00:07:05
una única vez 00:07:08
la primera vez 00:07:10
que se hace referencia a esa clase 00:07:11
o que se crea un objeto 00:07:14
de esa clase, que es en el momento 00:07:16
en el que aparecen las variables estáticas, ¿verdad? 00:07:18
En el momento en el que aparecen las variables 00:07:20
estáticas de una clase, 00:07:22
¿cuándo aparecen? La primera vez 00:07:24
que en un main 00:07:26
se llaman a esas variables con clase 00:07:27
a punto no sé qué o se crea un objeto, 00:07:30
la primera vez que se hace referencia 00:07:32
a una clase, esa primera vez 00:07:34
es la que aparece en todas las variables 00:07:36
estáticas. 00:07:38
Y se quedan ahí. Y ya van a existir para siempre. 00:07:39
¿Vale? 00:07:42
Bueno, pues esa vez, esa primera vez 00:07:43
en la que se quedan todas las propiedades estáticas, 00:07:45
también se ejecuta este código si lo hubiera. 00:07:48
¿Vale? Pues esta es la primera 00:07:50
cosa que digo, que también 00:07:52
puede estar aparte de propiedades y métodos. 00:07:54
Y también puede 00:07:57
haber otra cosa, que son 00:07:58
clases internas. 00:07:59
Puede haber una clase dentro de otra 00:08:01
Es decir, dentro de esta clase A 00:08:04
Puedo declarar yo dentro directamente una clase B 00:08:08
Así alegremente 00:08:12
Con sus propiedades 00:08:21
Por ejemplo, esta podría tener a lo mejor una propiedad 00:08:23
Y para distanciar un objeto de esa clase B 00:08:26
Tendría que distanciar primero uno de clase A 00:08:30
lo que pasa es que las clases internas 00:08:35
pueden ser, pueden admitir dentro 00:08:39
una cosa 00:08:41
que es 00:08:43
la clase interna puede tener dentro el modificador 00:08:43
estático 00:08:47
entonces puedes instanciar un objeto 00:08:47
clase interna 00:08:51
si no existe uno de la de arriba 00:08:51
en este modificador, lo digo para no 00:08:54
responderte así 00:08:56
sin mentirte, pero no quiero 00:08:58
meterme en eso, dime 00:09:00
Sí, a ver 00:09:01
Primero, esto se declararía así 00:09:04
La clase va directamente dentro de la otra 00:09:06
No va dentro de un método ni de nada 00:09:09
Va directamente dentro de la otra 00:09:11
¿Vale? Esta otra clase 00:09:12
Y ahora, ¿qué implicaciones tiene esto? 00:09:14
Bueno, esto es otra clase distinta 00:09:17
Es otra clase diferente 00:09:19
¿Vale? Entonces, con un código así 00:09:21
Tendríamos dos clases 00:09:23
La clase está de aquí 00:09:24
Y la otra clase 00:09:26
Cuyo nombre se convierte en compuesto 00:09:29
la otra clase se llama en realidad 00:09:31
así 00:09:34
es decir, su nombre cambia 00:09:37
de hecho, cuando compilamos 00:09:40
si compilamos esto y vemos lo que ha generado 00:09:42
pues vemos que ha generado 00:09:45
una clase A 00:09:47
y la otra la ha llamado así 00:09:47
tendríamos la A.class 00:09:50
y esta.class 00:09:54
porque el punto 00:09:57
como nombre de fichero 00:09:57
vale 00:09:59
¿vale? entonces, para empezar el nombre es distinto 00:10:00
el nombre no es directamente, el nombre cambia 00:10:03
pero bueno, eso es lo de menos, y ahora, ¿qué implicaciones 00:10:05
tiene a nivel de código? 00:10:07
pues que resulta 00:10:10
que esta clase que está aquí dentro 00:10:11
puede acceder 00:10:13
si le da la gana, vamos a imaginarnos que 00:10:15
yo aquí voy a hacer un método 00:10:17
mostrar 00:10:19
pues esta clase interna de aquí 00:10:20
puede acceder 00:10:25
por supuesto a sus propiedades 00:10:27
como siempre, claro, eso no cambia 00:10:29
pero es que también puede, si le da la gana, acceder a las propiedades de la clase que la contiene. 00:10:31
Es decir, esto tiene sentido. 00:10:42
Sin embargo, desde la clase externa no se puede acceder a las propiedades de la interna, no se puede, ¿vale? 00:10:46
Pero desde la clase interna sí se puede acceder a las de la externa. 00:10:56
entonces, espera, déjame un poco terminar 00:10:59
para que a lo mejor se resuelvan las dudas 00:11:02
después de acabar 00:11:03
entonces, ahora, claro, esto es una cosa rara 00:11:05
me diréis, vale 00:11:08
pero si me dices que son clases separadas 00:11:09
y que por tanto yo puedo hacer objetos separados 00:11:12
si yo instancio 00:11:15
un objeto de clase B 00:11:16
y llamo luego a mostrar 00:11:18
la Y está claro 00:11:20
la que se haya creado en el constructor 00:11:23
la que sea, pero que X muestra 00:11:25
claro, que X muestra 00:11:27
claro, es que para yo poder crear un objeto de esta clase 00:11:29
tiene que existir un objeto de esta 00:11:34
y yo cuando lo instancie, lo instanciaré 00:11:37
asociado a ese objeto, haré algo como esto 00:11:41
yo tengo el objeto A 00:11:46
perdón 00:11:52
algo así 00:11:53
yo tengo un objeto A 00:12:00
vale, pues muy bien 00:12:04
new clase A 00:12:05
y ahora como ya tengo un objeto A 00:12:07
con sus propiedades dentro llenas 00:12:12
las que sean como ya lo tengo 00:12:14
ya podría crear 00:12:15
un objeto de la otra clase 00:12:17
pero asociado a este 00:12:20
bueno, espera, lo estoy llamando A B 00:12:24
sería clase A, clase B 00:12:29
entonces 00:12:31
asociado a este objeto 00:12:40
se hace el nio 00:12:44
algo así, ahora lo comprobamos 00:12:46
porque no recuerdo muy bien si aquí también es obligatorio 00:12:51
poner clase A, yo creo que no 00:12:53
pero lo que me importa es la idea 00:12:54
¿vale? 00:12:56
entonces, para instanciar 00:12:58
un objeto de la clase de dentro 00:13:01
para instanciarlo 00:13:03
tiene que existir 00:13:05
un objeto de la de arriba 00:13:07
¿vale? tiene que existir 00:13:08
¿cuando te está después de placear es un punto? 00:13:11
sí, sí, sí, es un punto 00:13:14
¿vale? tiene que existir 00:13:14
entonces ahora ya esa primera duda está resuelta 00:13:17
si yo llamo a los métodos de B 00:13:19
los métodos de B 00:13:22
trabajan con las propiedades 00:13:23
estas y con las del objeto 00:13:25
este, trabajan con las de este 00:13:28
sin ningún problema 00:13:30
sin embargo tiene sentido que desde la 00:13:31
externa yo no pueda hacer hasta propiedades 00:13:34
porque este objeto puede existir 00:13:36
por libre independientemente 00:13:38
entonces si yo desde aquí pudiera acceder 00:13:39
a las propiedades de aquí y creo este 00:13:42
objeto por libre, cuando 00:13:44
accedo a esas propiedades, es que no están 00:13:46
ni creadas, ¿qué valor tendría? 00:13:48
no se puede, ¿vale? 00:13:50
es que no, puede existir 00:13:54
un objeto de esta clase 00:13:56
sin que estas propiedades existan, no existen 00:13:58
ni siquiera, entonces no tiene sentido que nos dejen 00:14:00
por código acceder a ellas 00:14:02
pero cuando estos objetos existan 00:14:03
Esta tiene que existir, con lo cual tiene sentido que me dejen hacer estas propiedades. 00:14:06
Luego esas son las implicaciones que tiene en cuanto a desarrollo, a escritura de código. 00:14:12
Y entonces uno podría decir, bueno, ¿y con esto qué gano? 00:14:19
Primero, gano una cosa que es la más importante, que es hacer diseños que de nuevo se correspondan muchísimo mejor con la realidad que estoy representando. 00:14:23
porque si yo hago un diseño de clases 00:14:34
que responde a la realidad de lo que estoy 00:14:36
gestionando seguramente esa aplicación 00:14:38
me va a ser mucho más fácil 00:14:40
luego irla manteniendo, irla ampliando 00:14:42
cosas porque estoy precisamente 00:14:44
representando la situación real 00:14:46
con lo cual cualquier cosa que se incorpora a la realidad 00:14:48
se va a incorporar 00:14:50
a mi aplicación de forma natural porque mi 00:14:52
aplicación es directamente un reflejo 00:14:54
de la realidad, no entonces por 00:14:56
ejemplo una situación en la cual 00:14:58
tenemos 00:15:00
alumnos y matrículas 00:15:01
una aplicación que gestiona alumnos, matrículas 00:15:04
una secretaría, vale, pues yo puedo 00:15:07
hacer mis clases alumno 00:15:09
con mis objetos alumno, mis clases 00:15:10
matrícula con mis objetos matrícula 00:15:12
vale, luego poner pues dentro 00:15:15
de la clase alumno un objeto 00:15:17
matrícula que sea su matrícula, puedo hacer ese 00:15:18
diseño, o también podríamos decir 00:15:20
vale, solamente 00:15:23
tiene sentido que existan objetos 00:15:25
matrícula, solo 00:15:26
si son de un alumno 00:15:28
mi aplicación no quiere 00:15:29
que exista un objeto matrícula por libre 00:15:32
no puede, no debería 00:15:34
yo poder hacer un new matrícula 00:15:36
sin más y que exista un objeto matrícula 00:15:39
por libre 00:15:40
¿vale? entonces 00:15:41
¿cómo puedo a lo mejor reflejar eso? 00:15:44
vale, pues que la clase matrícula 00:15:46
la hago interna 00:15:48
a la clase alumno 00:15:50
¿vale? 00:15:51
si, o sea, clase alumno tiene 00:15:53
de propiedad una matrícula 00:15:55
ya, pero es que ya no la tendría 00:15:56
claro, ya no la tendría 00:15:57
entonces, tú puedes 00:16:00
programar de esta manera 00:16:02
tú tienes tu clase alumno con sus propiedades 00:16:04
tiene una clase interna matrícula 00:16:06
y entonces tú te creas tu alumno 00:16:08
y cuando te creas una matrícula 00:16:10
obligatoriamente esa matrícula ya va asociada a un alumno 00:16:12
obligatoriamente, es que no hay tu tía 00:16:14
tienes que crearla aparte 00:16:16
tienes que estar creando un objeto alumno 00:16:18
y luego crear el objeto matrícula 00:16:20
ya, pero si están por separado igual 00:16:21
creas el objeto alumno, matrícula, luego tendrías que hacer el set 00:16:23
para asociarlos 00:16:26
entonces aquí 00:16:27
pues primero garantizas que nadie 00:16:29
va a instanciar una matrícula que se va a quedar suelta 00:16:32
por libre ahí en la aplicación, muerta 00:16:34
no, cualquier objeto matrícula 00:16:35
es que va a estar asociado a un alumno 00:16:38
sí o sí, no necesitas luego hacer 00:16:40
el set para asociárselo ni nada 00:16:42
porque ese alumno ha tenido que 00:16:43
existir para yo poder crear una matrícula 00:16:46
eso es la primera 00:16:48
cosa, y la segunda 00:16:50
desde la clase matrícula yo ya 00:16:51
puedo acceder tranquilamente 00:16:54
A todas las propiedades del alumno 00:16:55
Puedo hacer dentro del método matrícula 00:16:57
Mostrar datos de no sé qué 00:16:59
Y en ese mismo método de matrícula 00:17:01
Pues puedo yo ya 00:17:04
Usar las propiedades de la matrícula 00:17:05
Y las del alumno, tranquilamente 00:17:07
Pero en el objeto alumno no puedes acceder a tu matrícula 00:17:09
No, ya, pero 00:17:12
Sí, pero depende de lo que tengas que hacer 00:17:13
Pero desde aquí, si la gestión es 00:17:15
Pues hacer no sé qué con las matrículas 00:17:17
Tú tienes aquí los métodos 00:17:18
Y estos métodos ya te pueden hacer a lo de arriba 00:17:20
Que de nuevo depende, o sea, que es una herramienta más de diseño 00:17:22
No es que sea la herramienta que haya que utilizar, es un recurso más, un recurso más para diseñar, hacer una clase interna que te puede venir muy bien muchas veces, sobre todo la gran ventaja es que te facilita el paso de parámetros, porque aquí no hay parámetros que pasar. 00:17:25
Si tú en matrícula quieres poner un método que necesite los datos del alumno al que está asociado esa matrícula, tienes que hacerlo muy retorcido, lo tienes que pasar el objeto alumno por parámetro. 00:17:41
Eso luego se te puede complicar un poquito más, ahora llamar a ese método, pues tienes que coger el alumno al que esa matrícula estaba asociado, pasárselo. 00:17:54
Entonces, en función de la situación y de lo que estés resolviendo, esto puede ser mucho más cómodo. 00:18:02
Aquí metes el método y ese método tranquilamente lo tiene todo a su disposición. 00:18:07
Toda la matrícula y todo el alumno. 00:18:12
¿Y hay algún método que me muestre las subclases, o sea, las clases que están dentro de una clase? 00:18:14
No. 00:18:20
¿Por qué no puedo saber las clases que están dentro de una clase? 00:18:21
Porque eres el desarrollador, que has hecho ese diseño. 00:18:24
Sí, pero no. 00:18:27
Claro, eres el... 00:18:29
Sí, sí, lo he hecho yo, claro. 00:18:30
claro, pero es que si no lo has hecho tú 00:18:32
ese diseño 00:18:35
estará con una API 00:18:36
me refiero, estará con un uso, el que lo ha hecho 00:18:38
te dirá, estos son los métodos que tú puedes usar 00:18:41
y tú usarás esos métodos, como lo haya hecho 00:18:42
por dentro te da igual 00:18:45
dime 00:18:45
si yo cambiase 00:18:47
X de la clase A 00:18:50
en la clase B 00:18:52
si metieras esto aquí 00:18:54
no, si yo en caso 00:18:55
que tiene X y lo cambiase en la clase B 00:18:58
Sí, sí, sí, claro 00:19:00
Claro, o sea, tú ves de aquí 00:19:03
Si a X le das 7 00:19:05
El X de A se cambia 00:19:07
¿Vale? Con lo cual esto a veces 00:19:09
Se confunde con la herencia 00:19:11
No tiene nada que ver 00:19:13
Porque tú cuando una clase le da de otra 00:19:14
Tienes dos clases diferentes 00:19:17
Pero los objetos 00:19:19
Son completamente independientes 00:19:21
Entonces cuando una clase le da de otra 00:19:23
Si esta clase hiciera un extens de clase A 00:19:25
Efectivamente tiene un X dentro 00:19:27
al que acceder, pero ese X es el suyo propio 00:19:30
y cuando instanciamos 00:19:32
un objeto de clase B y accedemos a X 00:19:34
accedemos a su propia copia 00:19:36
de X 00:19:38
y clase A tendrá 00:19:38
si la pasas por parámetro como a cualquier otra 00:19:40
pero si esta hereda de esta 00:19:43
este tiene su propio X 00:19:46
y clase A tiene su propio X 00:19:47
cuando tú instancias uno de B 00:19:49
tiene su copia de X y uno de A tiene su copia de X 00:19:51
sin embargo 00:19:54
cuando no estás heredando 00:19:55
sino que es una clase interna 00:19:58
esta tiene 00:19:59
el X que es el único que existe 00:20:01
compartido por los dos 00:20:04
por este objeto al que también puede acceder 00:20:05
este X no es que sea 00:20:08
una propiedad de clase B 00:20:10
es de A, lo que pasa es que 00:20:11
esta tiene acceso directo a ella 00:20:14
para mostrarlo, para modificarlo 00:20:16
para lo que sea, es una propiedad 00:20:18
a la que puede acceder, o sea esto no es una herencia 00:20:19
entonces esto no responde 00:20:22
a clase B 00:20:24
es clase A, sino 00:20:26
responde a la idea de tiene un 00:20:27
clase A tiene un clase B 00:20:30
un alumno tiene 00:20:32
una matrícula, ¿vale? 00:20:34
nunca haríamos matrícula extensa alumno 00:20:36
porque una matrícula no es 00:20:38
un alumno 00:20:40
pero sí lo haríamos como clase interna 00:20:41
porque un alumno sí tiene una matrícula 00:20:44
entonces 00:20:46
dos opciones, como hemos dicho 00:20:47
o bien que clase A tenga un objeto 00:20:50
matrícula dentro y que luego lo instanciemos 00:20:52
o lo pasemos con el set, lo que sea 00:20:54
o como clase interna. 00:20:56
Como clase interna tenemos la seguridad 00:20:57
de que no va a haber objetos matrícula en la aplicación 00:21:00
sueltos. Y luego está otra ventaja. 00:21:02
Y es otro recurso más. 00:21:04
A mí me marea la idea 00:21:06
de no poder acceder 00:21:07
como propiedad de clase A a los 00:21:10
alumnos y matrículas. 00:21:11
Las matrículas de todos los alumnos, 00:21:14
como las tienes que recopilar, pues lo que sea. 00:21:16
Claro. 00:21:18
Pero no puedes acceder directamente 00:21:19
a través de los alumnos. 00:21:21
Claro, es que depende de lo que quieras hacer, pues no lo harías así. 00:21:21
claro, esto en realidad lo de las clases 00:21:24
internas se usa para cosas muy concretas 00:21:26
no es que se use todo el rato 00:21:28
no, para cosas muy concretas, para una aplicación 00:21:30
en general, tú tienes tus colecciones de datos 00:21:32
efectivamente, como hemos 00:21:34
hecho más hasta ahora, ¿vale? pero es 00:21:35
un recurso más que a veces en algún 00:21:38
contexto pequeño tiene sentido 00:21:39
y en este de la interfaz 00:21:41
gráfica es justo lo que necesitamos 00:21:44
los listeners 00:21:45
solo tiene sentido que haya listeners 00:21:47
si hay un frame 00:21:49
si no, ¿para qué quiere uno un listener suelto? 00:21:51
solo tiene sentido si hay un frame 00:21:54
luego que los listeners sean clases internas 00:21:55
porque una clase 00:21:59
puede tener todas las internas que hagan falta 00:22:00
no tiene por qué tener una, todas las que hagan falta 00:22:02
bueno pues 00:22:05
que los listeners sean clases internas 00:22:06
y al ser clases internas 00:22:08
ya pueden acceder a todo 00:22:10
lo que hay en el frame 00:22:12
entonces lo único que tenemos que hacer es sacarlo 00:22:13
de variable local de constructor a propiedad 00:22:16
de clase del frame 00:22:18
Y ya está solucionado 00:22:19
¿Vale? 00:22:21
Entonces 00:22:23
Nos queda algo así 00:22:24
¿Quién se ha dormido? 00:22:27
¿Tú te habías dormido? 00:22:36
Un poco, ¿no? 00:22:38
Vale, pues entonces 00:22:42
Mi ventana 00:22:44
Versión 2 00:22:48
¿Por qué lloras? 00:22:50
Tú estás aquí por gusto, se supone 00:22:57
Venga, pues vamos a hacernos una copia 00:22:59
De mi ventana 00:23:05
Hago copy-paste 00:23:06
Mi ventana 2 00:23:12
De verdad, tenéis que graduaros la pista 00:23:13
no, no, no 00:23:29
te puede ayudar para actividades creativas 00:23:52
claro, lo que he dicho 00:23:54
en la facultad de filosofía 00:23:55
claro, pero aquí no 00:23:57
ni el pegamento tampoco 00:23:59
tampoco 00:24:01
Un polvorón 00:24:03
Eso igual sí, hombre 00:24:11
Uf, eso menos todavía 00:24:12
No, no, no, no, por Dios 00:24:15
Venga, a ver 00:24:18
He hecho una copia de mi ventana 00:24:20
Mi ventana 2 00:24:22
¿Qué es esta? Mi ventana 2 00:24:23
Haced un 00:24:25
A ver, pero haced simple 00:24:26
Mi ventana, le ponéis aquí, botón derecho, copy 00:24:29
Hacéis en el main paste 00:24:31
Y ya te lo ofrece con nombre 2 00:24:33
Vale, mi ventana 2 00:24:34
Pues mi ventana 2 00:24:37
Vamos a hacer el listener 00:24:42
Vamos a meterlo dentro, como clase interna 00:24:44
Pues vamos a copiar 00:24:46
El escucha saludar este 00:24:49
Bueno 00:24:50
Vamos a 00:24:55
El action performance solo 00:24:55
Vale, y copio el action performance 00:24:58
Enterito 00:25:14
que tenía aquí 00:25:17
todos los atajos 00:25:21
que sean con este dedo, eso sí me los puedes decir 00:25:28
pero los que impliquen dos dedos 00:25:31
¿se te atasca la mano? 00:25:33
es que no, es que nací 00:25:40
esta articulación 00:25:41
bueno, a ver, nací 00:25:42
imagino que nacería con ella suelta 00:25:44
y en algún momento se soldó, pero se soldó girada 00:25:47
entonces 00:25:50
claro, o sea, a ver, yo puedo hacer así 00:25:51
pero para hacer así tengo que subir mucho esto 00:25:54
entonces 00:25:56
Es muy incómodo 00:25:56
O sea que tú puedes hacer esto y puedes hacer esto 00:25:58
¿Verdad? Con las dos 00:26:01
Pues yo con esta llego hasta aquí 00:26:02
Ya no llego hasta aquí 00:26:03
Como pianista habría tenido un futuro 00:26:04
Pues lo toqué algunos años 00:26:12
Poder se puede 00:26:22
Vale, pues de mi ventana a dos 00:26:24
Entonces ya lo hemos puesto como clase interna 00:26:26
Implementation Listener 00:26:28
El import 00:26:32
Sí, pero precisamente los acordes 00:26:33
O sea, es que 00:26:37
Claro 00:26:37
Vale, pues entonces 00:26:38
¿Qué? 00:26:43
Pero a ver, que tenéis el cuello muy ágil 00:26:50
Vosotras 00:26:52
Tenéis que agradecerme 00:26:52
Las sesiones que os estoy dando 00:26:56
A ver, echa un copia y pega 00:26:57
A ver, clase escucha saludar 00:27:01
Copiáis y pegáis 00:27:06
Pero dejáis sobre la acción performe dentro 00:27:08
¿Vale? 00:27:10
Claro, entonces 00:27:13
El escucha saludar, ¿qué necesitaba? 00:27:14
Necesitaba acceder a texto 00:27:17
A saluda y a despide 00:27:18
Ya está, pues puede acceder directamente 00:27:19
Como es interna, la hemos hecho interna 00:27:22
Puede acceder a todas las propiedades de la clase 00:27:24
tranquilamente, puede acceder a todas ellas 00:27:26
claro, pero es que 00:27:29
no son propiedades de la clase, son locales 00:27:31
a construir interfaz, no pasa nada 00:27:33
vamos a hacerlas como propiedades de la clase 00:27:35
ala 00:27:37
vamos a hacerlas como propiedades 00:27:40
de la clase, no pasa nada 00:27:43
las hago como propiedades del frame 00:27:45
ya son propiedades de la clase 00:27:46
entonces 00:27:48
ahora ya 00:27:50
puede acceder, veis, tranquilamente 00:27:52
a ellas como clase interna 00:27:55
Pues ya está 00:27:56
La clase interna accede a ello 00:28:06
Entonces ahora ya 00:28:08
El objeto lo tengo que crear igualmente 00:28:13
Bueno, el constructor ya le quito todo esto 00:28:16
Claro 00:28:17
Lo sella, ni falta que me hacen 00:28:18
Ni las quiero 00:28:21
Vale 00:28:22
Vale 00:28:24
no, no he hecho nada 00:28:30
os lo he dejado igual, he sacado 00:28:37
los componentes los he sacado 00:28:39
fuera, como variables de clase 00:28:41
están fuera 00:28:43
el constructor, mi ventana, construí 00:28:44
interfaz, ahora ya como los he sacado fuera 00:28:47
ya no los declara dentro, porque ya están 00:28:49
fuera los propiedades de la clase 00:28:51
he instanciado 00:28:52
mi listener 00:28:55
que es una clase interna, no pasa 00:28:56
nada, la instancia igualmente, como veis 00:28:59
no le hace falta que le ponga su nombre 00:29:01
doble, su nombre porque 00:29:03
como la estamos accediendo 00:29:05
desde la propia clase, no hace 00:29:07
falta ponérselo, vale 00:29:09
entonces instanciamos la clase, que es interna 00:29:10
la instanciamos y se la añadimos 00:29:13
y se acabó y ya está 00:29:15
y listo, y ahora ya en la clase interna 00:29:17
pues, un segundo 00:29:21
la clase interna es igual que la que era 00:29:23
pero ya me olvido del paso de parámetros 00:29:25
no hace falta, porque ya accede directamente 00:29:27
a todo lo de la interfaz. 00:29:30
¿Hasta dónde? 00:29:33
Que le estaba pasando, 00:29:38
como era copia y pega la versión anterior, 00:29:41
le estaba pasando cosas al constructor, se lo he quitado. 00:29:43
Nada más. 00:29:46
Claro, porque 00:29:54
este escucha saludar ya no tiene 00:29:55
propiedades ni tiene nada porque ya accede 00:29:57
directamente a las de la clase 00:29:59
que la contiene, que es el frame, esa es la ventaja 00:30:01
de que sea interna 00:30:03
pero 00:30:04
entre hoy 00:30:07
y mañana, aparte de subir 00:30:09
todos los proyectos 00:30:11
al tema, organizados y eso 00:30:13
y las grabaciones, pues 00:30:15
lo tendréis todo esto, lo tendréis todo ahí subido 00:30:16
en cuanto lo hagáis 3 o 4 veces 00:30:31
ya está 00:30:37
ya, pero es que lo de subir y bajar 00:30:37
es relativo 00:30:43
que subo, que bajo 00:30:43
el ratón, la pantalla 00:30:49
Bueno, pues a ver 00:31:09
Vale, de todas maneras 00:31:46
Vais a hacer ahora 00:31:57
Una parecida 00:31:59
Para que a todo el mundo ya le quede claro 00:32:01
Como se colocan las cosas y demás 00:32:03
Antes de pasar a lo siguiente 00:32:04
Claro, a ver 00:32:07
Estamos arrancando un mundo 00:32:09
De posibilidades enormes 00:32:10
Que tenemos que explorar 00:32:13
vale, bueno pues entonces 00:32:14
solo de cara a que todo el mundo esté organizado 00:32:17
situado y sepa construir 00:32:19
lo básico 00:32:21
pues a ver 00:32:21
haced una interfaz vosotros 00:32:24
en la que haya que pedir 00:32:26
pida un nombre 00:32:29
o sea un área de texto para pedir un nombre 00:32:30
se escribe un nombre 00:32:32
y cuando se le dé al enter 00:32:34
pues diga tu nombre 00:32:36
tiene 27 letras 00:32:38
por ejemplo, vale ya está 00:32:40
entonces lo único que os digo es 00:32:42
el componente 00:32:44
para 00:32:47
poner texto 00:32:48
se llama text fill 00:32:50
se llama j text fill 00:32:51
ese es el componente para meter texto 00:32:53
y el evento por defecto del text fill 00:32:55
es darle al enter 00:32:58
cuando estás situado en él y has escrito le das a enter 00:32:59
lo tendrás que 00:33:01
se guarda dentro del objeto text fill 00:33:06
tú sácalo con el método que 00:33:08
text fill 00:33:09
es el objeto que tiene dentro de todo 00:33:12
el texto que tú hayas puesto, su tamaño 00:33:14
tiene un montón 00:33:16
¿lo sacas de él? 00:33:16
igual, si el Jbutton tiene un gettest 00:33:19
¿cómo no va a tener el textfield 00:33:21
un gettest? 00:33:24
claro 00:33:26
¿puedo repetir el enunciado? 00:33:26
sí 00:33:30
enunciado 00:33:30
a ver 00:33:33
¿necesito un ratón? 00:33:35
sí, sí 00:33:37
¿necesito café? 00:33:39
enunciado 00:33:41
Enunciado va a ser la 00:33:42
Segunda GUI 00:33:46
¿Qué quieres que te haga? 00:33:54
Si no 00:33:55
A ver 00:33:55
Efectivamente 00:33:57
Por eso os traigo 00:34:05
Vale 00:34:06
Pues me vais a hacer 00:34:07
A ver voy a hacer aquí una clasecita 00:34:09
solo para poner el texto 00:34:11
lo que me vais a hacer es 00:34:13
esto 00:34:17
aplicación con una 00:34:18
interfaz gráfica 00:34:25
gráfica 00:34:28
gráfica, a ver, ¿quién tenía que 00:34:29
fumar? 00:34:33
que permita 00:34:34
introducir 00:34:35
tu nombre 00:34:39
Y te indique 00:34:41
Cuántas letras tiene 00:34:46
Área de texto 00:34:51
Metes el nombre, enter 00:34:56
Tu nombre tiene no sé cuántas 00:34:58
Ya está 00:34:59
Y te indica 00:35:01
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:
8 de marzo de 2025 - 19:22
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 06″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
680.59 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid