Saltar navegación

Clase 19-04-24 - 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 21 de abril de 2024 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

¿Solo has venido por la nota? 00:00:00
Bueno, pues el tema de interfaces gráficas de usuario, 00:00:04
lo único que incorpora es otra manera más de comunicarnos con la aplicación 00:00:08
para darle los datos y para recibir los resultados. 00:00:13
Nada más. 00:00:17
Es decir, vamos a cambiar la vista de la aplicación. 00:00:19
Es una aplicación, en general, tenemos que verla como un modelo de tres capas. 00:00:23
en programación, en desarrollo en general 00:00:28
este término modelo de tres capas 00:00:34
tiene un significado concreto 00:00:37
es algo que se usa, el modelo de tres capas 00:00:40
que es una aplicación en general 00:00:43
se puede dividir en tres partes 00:00:45
la vista 00:00:48
la vista es toda esa parte del código 00:00:51
que está relacionada con 00:00:56
mostrar 00:00:59
resultados al usuario 00:01:00
y recoger también resultados del usuario. 00:01:03
Es decir, toda la parte del código 00:01:06
que esté orientada a 00:01:07
la comunicación con el usuario. 00:01:09
A la comunicación. 00:01:11
Simplemente a eso. 00:01:13
A mostrar los datos 00:01:14
y recibirlos. ¿De qué manera? 00:01:17
Pero claro, 00:01:21
los datos que recibe la vista 00:01:21
y los datos que muestra la vista, 00:01:23
esos datos, 00:01:25
tiene que operar alguien con ellos. 00:01:26
alguien opera con ellos 00:01:28
pues esa sería la segunda capa 00:01:30
que sería la lógica 00:01:33
¿vale? esta sería como la lógica 00:01:35
la lógica es la que opera con los datos 00:01:39
entonces esta es 00:01:41
la parte de programación en sí 00:01:43
pura y dura, ¡cállate! 00:01:45
¿vale? no habléis, de verdad 00:01:54
que me ponéis muy nerviosa, lo siento 00:01:56
vale, pues entonces 00:01:58
la lógica es la parte 00:02:00
de programación en sí que ya opera con los datos 00:02:02
la que nos, oyes Moisés 00:02:04
por favor lo que no habléis os separéis 00:02:06
tenéis el resto de la vida para estar juntos 00:02:07
¿vale? pero ahora en clase por favor 00:02:10
bueno, vale 00:02:11
pues la lógica es la parte que opera con los datos 00:02:14
la que nos cuesta, la que nos cuesta el trabajo 00:02:16
con la que llevamos peleándonos 00:02:18
todo el curso, todo el curso nos hemos 00:02:20
venido peleando con esta parte 00:02:22
porque la parte de vista hasta ahora 00:02:23
para nosotros era un system 00:02:26
out println y un scan 00:02:28
ya está, esa era la vista 00:02:29
para nosotros, un system out y un 00:02:31
scan out, todo lo con 00:02:33
lo que nos hemos peleado es la lógica 00:02:35
bueno, pero 00:02:37
estamos hablando de modelo de tres capas, nos falta uno 00:02:39
pues esa otra 00:02:41
capa, que a lo mejor ahora mismo 00:02:43
a nosotros nos cuesta más de entender 00:02:45
porque no hemos trabajado 00:02:47
con ella, es la parte que se llama 00:02:49
de negocios, entonces 00:02:51
en general todos los términos que mencionamos 00:02:56
os tienen que ir poco a poco 00:02:58
sonando, por pura repetición 00:03:00
pues al final os acabarán sonando 00:03:02
para que cuando leéis vuestros discursos 00:03:04
en las entrevistas o para cuando oigáis 00:03:06
a otros, sepáis 00:03:08
de qué se está hablando y sobre todo 00:03:10
para que cuando vosotros seáis los que 00:03:12
habléis, pues que parezca 00:03:14
que sabéis en qué 00:03:16
contexto estáis trabajando 00:03:18
y que conocéis el tema 00:03:19
¿vale? entonces, ¿qué es esto 00:03:22
de negocio? ¿qué significa negocio en 00:03:24
términos de desarrollo de aplicaciones? 00:03:26
en este sector nuestro de desarrollo de aplicaciones 00:03:28
Negocios significan los datos con los que la empresa trabaja 00:03:30
Eso significa el negocio 00:03:36
Pues esta empresa trabaja con muebles, con no sé qué 00:03:37
Esta empresa trabaja con empleados, con jefes 00:03:41
Bueno, más que la empresa en sí, la aplicación 00:03:46
O sea, una aplicación, hemos dicho muchas veces, que gestiona cosas 00:03:49
Gestiona cosas por ahí, gestiona cosas 00:03:52
Pueden ser alumnos, matrículas, profesores 00:03:55
Pueden ser muebles, sillas, pedidos 00:03:57
Pueden ser empleados 00:04:01
Jefes, nóminas 00:04:03
Bueno, pues las cosas con las que se trabaja 00:04:04
Es el negocio 00:04:07
Entonces cuando uno va a una empresa 00:04:08
Y va a desarrollar para ella 00:04:10
La parte que más le cuesta al principio 00:04:13
Muchas veces 00:04:15
Es entender el negocio 00:04:16
Es entender con qué trabaja esta empresa 00:04:18
Entenderlo bien 00:04:20
Con qué cosas gestiona 00:04:21
Cómo se relacionan entre sí 00:04:23
Entender el negocio 00:04:24
¿Vale? Bueno, pues esta es la tercera capa de la aplicación. ¿Y esto en qué se traduce a efectos de una aplicación? Pues que el negocio está plasmado en una base de datos, ¿vale? 00:04:26
En realidad, en una o varias bases de datos, están plasmados los datos de la aplicación, están recogidos. 00:04:40
En una o varias bases de datos estarán todas las tablas con los datos con los que la aplicación trabaja, con los que sea. 00:04:48
Pues contratos de la luz, facturas de no sé qué, ese es el negocio de la empresa, los datos con los que trabaja que estarán recogidos en una o varias bases de datos. 00:04:58
entonces entender toda esa arquitectura 00:05:06
de datos de la empresa 00:05:09
pues eso es un coñazo 00:05:11
muchas veces, pero hay que entenderlo bien 00:05:13
para luego hacer las aplicaciones en condiciones 00:05:15
bueno, pues la capa de negocio 00:05:16
de la aplicación, de una aplicación 00:05:19
de tres capas, la capa de negocio 00:05:21
es toda esa parte 00:05:23
del software, toda esa parte del programa 00:05:25
que se encarga de mover los datos 00:05:27
que se encarga de mapear 00:05:29
estos datos, de las bases de datos 00:05:33
que en la base de datos están ahí, pero ahí pueden estar 00:05:35
porque no se puede operar con ellos 00:05:37
si están ahí, nadie los saca 00:05:40
pues la aplicación en su parte de negocio 00:05:41
estos datos los mapea 00:05:44
los mapea a cosas 00:05:45
con las que ya la aplicación puede trabajar 00:05:47
y esas cosas que son 00:05:50
colecciones, ya está, punto pelota 00:05:51
no hay más 00:05:54
las tablas se mapean en colecciones 00:05:54
de datos, como las que hemos visto 00:05:58
o a lo mejor como 00:06:00
otras específicas 00:06:02
que puede haber desarrollado el propio equipo de desarrolladores. 00:06:03
Igual que ya hay colecciones ya hechas, un montón, listas, pilas, maps, 00:06:10
pues uno puede desarrollar sus propias colecciones. 00:06:15
Pues la capa de negocio mapea. 00:06:18
Toda esta información la mapea en colecciones de datos. 00:06:20
De eso se ocupa. 00:06:24
Y esto no es trivial, porque en función de si este mapeo 00:06:25
traduce las bases de datos 00:06:29
en un galimatías de colecciones 00:06:32
que no hay Cristo que entienda 00:06:34
o si lo mapea en una 00:06:35
estructura de colecciones entendible 00:06:38
jerárquica, ¡ay qué bonita! 00:06:40
pues de hacerlo bien o hacerlo mal, la aplicación es 00:06:42
una caca o la aplicación funciona 00:06:44
de maravilla y la puedo ampliar y mantener 00:06:46
etcétera, entonces esta parte de mapeo 00:06:48
no es trivial, no se trata de 00:06:50
leer de la base de datos y ya está 00:06:52
no, se trata de mover la información 00:06:54
que yo necesito a las colecciones 00:06:56
ya de la aplicación 00:06:58
de una manera que luego eso sea manejable 00:07:00
bueno, pues toda esta parte 00:07:02
es la parte que trata 00:07:04
el módulo de acceso a datos 00:07:06
del año que viene, por ejemplo 00:07:08
¿vale? y la parte de vista 00:07:09
en particular, ¿quién la trata? 00:07:13
pues la trata el módulo de desarrollo de interfaces 00:07:17
del año que viene 00:07:20
también, porque aquí con 00:07:24
desarrollo de interfaces, aquí ya sí que se refiere 00:07:28
en interfaces gráficas de usuario 00:07:30
obviamente, no se refiere a las interfaces 00:07:32
de Java que hemos visto nosotros 00:07:34
y lógica es todo lo demás 00:07:35
lógica es todo con lo que estamos trabajando 00:07:39
este año, lógica es todo 00:07:41
lo que se sigue incorporando 00:07:43
el año que viene en módulos como en programación 00:07:44
multihilo, etcétera, lógica ya es 00:07:46
programación, uno ya tiene 00:07:48
aquí sus colecciones de datos 00:07:51
y diseña el programa para que haga 00:07:52
lo que tenga que hacer 00:07:55
y eso realmente es lo complicado 00:07:55
¿vale? 00:07:59
dentro del diseño de esa lógica pues 00:08:02
habrá que diseñar, lo hago en un solo hilo 00:08:04
lo hago en varios porque uno tarda mucho 00:08:07
etcétera, pues toda esa parte se incorpora al año que viene 00:08:09
en el módulo de programación de servicios 00:08:11
y procesos, etcétera 00:08:13
bueno, pues esto es lo que viene a ser 00:08:15
el módulo de tres capas de toda la vida 00:08:17
entonces una aplicación lo ideal es que 00:08:19
esté bien estructurada y que 00:08:21
tenga separadas sus partes, ah mira estas clases 00:08:23
están relacionadas con la vista 00:08:25
la vista recibe 00:08:26
datos de la lógica, la lógica 00:08:28
accede 00:08:31
a las colecciones que ha mapeado esta parte 00:08:32
pero todo ahí separadito 00:08:36
en última instancia una aplicación podría ser un main 00:08:38
todo ahí seguido, 10.000 líneas 00:08:41
en última instancia una aplicación podría ser un main con 10.000 líneas 00:08:43
pero eso no valdría para nada 00:08:49
entonces cuanto más modular, más separado, más escalado esté mejor 00:08:51
y con ese objetivo es con lo que se define 00:08:55
el modelo de tres capas 00:08:59
que es muy genérico, que se adapta a cualquier tipo 00:09:00
de aplicación 00:09:03
luego cuando hablamos ya, aplicaciones 00:09:03
de un tipo específico, por ejemplo, aplicaciones 00:09:06
web, que son las que se ejecutan 00:09:09
en un servidor web y yo 00:09:11
las invoco desde mi cliente web a 00:09:12
10.000 kilómetros, es un tipo específico de aplicación 00:09:14
pues esas 00:09:17
tienen un modelo de capas un poquito 00:09:18
distinto porque hay que incorporar 00:09:20
esas capas adicionales de servicio 00:09:22
de la aplicación en el servidor, etc. 00:09:25
pero en general el modelo de tres capas es un modelo 00:09:27
genérico para cualquier tipo de aplicación 00:09:29
¿vale? que repito, se puede matizar 00:09:30
luego ya para aplicaciones específicas 00:09:33
pues aplicación para móvil, aplicación 00:09:34
pero es general 00:09:37
la idea es general para cualquier aplicación 00:09:39
el separar en esas tres 00:09:41
partes ¿vale? 00:09:43
bueno, pues ahora nos toca a nosotros 00:09:45
incorporar un poquito 00:09:47
de la vista, incorporar un poquito 00:09:49
para no estar todo el rato 00:09:51
con el sistema audio y el scan, porque tenemos que 00:09:53
hombre, en este curso de programación 00:09:55
tenemos que saber también 00:09:56
incorporar interfaces gráficas 00:09:57
entonces nosotros lo vamos a hacer con el paquete 00:10:00
de interfaces gráficas de Java de toda la vida 00:10:02
que os sonará 00:10:04
y si no os suena, pues sonará a partir de ahora 00:10:05
que es este 00:10:08
entonces de este hay 00:10:09
es un paquete de clases para hacer interfaces gráficas 00:10:11
de swing hay libros 00:10:15
de miles y miles de páginas 00:10:16
nosotros lo que vamos a ver es su funcionamiento 00:10:18
y cómo hacer interfaces gráficas 00:10:21
pero una vez que uno sabe eso 00:10:22
ampliar ya para incorporar 00:10:23
todo tipo de componentes 00:10:25
es fácil 00:10:27
quiero este componente, voy a estudiarme 00:10:29
cómo funciona, cómo lo incorporo 00:10:31
una vez que uno ya sabe cómo funciona 00:10:33
una aplicación 00:10:35
con swing 00:10:37
pues incorporar el resto de cosas ya es ponerse con cada componente 00:10:38
¿vale? 00:10:42
pero nosotros vamos a ver 00:10:43
un poquito cómo funciona por encima, obviamente 00:10:44
no nos vamos a meter en profundidades de swing 00:10:46
porque no tiene sentido 00:10:48
entonces con lo que conozcamos este año 00:10:51
conoceremos los dientes de SWIM para que uno pueda 00:10:54
meterse en él y desarrollar aplicaciones 00:10:56
con SWIM hasta el nivel de 00:10:58
profundidad que quiera 00:11:00
el curso que viene en particular, este módulo 00:11:01
ya pues claro, para cambiar de lenguaje y lo que sea 00:11:04
se hace con 00:11:06
Visual Studio 00:11:08
y que usa el lenguaje 00:11:09
de Sharp, pero la filosofía 00:11:12
de construcción de vistas 00:11:14
es la misma en cuanto a usabilidad 00:11:15
interoperabilidad 00:11:18
operabilidad, etcétera. 00:11:20
Todos esos detalles, todos esos criterios 00:11:22
de construcción de vistas 00:11:24
usables, amigables, etcétera, 00:11:26
todos esos criterios, pues los 00:11:28
utilizáis, los estudiáis 00:11:30
el año que viene. 00:11:32
Bueno, pues después de esta 00:11:34
introducción nos vamos a meter entonces 00:11:36
ahora ya con esa herramienta. 00:11:38
Ahora ya estáis contextualizados. 00:11:40
Uno siempre, en cualquier cosa que haga 00:11:42
en la vida, tiene que estar siempre 00:11:44
contextualizado. Es decir, a ver, 00:11:46
¿por qué estoy haciendo esto? ¿Para qué lo quiero? 00:11:48
qué es, para qué me sirve 00:11:50
por qué he elegido esto y no he elegido otra cosa 00:11:52
uno siempre tiene que estar en contexto 00:11:54
de lo que está haciendo 00:11:56
y no perder la perspectiva de lo que está haciendo 00:11:57
no pones a estudiar las cosas sin más 00:11:59
bueno, pues esta es la perspectiva de 00:12:02
por qué vamos a ver ahora 00:12:04
Swim 00:12:05
vale, pues para hacer ahora 00:12:06
para empezar ya a incorporar 00:12:37
interfaces gráficas 00:12:39
a nuestra aplicación, vamos a tener que ver 00:12:41
una serie de clases 00:12:43
sobre todo para lo que nos va a ser útil 00:12:45
es para volver a repasar lo mismo 00:12:48
una y otra vez, porque lo que más nos importa 00:12:50
a nosotros ahora mismo es 00:12:52
que reforcéis, que terminéis de aprender 00:12:53
que incorporéis más soltura 00:12:56
en lo que hemos visto hasta ahora 00:12:58
pero lo que hemos visto hasta ahora es la programación pura y dura 00:12:59
lo que queda ahora que es interfaces 00:13:02
gráficas, accesos ficheros y algunos 00:13:04
flecos sueltos que no hemos 00:13:05
ido tocando por 00:13:07
falta de tiempo, son cosas 00:13:10
ya específicas añadidas 00:13:11
pero lo que hemos visto hasta ahora 00:13:13
es la programación 00:13:15
pura y dura 00:13:17
entonces 00:13:18
en las aplicaciones que hagamos a partir de ahora 00:13:19
vamos a incorporar 00:13:22
una interfaz gráfica 00:13:24
pero lo que va a importar sobre todo es 00:13:26
lo que está detrás, cómo se operan los datos 00:13:28
entonces la idea es seguir 00:13:30
revisando, repasando 00:13:32
reforzando y cogiendo 00:13:34
las habilidades que todavía no hayáis cogido 00:13:36
porque la construcción de la interfaz es facilísima 00:13:39
ya lo vais a ver 00:13:43
bueno, pues ¿en qué se basa? 00:13:44
Swing es un paquete de clases 00:13:52
es lo único que es Swing, ¿vale? 00:13:54
un paquete de clases 00:13:56
es un paquete de clases para hacer cosas 00:13:57
igual que Java útil 00:14:05
era un paquete de clases para hacer cosas 00:14:06
pues Swing también, es Java x Swing 00:14:09
para hacer cosas 00:14:11
bueno 00:14:12
pues ahora cuando hagamos una aplicación 00:14:14
con interfaz gráfica 00:14:17
esta va a ser la primera vez 00:14:19
que pasan cosas 00:14:21
que no las provoca 00:14:23
el programa 00:14:26
nosotros hasta ahora todos los programas que hemos 00:14:26
hecho 00:14:30
podían tener 00:14:30
una o mil líneas, llamarse 00:14:33
de unas clases, llamar a otras mediante 00:14:35
llamadas a métodos 00:14:38
bueno, podían ser, pero todo lo que 00:14:39
ocurría 00:14:41
era consecuencia 00:14:42
de la ejecución de una sentencia 00:14:45
todo lo que ocurría 00:14:47
cuando aparecía una excepción que parecía que de repente 00:14:48
boom, aparecía y no sabemos dónde había aparecido 00:14:51
cuando aparecía una excepción 00:14:53
ahora sabemos que también era siempre 00:14:55
a consecuencia de la ejecución 00:14:57
de una sentencia, en nuestro caso 00:14:59
el throw, es decir, hasta ahora 00:15:01
todo lo que ha ocurrido en nuestros 00:15:03
programas ha sido siempre a 00:15:05
consecuencia de la ejecución 00:15:07
de una sentencia 00:15:09
¿vale? bueno, pues 00:15:10
ahora, desde el momento en que 00:15:13
incorporamos una interfaz gráfica 00:15:15
abrimos ya un mundo de cosas que pueden 00:15:17
ocurrir que ahora ya sí que nos importan 00:15:19
que antes no nos importaban 00:15:21
y hay que tenerlas en cuenta y ver 00:15:23
cómo las incorporamos 00:15:25
entonces ahora ya 00:15:27
nuestra aplicación construirá una 00:15:30
interfaz gráfica con botoncitos 00:15:33
con listados 00:15:35
con lo que nos dé la gana 00:15:37
aquí con sus, la construirá 00:15:38
va a ir apegando y la construirá 00:15:41
y desde el momento que hemos construido 00:15:43
la interfaz gráfica ahora ya se abre un mundo 00:15:44
de cosas que pueden ocurrir 00:15:46
ahora puede ocurrir que de repente llegue alguien y pum 00:15:47
pulse este botón, que ahora llegue otro 00:15:50
y plaf, seleccione este ítem 00:15:53
de esta lista 00:15:55
o puede ocurrir que de repente alguien decida 00:15:56
redimensionar esta ventanita 00:15:59
o puede ocurrir que uno 00:16:01
decida darle aquí a esta de minimizar 00:16:03
ahora pueden ocurrir un montón 00:16:05
de cosas 00:16:07
porque las estamos ofreciendo 00:16:08
estamos ofreciendo que ocurran ese montón de cosas 00:16:10
y ese montón de cosas que son 00:16:12
pulsar, redimensionar, darle 00:16:15
no son sentencias que se están 00:16:17
ejecutando, eso es que hay un humano 00:16:19
ahí que lo está haciendo 00:16:21
¿vale? pues eso es lo que se llaman 00:16:22
eventos, entonces este 00:16:25
concepto de evento hasta ahora no nos ha parecido 00:16:32
¿vale? 00:16:34
pues hay una cosa que se llama la 00:16:36
programación orientada a eventos, que es un 00:16:38
término muy genérico, la programación orientada a eventos 00:16:40
que es, ¿cómo programo yo 00:16:42
aplicaciones? ¿cómo 00:16:44
programo yo software? de manera que 00:16:46
se enteren de que pasan cosas 00:16:48
ajenas a ella 00:16:50
¿vale? bueno, pues esto de swing 00:16:51
va a ser nuestro primer ejemplo 00:16:54
de hacer programación orientada 00:16:55
a eventos. 00:16:58
¿Por qué? Van a pasar cosas 00:16:59
ajenas a la ejecución 00:17:02
de nuestro software. Va a pasar 00:17:04
que uno pulse, que otro lo dimensione, 00:17:06
que otro lo minimizar. Van a pasar un montón de cosas. 00:17:08
¿Qué es lo que se llaman eventos? 00:17:10
Pues tenemos que ver cómo construimos 00:17:12
nuestra aplicación, qué podemos hacer para 00:17:13
enterarnos de todo eso y actuar 00:17:15
en consecuencia. 00:17:18
Esa es la programación orientada a eventos. 00:17:21
La programación que incorpora una arquitectura de clase 00:17:23
ahora veremos cómo, que incorpora una arquitectura de clases 00:17:26
que te permite 00:17:28
enterarte de que ha pasado 00:17:30
algo externo y responder a ello 00:17:32
entonces los eventos en general son 00:17:34
cosas 00:17:38
que ocurren 00:17:40
ajenas al programa 00:17:44
esos son los eventos, en nuestro caso 00:17:46
pues ya está lo que hemos dicho 00:17:57
¿y qué es la programación orientada a eventos? 00:17:58
pues la programación 00:18:01
orientada a eventos 00:18:03
será la programación 00:18:04
Que se entera de esos eventos 00:18:06
Y genera una respuesta 00:18:11
Esa es la programación orientada a eventos 00:18:12
Que hasta ahora nosotros no la hemos hecho 00:18:15
Pero no teníamos eventos 00:18:16
Esta será la programación 00:18:17
Que se entera 00:18:31
Vas a ver cómo se entera 00:18:34
Que se entera 00:18:35
De que ocurren eventos 00:18:38
Y genera respuesta 00:18:43
Bueno, genera respuesta si quiere 00:18:46
Podríamos hacer una aplicación 00:18:47
que sí puede enterarse de que esto se redimensiona 00:18:49
pero no genera ninguna respuesta 00:18:52
y genera respuesta opcionalmente 00:18:53
si quiere generarla, claro 00:19:01
bueno, pues es otro término 00:19:03
programación orientada a eventos 00:19:10
y este, repito, es el primer ejemplo 00:19:11
el primer ejemplo 00:19:14
cuando se hacen interfaces gráficas 00:19:15
hay otros 00:19:17
contextos, otras situaciones en las cuales 00:19:19
pueden llegar también eventos, pero otras situaciones 00:19:21
pues cuando uno hace programación en red 00:19:23
evento de que ha habido una petición 00:19:25
a un socket, por ejemplo, es otro evento 00:19:28
entonces se tiene que enterar, la aplicación 00:19:29
hay más situaciones en las cuales un programa 00:19:32
puede querer enterarse 00:19:34
de que han ocurrido cosas 00:19:36
este es uno, cuando se hacen 00:19:37
interfaces gráficas 00:19:39
porque los eventos están claros 00:19:41
dar a las cositas es algo ajeno al programa 00:19:43
luego por definición 00:19:46
esos son eventos 00:19:47
bueno, pues esto de enterarse 00:19:48
esto de enterarse 00:19:53
es lo que se llama 00:19:54
capturar el evento 00:19:55
que es lo que nosotros tenemos que hacer 00:19:57
en nuestros programas 00:20:00
esto de enterarse de que el evento ha ocurrido 00:20:01
se llama capturar el evento 00:20:07
luego nuestras aplicaciones con swing 00:20:09
van a tener dos partes 00:20:13
la vista 00:20:15
una 00:20:16
pintar la interfaz 00:20:17
la más sencilla 00:20:20
compongo las cositas 00:20:21
pintar la interfaz 00:20:24
y dos 00:20:25
capturar los eventos 00:20:26
van a ser las dos partes que tendrá nuestra vista 00:20:29
¿vale? entonces una aplicación con interfaz gráfica 00:20:32
tiene ya entonces una serie de clases 00:20:35
asociadas a la vista 00:20:38
no como las que hemos hecho hasta ahora 00:20:40
que lo único que había relacionado con la vista era 00:20:42
scan y system out 00:20:44
entonces ¿para qué meter eso en una clase aparte? 00:20:46
un método que hiciera system out 00:20:49
¿vale? 00:20:50
ahora no 00:20:53
ahora las clases relacionadas con nuestra vista ya serán muchas 00:20:54
porque para construir todo esto y capturar eventos 00:20:57
esto ya no se hace en una línea 00:20:59
bueno pues las clases 00:21:00
relacionadas con la construcción 00:21:03
de nuestra vista 00:21:06
van a tener claramente 00:21:07
dos partes 00:21:09
la parte de construcción 00:21:11
de las ventanas 00:21:14
la parte de pintado, de dibujado 00:21:16
la parte de construcción 00:21:18
y la parte de captura de eventos 00:21:20
que es yo he construido esto 00:21:24
pero si no hago la parte de captura de eventos 00:21:25
ya puede estar ahí el usuario dando botones toda la vida 00:21:27
que no va a pasar nada 00:21:29
entonces no solo basta con que yo construya 00:21:30
tengo que hacer la parte de 00:21:32
captura de los eventos que yo quiera 00:21:34
si solo quiero capturar que se pulse el botón 00:21:38
pues solo capturo ese 00:21:41
lo que yo quiera capturar 00:21:42
esas van a ser las dos partes 00:21:43
y una vez que entendamos 00:21:46
el funcionamiento de las dos partes 00:21:49
pues ya es, se trata de incorporar 00:21:50
más cositas, nada más 00:21:52
luego bueno, tiene la complejidad 00:21:53
que si tengo solo una ventana 00:21:56
facilísimo, si quiero que haya diferentes 00:21:58
ventanas, pues tengo que abrir varias 00:22:00
pero ya es ir estudiando poquito a poco 00:22:02
sobre una base conocida 00:22:04
a ver, si todo esto lo tuviéramos 00:22:06
que hacer desde cero, sería una 00:22:10
locura, porque claro 00:22:12
programar uno desde cero 00:22:13
los píxeles para que tengan 00:22:16
el colorcito y el aspecto que yo quiero 00:22:18
sería una locura, obviamente no programamos 00:22:20
desde cero una 00:22:22
ventana, no lo programamos 00:22:24
desde cero porque afortunadamente 00:22:28
estamos trabajando con programación orientada 00:22:29
a objetos 00:22:32
¿y cuál era la base de la programación orientada a objetos? 00:22:32
entre otras cosas era la herencia 00:22:35
y es, yo tengo clases hechas que hacen cosas 00:22:37
si heredo de ellas 00:22:40
me hago mi propia clase 00:22:42
donde ya tengo un montón de cosas 00:22:44
hechas y lo único que tengo que hacer yo es particularizar 00:22:46
pues esa es 00:22:48
la filosofía de la construcción 00:22:50
de una vista 00:22:51
afortunadamente 00:22:53
ya tenemos 00:22:55
una clase 00:22:58
que te hace una ventana 00:22:59
completita, sin nada 00:23:01
que esta es la básica 00:23:04
de cualquier aplicación construida en Swim 00:23:06
la clase se llama JFrame 00:23:08
y ahora yo ya 00:23:10
heredo de ella 00:23:13
y ya tengo 00:23:14
ahí mogollón hecho 00:23:17
pero mogollón 00:23:19
entonces la clase que yo haga 00:23:21
heredando de ella, mi propia ventanita 00:23:24
la que yo quiera, a esa ya 00:23:26
le añado lo que yo quiera 00:23:27
¿que le quiero añadir un botón? 00:23:29
hombre, ¿tengo yo 00:23:33
que hacerme una clase 00:23:34
que dibuje el botón, le ponga 00:23:35
el color que sea? no, porque 00:23:38
afortunadamente, Swin 00:23:40
es un paquete con tropecientas mil clases 00:23:42
con cosas que ya está hechas, por ejemplo 00:23:43
entre ellas el botón 00:23:45
pues entonces, gracias a que tengo yo un montón de clases 00:23:47
que hacen muchas cosas 00:23:52
pues construir la interfaz es ir 00:23:53
seleccionando las clases que yo quiero 00:23:56
e irlas incorporando 00:23:59
a través de los métodos 00:24:01
y ya está 00:24:02
entonces la parte de construcción 00:24:03
es sencilla 00:24:06
y luego ya la parte de captura de eventos 00:24:07
pues habrá que ver, ¿cómo se captura el evento 00:24:11
de un componente? pues bueno 00:24:13
pues habrá que ver, pero a ver, vamos a ver 00:24:14
un primer ejemplo de construcción 00:24:17
entonces la base siempre es 00:24:18
un JFrame raíz 00:24:20
y luego ya del 00:24:22
heredo y particularizo 00:24:24
entonces hay dos tipos 00:24:26
bueno hay muchos pero vamos 00:24:28
hay dos tipos en general de 00:24:30
elementos en swing 00:24:32
contenedores y 00:24:34
componentes, los contenedores 00:24:36
son los que están pensando para 00:24:47
contener elementos 00:24:48
de la interfaz, el JFrame 00:24:50
es el contenedor básico 00:24:52
el contenedor básico porque el JFrame 00:24:54
ahora lo veremos, es el marco de cualquier ventana 00:24:56
y el JFrame está pensado 00:24:58
para contener cosas 00:25:00
componentes, pues tropecientos mil 00:25:02
el botón, el slider 00:25:05
cualquier cosa, la lista 00:25:07
el desplegable, todo eso son elementos 00:25:08
que van dentro de un 00:25:11
contenedor 00:25:13
entonces en general hay contenedores y 00:25:14
componentes, entonces uno selecciona 00:25:17
el contenedor, va poniendo los componentes 00:25:19
y luego captura los eventos 00:25:21
bueno, pues lo vamos a ir viendo 00:25:22
en algún ejemplo pequeñito 00:25:25
y así queda más claro 00:25:27
pero más o menos, esta es la filosofía 00:25:28
de uso de SWI y los conceptos relacionados 00:25:31
pues 00:25:33
los eventos, la captura del evento 00:25:34
y poco más 00:25:37
vale, vamos a ver 00:25:39
¿puedo entrar? 00:25:51
sí, puedes entrar, pero vaya horitas, ¿no? 00:26:09
vale, pues venga 00:26:12
esta tarde voy a subir el examen completo corregido 00:26:37
recordad que el segundo ejercicio lo miramos un poco por encima 00:27:09
pero la idea es que lo miréis en detalle vosotros 00:27:12
con la corrección que yo he subido 00:27:16
aunque lo podéis haber hecho de otras maneras 00:27:18
pero yo os doy una corrección con diferentes cosas 00:27:20
para que 00:27:23
no se os olvide mirarlo 00:27:24
no se os olvide mirarlo 00:27:27
si algo no entendéis o lo que sea 00:27:29
pues lo vemos 00:27:31
vale, pues venga 00:27:32
primer ejemplo para entender 00:27:34
la base 00:27:41
vale, vamos a ponerme a hacer un paquete vista 00:27:42
pues yo que sé, por ir haciendo cosas un poquito 00:28:01
bueno, pues vamos a hacer 00:28:03
una aplicación 00:28:09
pues nada, que 00:28:11
metes una edad 00:28:12
Y te diga si es mayor de edad o no. 00:28:16
¿Qué edad tienes, patatín? 00:28:22
Pues eres mayor de edad, no eres mayor de edad. 00:28:23
Cualquier chorrada. 00:28:24
Podríamos meter un año y que te diga, es bisiesto, no es bisiesto. 00:28:25
Pues lo que fuera. 00:28:28
Bueno, lo del año tiene más sentido, por lo menos tiene que hacer algo. 00:28:29
Vale, para meter un numerito, una aplicación para meter un numerito. 00:28:32
Bueno, pues entonces, lo que hemos dicho. 00:28:36
La aplicación necesita un marco raíz. 00:28:39
y sobre ese marco raíz ya se pondrá 00:28:44
todo lo demás 00:28:46
puede que la aplicación tenga más ventanas que se van abriendo 00:28:47
¿vale? 00:28:50
desde luego puede ser muy complicada 00:28:52
con muchas ventanas que se van abriendo y con todo 00:28:53
pero 00:28:55
estarán todas en general 00:28:57
hablo general porque luego swing tiene muchas formas 00:29:00
de uso, pero bueno, en general estarán todas 00:29:02
asociadas a un marco raíz, a un marco básico 00:29:04
que es el arranque de la aplicación 00:29:06
porque la aplicación, una aplicación 00:29:08
normal de escritorio cuando arranca 00:29:10
normalmente arranca una única ventana al principio 00:29:12
luego cuando tú vas dando 00:29:14
pueden abrirse ventanas secundarias 00:29:15
y que a lo mejor cuando se abre otra 00:29:17
pues igual puede haberse cerrado la primera 00:29:19
pero al principio siempre arranca con una 00:29:21
ventana inicial y luego ya 00:29:23
a partir de los eventos que tú hagas 00:29:25
pueden ir pasando más cosas 00:29:27
bueno, pues esa ventana inicial 00:29:29
que se abre sería el 00:29:31
marco raíz y es lo que he llamado 00:29:33
ahí el JFrame 00:29:36
vale, pues venga, vamos a hacer 00:29:37
una clase nuestra 00:29:39
Que va a ser ese marco básico 00:29:41
Pues venga, nos hacemos 00:29:43
Nuestra clase 00:29:45
Pues venga 00:29:48
Esta va a ser una ventana 00:29:49
Pues venga, a ver si esto 00:29:52
La vamos a llamar, porque es la ventana 00:29:54
Que nos va 00:29:56
A U 00:29:57
¿Vale? 00:29:59
A la ventana, a ver si esto 00:30:05
Bueno, pues yo quiero que esto sea mi marco raíz 00:30:06
Mi ventana inicial 00:30:09
Entonces, si a partir de aquí 00:30:11
De esta ventana en blanco 00:30:13
repito lo que he dicho antes, me tengo que poner yo aquí 00:30:14
a programar 00:30:17
a tan bajo nivel como para marcar 00:30:19
píxeles de color, mostrar líneas 00:30:21
que podría 00:30:23
pues claro, me vuelvo loca 00:30:24
obviamente no vamos a hacer eso 00:30:27
¿qué vamos a hacer? vamos a decir, hombre 00:30:28
tengo yo una clase ya hecha 00:30:30
en el paquete Java Swim 00:30:33
que es JFrame 00:30:34
que ya me da una ventana 00:30:36
un marco con ya 00:30:39
unas cuantas cosas, pues voy a 00:30:41
heredar de ella 00:30:43
Voy a heredar de ella 00:30:43
Ala, heredo de JFrame 00:30:46
A heredar de JFrame 00:30:49
Ya tengo aquí un montón de cosas 00:30:50
Tengo aquí un montón de cosas 00:30:53
Habrá que importarla, claro 00:30:55
Pues JFrame 00:30:57
Como veis 00:30:59
Está en este paquete 00:30:59
Ala, ya tengo un frame básico 00:31:03
De hecho, podríamos ya verlo 00:31:08
Que esto ya tiene algo 00:31:11
Vamos a hacernos un main 00:31:12
Vamos a hacernos un main 00:31:13
bueno, para 00:31:16
no es que esté haciendo una 00:31:18
separación muy 00:31:21
vamos a hacer un paquete lógico y vamos a meter 00:31:23
el main ahí, para ir 00:31:25
arrancando mi aplicación, porque yo aquí no tengo ningún 00:31:34
main todavía, una aplicación de escritorio 00:31:36
sí o sí para arrancar y dar un main, o sea, lo sabemos 00:31:38
vale 00:31:40
pues entonces 00:31:49
¿qué es lo primero que yo hago 00:31:50
para arrancar mi aplicación? 00:31:53
pues hombre, instanciar 00:31:55
mi objeto marco, yo aquí he declarado 00:31:56
la clase marco raíz, la clase 00:31:59
JFrame, está declarada 00:32:01
pero no está creada, el objeto 00:32:03
no está instanciada 00:32:05
pues lo primero que tendrá que hacer mi main es instanciarlo 00:32:06
pues venga, vamos a 00:32:09
hacer, simplemente instanciar 00:32:11
esa ventanita 00:32:13
y si 00:32:14
esto 00:32:16
no he puesto bien el nombre o 00:32:18
si, es que 00:32:38
ay, es que soy 00:32:41
Estoy muy pegata y no me apetece cambiarme las gafas 00:32:44
No tengo tiempo 00:32:47
Vale 00:32:49
Vamos a refactorizarla 00:32:50
Ah, habré acertado esta vez 00:32:55
Sí, ahora ya 00:33:09
Ya se me deja hacer el link 00:33:14
Vale, pues hombre 00:33:16
Aquí ya 00:33:18
Si realmente 00:33:20
Jotaframe 00:33:21
Ya tiene cosas 00:33:23
En cuanto yo instancie esto 00:33:25
Algo va a pasar, porque JFrame ya tiene cosas 00:33:28
Vamos a ejecutar 00:33:30
Este main 00:33:32
A ver que pasa 00:33:33
Vale, ejecuto este main 00:33:35
No ha pasado nada 00:34:16
Vale 00:34:19
vale, no ha pasado nada 00:34:22
claro, el objeto se ha creado 00:34:32
pero ¿qué me ha faltado? 00:34:34
ah, espérate, es que tengo que entender 00:34:36
JFrame un poco más en profundidad 00:34:38
entonces, un JFrame 00:34:39
es una clase que ya existe 00:34:42
y VentanaVisiesto, al heredar de JFrame 00:34:43
ya hereda muchas cosas, entre ellas 00:34:46
métodos, entonces hombre 00:34:48
algunos métodos básicos tengo que conocer 00:34:49
entonces, ¿aquí qué es lo que me ha faltado? 00:34:51
pues que VentanaVisiesto 00:34:54
este objeto de aquí 00:34:56
este objeto lo he instanciado 00:34:57
pero no lo he hecho visible 00:34:59
¿vale? 00:35:02
entonces primer método básico 00:35:06
obviamente no vamos a ver 00:35:08
ni todas las clases en detalle porque sería imposible 00:35:10
pero vamos a ver algunas 00:35:13
con los métodos básicos para tener 00:35:15
una pincelada de swing en cuestión de poco tiempo 00:35:16
hombre pues claro 00:35:19
es que el primer método me ha faltado 00:35:21
el JFrame 00:35:23
tiene un método para hacerse visible 00:35:25
¿vale? 00:35:27
y V como hereda de JFrame 00:35:29
lo puede llamar, entonces ahora ya 00:35:31
si ejecutamos esto 00:35:33
pues ahora me ha aparecido una ventanita 00:35:35
ahora ya sí, lo que pasa es que 00:35:37
hombre, este es el frame básico, me ha aparecido 00:35:39
diminuta, que feo, cuando yo 00:35:41
arranco mi aplicación no quiero obligarle al tío 00:35:43
a que me abra la ventana 00:35:45
siempre que me la estire, ah claro 00:35:47
es que también tengo 00:35:49
otro método 00:35:51
para fijar 00:35:53
el tamaño en pulgadas 00:35:56
horizontal y vertical 00:35:59
hombre, pues yo que sé, el que yo quiera 00:36:01
entonces si ahora ejecutamos esto 00:36:03
ahora ya 00:36:09
bueno, un poco en anujo, en cualquier caso 00:36:10
pero vamos 00:36:13
eso ya da igual 00:36:16
ah, es que lo he dejado en cero 00:36:19
un segundito 00:36:24
bueno, vale, ese es el frame básico 00:36:30
entonces setSize es un método 00:36:34
que está sobrecargado 00:36:36
y tiene otra versión, tú le puedes pasar un objeto 00:36:37
dimensión, que es otra manera 00:36:40
de meter las dimensiones 00:36:42
en dimensión también puedes meter, me parece 00:36:43
no solo el ancho y el alto 00:36:45
sino también en qué punto de la pantalla 00:36:48
porque yo este 00:36:50
en el set size 00:36:51
la pantalla siempre me la arranca de partida 00:36:52
aquí arriba 00:36:56
pero con el set dimension creo que puedes fijar también 00:36:56
en qué punto, si quieres que arranque 00:37:00
en el centro o no 00:37:01
entonces cada método 00:37:03
dentro de que hay tropecientos para cada clase 00:37:05
cada método está sobrecargado 00:37:08
¿Perdón? 00:37:09
Claro, tienes que crear 00:37:13
bueno, directamente el objeto dimensión 00:37:14
pero habría que ver en la documentación de dimensión 00:37:16
cómo meterle los datos que tú quieres 00:37:18
¿Vale? Pero uno 00:37:20
vamos, que 00:37:22
uno busca dimensión y rápidamente 00:37:23
le saldrá 00:37:26
de hecho, SetSize creo que tiene otra 00:37:27
tiene tres versiones, creo, me parece 00:37:29
incluso, no solo dos, otra, donde le das 00:37:32
cuatro valores, uno es 00:37:34
ancho alto y otro es la 00:37:36
coordenada x e y en la que 00:37:38
arranca, creo, pero no estoy segura 00:37:40
porque de cada, no, tiene dos versiones 00:37:42
solo, entonces si le quieres dar el punto de arranque 00:37:44
tienes que darle un objeto de dimensión 00:37:46
¿vale? pero vamos, esto 00:37:47
uno puede mirar la ayuda 00:37:57
vale, bueno 00:37:58
bueno, pues entonces ya sabemos 00:38:01
construir un marco raíz, un marco 00:38:04
básico 00:38:06
¿vale? pero 00:38:06
pero a ver, fijaos en un detalle 00:38:09
yo he cerrado 00:38:19
mi ventanita, le he dado a la X 00:38:21
la he cerrado 00:38:23
pero mi aplicación sigue funcionando 00:38:24
sigue ahí 00:38:27
no la he parado 00:38:29
¿por qué? porque no he 00:38:31
capturado el evento de darle a la X 00:38:33
entonces yo me puedo creer que la aplicación 00:38:35
ha terminado, pero no 00:38:37
es decir, aquí 00:38:39
por eso, aquí ya hay cosas que funcionan de forma 00:38:41
distinta como las intuimos con lo que he 00:38:43
hecho hasta ahora. O sea, set visible 00:38:45
hace que el frame 00:38:47
se quede ahí visible, ¿vale? 00:38:49
Aparezca y el programa 00:38:51
no termina, el objeto está ahí. Entonces, 00:38:53
aunque yo le dé a la X, el programa 00:38:55
no ha terminado. 00:38:57
Luego, aquí es la primera vez que pasa una cosa rara. 00:38:59
Hasta ahora, nosotros, 00:39:01
cuando un main terminaba, 00:39:03
cuando ya se había ejecutado todas las sentencias, 00:39:05
el programa terminaba. Cuando el main 00:39:07
termina, el programa termina. 00:39:09
pero aquí el frame tiene un funcionamiento 00:39:10
interno, el frame que es 00:39:13
que arranca un hilo 00:39:15
que está ahí continuamente 00:39:16
esperando a ver si 00:39:18
ocurren eventos 00:39:21
entonces desde el momento en que uno instancia 00:39:22
una ventana de estas 00:39:25
ha arrancado un hilo 00:39:26
infinito, un hilo que no para 00:39:29
y la única forma de pararle 00:39:30
sería hacer 00:39:33
una sentencia del tipo 00:39:35
system exit de las que cierran 00:39:36
un proceso forzado 00:39:39
a ver, lo voy a parar yo 00:39:41
con este botón rojo a lo bestia 00:39:43
Valeria sí que está parada, el proceso porque lo he parado a lo bestia 00:39:45
es como si me hubiera metido al sistema operativo 00:39:48
y hubiera hecho un kill 00:39:50
y hubiera matado al proceso, eso es lo que hago 00:39:50
dándole al rojito ahí 00:39:53
estoy haciendo un kill 00:39:54
y mato el proceso a lo bestia, nunca jamás deberíamos 00:39:56
cerrar una aplicación 00:39:59
matándola así a lo bestia con un kill 00:40:00
siempre hay que cerrarla de forma 00:40:02
con los recursos que nos ofrezca 00:40:04
para cerrarla, que se preocuparán 00:40:07
de cerrar el resto de cosas que dependan de ella 00:40:10
etcétera, pues es que tal y como 00:40:12
tengo yo aquí mi aplicación, cuando yo la arranco 00:40:14
ala, aquí la tengo 00:40:16
ahí se queda, ahí lo infinito 00:40:18
para siempre jamás 00:40:19
ya está, ahí está, para siempre, para toda la vida 00:40:21
se queda, y yo puedo darle al X, puedo darle 00:40:24
a minimizar, puedo darle a lo que sea, y ahí sigue 00:40:25
por siempre jamás 00:40:28
nunca se para esa aplicación 00:40:29
entonces, ¿qué es lo primero 00:40:31
que nos faltaría aquí, que todavía no vamos a hacer? 00:40:34
pues tendríamos que 00:40:36
capturar el evento 00:40:37
darle a la X que está sin capturar 00:40:39
capturarle 00:40:42
para que haga un 00:40:43
system exit, para que pare 00:40:45
el proceso, tendríamos que capturarle 00:40:48
porque si no lo capturamos el evento 00:40:49
pues es que la aplicación está hasta el infinito 00:40:51
ahí, pero bueno como por ahora 00:40:54
no sabemos capturar el evento pues la paramos 00:40:56
aquí con el kill a la afuera 00:40:58
parada, vale 00:40:59
vale 00:41:01
bueno vamos a parar unos minutejos 00:41:03
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
21 de abril de 2024 - 19:03
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
41′ 09″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
596.43 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid