Saltar navegación

GUI 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 22 de abril de 2024 por Stefano C.

19 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, hoy empezamos a ver las interfaces gráficas, ¿vale? 00:00:00
Sería darle una cara bonita a nuestros maravillosos programas que hemos hecho hasta ahora 00:00:06
Solo que nuestros programas hasta ahora eran feos en el sentido que era todo de tipo textual 00:00:14
Cuando yo tenía un menú y tenía que añadir algo, pues siempre tenía que decir 00:00:20
Pulsa 1 si quieres añadir un alumno 00:00:25
Pulsa 2 si quieres asignar 00:00:28
A un alumno 00:00:30
Y cuantas veces 00:00:31
En vuestra vida de usuario 00:00:33
De Windows o de Linux 00:00:36
O de lo que sea 00:00:37
Habéis visto un programa así vosotros 00:00:38
Nunca 00:00:41
A lo mejor 00:00:42
Raramente en algunos 00:00:44
Linux que no tienen interfaz gráfico 00:00:47
Y se va por comandos 00:00:49
Y cosas por el estilo 00:00:51
Si habéis hecho 00:00:52
No sé, has ido a algunas prácticas más avanzadas de SMR antes 00:00:53
Pero por lo general, los usuarios no quieren usar interfaz de tipo texto 00:00:59
Lo que quieren es botones, ventanas y cosas que se hace clic encima 00:01:07
¿Vale? 00:01:12
Entonces nosotros ahora vamos a aprender 00:01:13
Poco, ¿vale? 00:01:15
Y de forma básica 00:01:18
Como podemos poner un interfaz gráfico a nuestros programas 00:01:19
La idea es que ahora damos un paso hacia ver como se construye un interfaz gráfico 00:01:24
Que es la programación a eventos y cosas por el estilo 00:01:35
Pero dejaremos a un lado todo lo que sabemos hacer, la parte digamos detrás de la interfaz 00:01:39
Porque vamos a aprender lo que se ve 00:01:46
Después la idea es que esto que se ve es simplemente un puente entre el usuario que no sabe programar y que no sabe utilizar bien el ordenador 00:01:49
Y lo que nosotros hemos hecho y programado detrás 00:02:00
Nuestro sistema de gestión de alumnos con sus materias y cálculo de notas y de medias de los alumnos será igual 00:02:03
Es el mismo que hemos hecho nosotros hasta ahora con los metoditos y con todo lo que hemos hecho hasta ayer 00:02:11
Simplemente le pondremos delante una interfaz 00:02:17
Que me permitirá acceder a estos datos o manipular estos datos de forma más sencilla 00:02:21
Teniendo en cuenta que la interfaz gráfica siempre es una pseudo trampa 00:02:26
Tiene dos problemas la interfaz gráfica 00:02:30
Primero, la interfaz gráfica me permite hacer cosas de forma más fácil 00:02:33
Pero siempre que yo hago una interfaz gráfica estoy limitado 00:02:39
A lo que el programador 00:02:45
Ha decidido que yo pueda hacer 00:02:48
¿Vale? Pensad en Windows 00:02:50
En Windows tú puedes 00:02:52
Configurar la IP 00:02:54
De tu ordenador 00:02:55
Mientras que hay una ventanita 00:02:57
Que te permite llegar allí y configurar 00:02:59
La IP de tu ordenador, pues tú puedes hacer 00:03:01
¿Sí? 00:03:03
Si no hay la ventanita para hacer 00:03:05
Lo que tú quieres hacer, las cosas 00:03:08
Se complican 00:03:10
No sé si me explico lo que quiero decir 00:03:10
Si tú tienes el botón por algún lado de Windows que te permite modificar lo que quieres modificar 00:03:13
Pues vas a ese botón, lo clicas y haces algo 00:03:19
Si ese botón no está, porque quien ha hecho la interfaz gráfica ha decidido no ponerlo 00:03:21
O porque se lo ha olvidado o porque no funciona ese botón 00:03:27
Pues ahora tú no tienes la interfaz para gestionar con la parte del sistema que tú quieres 00:03:30
Así que, tú te creas 00:03:36
Sistema que añade alumnos 00:03:39
Tiene el método de añadir alumnos 00:03:43
Quita alumnos, no sé qué, no sé cuánto 00:03:44
Y cuando haces la interfaz gráfica 00:03:46
No pones el botón crea alumno 00:03:48
Tú no puedes crear el alumno 00:03:50
¿Sí? 00:03:53
Entonces la interfaz gráfica siempre 00:03:54
Puede ser una limitación 00:03:56
Así, pilladlo como 00:03:57
Anécdota y cosas por el estilo 00:04:02
Pero es un poquito quizás la diferencia que podríamos ver entre Windows y Linux 00:04:03
Windows es muy fácil de utilizar 00:04:08
Pero cuando algo no se puede hacer con ventanitas y botones 00:04:11
Hacerlo se vuelve muy complejo 00:04:15
Linux todo es muy complejo 00:04:17
Es siempre con comandos muy largos 00:04:20
De hecho la gente se acostumbra a utilizar comandos 00:04:23
A utilizar el command line interface, la parte textual 00:04:26
Y entonces llega un momento en que sí que hay la parte gráfica 00:04:29
Así que hay la parte para poder ir a buscar el botón que lo hace, pero tú ya te conoces el comando gigantesco que te hace la misma cosa 00:04:33
y prefieres trabajar con el comando que con la ventanita, ¿vale? 00:04:40
Y eso también nos lleva al segundo punto sobre las interfaces gráficas. 00:04:45
Las interfaces gráficas son programas y como son programas, tienen bugs, tienen errores, tienen posibles vulnerabilidades. 00:04:50
Un programa sin interfaz gráfico 00:04:59
Posiblemente 00:05:02
Tendería a ser 00:05:03
Más seguro 00:05:06
En general 00:05:07
En media, que un programa con 00:05:10
Interfaz gráfica, simplemente porque 00:05:12
Tú tienes el mismo programa que hace lo mismo 00:05:14
A uno le añade más línea de código 00:05:16
Que además te hace una interfaz gráfica 00:05:18
Y tiene los mismos errores 00:05:20
Que tenía el otro, más los errores 00:05:22
Que puedes haber insertado tú 00:05:24
Al hacer la interfaz gráfica 00:05:26
Por eso los servidores 00:05:27
Digamos más avanzados 00:05:30
Que tienen que ser más sólidos, más seguros 00:05:31
Pues suelen ser sin interfaz gráfica 00:05:34
Se quita la interfaz gráfica del sistema operativo 00:05:36
Y se comanda todo con línea de comandos 00:05:38
Acceso directamente textual 00:05:40
¿Por qué? Porque no tengo por encima la estructura 00:05:42
De toda la parte gráfica 00:05:44
Además son más ligeros 00:05:47
Son más rápidos 00:05:48
Porque solo se centran en lo que tienen que hacer 00:05:51
Etcétera, etcétera 00:05:53
Y aquí vuelve un poco a la cosa 00:05:54
Windows siempre tiene la idea 00:05:56
De ser amigable con el usuario 00:05:59
Y para usuarios que no son expertos 00:06:01
Windows fenomenal 00:06:03
Linux 00:06:04
Tende más a ser 00:06:07
Menos amigable 00:06:08
Pero por ejemplo hay versiones de Linux 00:06:10
Que no tienen interfaz gráfica 00:06:12
Tú puedes conectarte con un SSH por remoto 00:06:14
Y le mandas comandos 00:06:16
Sin necesidad de tener 00:06:18
Ventanitas 00:06:21
Botones 00:06:22
Entonces 00:06:23
¿Qué son las interfaces gráficas? 00:06:27
¿Vale? 00:06:30
Vamos a ver cuáles son los elementos 00:06:30
De una interfaz gráfica 00:06:33
¿Vale? 00:06:34
Que son las cositas que podemos añadir 00:06:35
Y las organizaciones 00:06:39
De estos elementos 00:06:41
O sea, yo voy a añadir botones 00:06:42
Voy a añadir, qué sé yo 00:06:44
Campos de texto, etcétera 00:06:46
¿Cómo se organizan estos? 00:06:47
¿Cómo los puedo mover? 00:06:50
Como los puedo decir, tú me ponte aquí 00:06:52
Tú ponte a la derecha, tú ponte a la izquierda 00:06:54
Esto, en un cierto sentido 00:06:55
Se puede parecer 00:06:58
A lo que habéis hecho en HTML 00:07:00
Habéis hecho algo en HTML 00:07:02
Habéis hecho 00:07:03
Los controles 00:07:05
En plan checkbox 00:07:07
Button 00:07:09
Los botones 00:07:11
Los elementos 00:07:14
De la interfaz gráfica al fin y al cabo son esos 00:07:15
¿Vale? 00:07:18
El layout en HTML se hace de una forma, normalmente indicando las coordenadas 00:07:18
Aquí se puede hacer o indicando las coordenadas o indicando otras cosas 00:07:26
O usando un layout ya por defecto 00:07:30
Pero más o menos las ideas son esas 00:07:33
Si habéis entendido la parte de HTML sobre construcción de interfaces 00:07:36
Pues esto será relativamente fácil 00:07:41
Tened en cuenta también que esto será interfaces utilizando Java 00:07:43
¿Vale? Porque nosotros estamos aprendiendo Java 00:07:51
Y la realidad es que en el mundo real allá afuera 00:07:53
Java no se suele utilizar mucho para hacer interfaces 00:07:56
¿Vale? 00:08:00
Las interfaces se suelen hacer con otro tipo de lenguajes 00:08:01
Con otro tipo de tecnologías o herramientas 00:08:04
Que hacen las interfaces más bonitas 00:08:07
Y más... quizás más fácil de hacer 00:08:09
¿Vale? Simplemente esto es 00:08:13
Para completar Java 00:08:15
Java tiene su forma, ahora lo vamos a ver 00:08:17
Como se hace, nosotros así 00:08:19
Practicamos siempre Java y sabemos la filosofía 00:08:21
De Java, el próximo año creo que tenéis 00:08:23
Una asignatura que se llama 00:08:25
Construcción de interfaces 00:08:27
Vosotros tenéis desarrollo lado cliente 00:08:28
Que más o menos 00:08:31
Se dedicará a construir 00:08:33
Una interfaz más bonita 00:08:35
Y hacer todos los controles que 00:08:37
Tiene que hacer su interfaz 00:08:39
Entonces nosotros vamos a ver estas dos cosas 00:08:40
Que podemos poner en la interfaz gráfica 00:08:43
Y como las organizamos 00:08:44
La interfaz gráfica es la parte del programa 00:08:47
Que interactúa con el usuario 00:08:51
Es decir, tenemos elementos gráficos 00:08:53
Imágenes, iconos, botones, cosas raras 00:08:58
Que sostancialmente el usuario pueda reconocer 00:09:01
De forma más fácil que tener que escribir 00:09:04
Y leer texto, y texto, y texto, y muros de texto 00:09:06
Es intentar hacer un entorno sencillo e intuitivo para el usuario 00:09:08
Para que pueda hacer lo que nosotros queremos hacer 00:09:15
Nosotros sabemos hacer con un montón de código por detrás 00:09:17
Sin que él vea lo que es 00:09:20
Es una máscara, es algo que me permita hacer más fácil 00:09:22
Lo que detrás es más complejo 00:09:26
Eso en un cierto sentido es la evaluación de la línea de comando 00:09:29
Todos los ejercicios que hemos hecho ahora 00:09:33
Nosotros hemos podido interactuar con el usuario 00:09:36
A través de línea de comando 00:09:38
Nosotros normalmente simplificamos 00:09:39
Y mandamos 1, 2, 3, 4 00:09:42
Nadie te prohíbe usar un escáner 00:09:44
Para leer un comando entero 00:09:46
Y interpretar ese comando 00:09:48
Rehacer una command line 00:09:49
Un cmd 00:09:52
Para hacer vuestro propio programa 00:09:53
De gestión de lo que queráis 00:09:55
Pero normalmente 00:09:58
Las líneas de comando 00:10:00
Son menos amigables para los usuarios 00:10:01
Quien no sabe utilizar los usuarios 00:10:04
Tiene que aprender cuáles son los comandos 00:10:05
Y cuál es el formato de los comandos 00:10:08
Una vez que lo sabe, lo puede utilizar 00:10:10
Si yo no lo sé, es mucho más fácil darle a un botón 00:10:12
Añade alumno, que tener que hacer 00:10:14
Un código especial de add 00:10:16
Espacio alumno, espacio el nombre 00:10:18
Espacio la fecha de nacimiento 00:10:20
En formato, no sé qué 00:10:23
Todo más complejo 00:10:24
¿Vale? Y se suele 00:10:26
Llamar estos 00:10:28
Guy 00:10:29
Graphical User Interface 00:10:30
¿Cómo construimos 00:10:34
Interfaces en Java 00:10:38
Hay varias opciones 00:10:40
En general hay tres 00:10:41
Paquetes 00:10:44
Que están por ahí 00:10:46
Para hacer la interfaz gráfica 00:10:47
En Java 00:10:50
Uno se llama AWT 00:10:50
Que es la versión más vieja 00:10:53
Aún así 00:10:56
Algunas cosas que utilizaremos 00:10:57
Nosotros vienen de ese paquete 00:11:00
De allí 00:11:02
Porque es como la parte más básica 00:11:02
Y más sólida 00:11:06
De las interfaces gráficas 00:11:08
Y también la más vieja 00:11:09
La que proporcionaba menos posibilidades 00:11:10
Para hacer interfaces gráficas 00:11:14
¿Vale? 00:11:16
A continuación salió 00:11:17
El Swing 00:11:19
Que es una librería 00:11:20
Que expande un poco 00:11:24
Lo que puede hacer AWC 00:11:25
Añadiendo algunos controles más 00:11:27
Añadiendo algunas opciones 00:11:29
A las interfaces gráficas 00:11:30
Extra 00:11:33
Con respecto a OVT 00:11:36
Y nosotros esto veremos 00:11:37
Y luego está JavaFX 00:11:39
Que es como 00:11:42
Una extensión y un cambio 00:11:44
Un poco de mentalidad 00:11:46
Con respecto a Swing 00:11:48
Para hacer interfaces gráficas 00:11:49
También un poquito más avanzadas 00:11:52
Pero digamos que JavaFX 00:11:54
No es 00:11:56
Entre comillas 00:12:00
Java puro 00:12:02
Mezcla algunas cosas extra de Java 00:12:03
Como por ejemplo se puede utilizar CSS 00:12:06
Para organizar las interfaces 00:12:08
Se puede utilizar una cosa que se llama 00:12:13
Fxml 00:12:16
Que es como un lenguaje XML 00:12:19
Pensado para construir interfaces 00:12:21
Es como que sale un poquito del mundo de Java 00:12:26
Y añade herramientas más interesantes 00:12:30
Más potentes para hacer interfaces un poquito 00:12:33
Mejores, porque claro, con CSS puedo 00:12:35
Modificar varias cosas, pero 00:12:37
Nosotros nos quedamos en el mundo 00:12:39
De Java, ¿vale? Así está 00:12:41
Vamos a utilizar las reglas de Java 00:12:43
Que hemos utilizado hasta ahora, los métodos 00:12:45
Las llamadas, las funciones, reforzamos 00:12:47
Lo que ya sabemos 00:12:49
Y al mismo tiempo nos quedamos en 00:12:50
Java puro, no tenemos 00:12:53
Que aprendernos un lenguaje 00:12:55
XML extra o 00:12:57
Volver a hablar 00:12:59
De CSS que entra en otra asignatura 00:13:01
¿Vale? 00:13:04
Entonces nosotros vamos a utilizar 00:13:04
Swing, ¿vale? 00:13:08
Si buscáis por ahí en internet 00:13:08
Hay mogollón de tutoriales 00:13:11
De Swing, hay mogollón de 00:13:13
Páginas que os explican 00:13:15
Hay mogollón de páginas 00:13:18
En Stack Overflow 00:13:19
Donde si tenéis alguna duda 00:13:21
Os la resuelvan, o sea que hay un montón de material 00:13:23
Para esto 00:13:25
JavaFX es más nuevo 00:13:26
Java Swing 00:13:29
Está ya 00:13:30
Allá afuera desde hace mucho tiempo 00:13:32
Hay varias aplicaciones 00:13:34
Con JavaScript, entonces conocerlo 00:13:37
No es que es inútil, puede ser que 00:13:39
Alguna vez lo veáis 00:13:40
Tened en cuenta lo que os decía antes, vale 00:13:41
Veréis que las 00:13:44
Interfaces gráficas que salen en Java 00:13:47
No son muy bonitas 00:13:49
En realidad, al menos con Swing 00:13:50
No salen cosas muy bonitas 00:13:52
Entonces nosotros lo hacemos como ejercicio 00:13:54
Para aprender, para ver 00:13:56
Posiblemente si quieres hacer algo atractivo 00:13:58
Algo que sea bonito 00:14:01
Pues en vez de hacerlo en Java 00:14:02
Pues lo harías con otro programa 00:14:04
O cosas así 00:14:08
Vosotros en caso web 00:14:09
Tendréis la parte digamos 00:14:11
Lado cliente 00:14:13
Que estará en el navegador 00:14:16
Y que probablemente usaréis 00:14:17
Javascript para crear toda la página 00:14:19
Y las cosas bonitas 00:14:22
De la página cliente 00:14:24
Que luego se conectará 00:14:25
Con un servidor y luego estará 00:14:27
Ahí el backend, estará el 00:14:29
El lado servidor 00:14:30
Donde estarán otros 00:14:33
Lenguajes, entre ellos podría 00:14:35
Estar Java, que es lo que hace 00:14:37
Las cosas, vale 00:14:39
JavaScript por delante que hace las cosas 00:14:40
Bonitas y luego Java podría 00:14:43
Ser una opción 00:14:45
Detrás para que, ok, yo he elegido 00:14:46
Que mi 00:14:49
Viaje tiene que ir 00:14:51
De Madrid a Roma 00:14:53
A este 10, pues lo mando todo 00:14:55
Al lado servidor 00:14:57
Que hace todas las búsquedas, saca de la base 00:14:59
De datos cuáles son los vuelos 00:15:01
Y me lo devuelve y otra vez el lado cliente 00:15:03
Lo pinta bonito, ¿sí? 00:15:05
Más o menos, esto es lo que aprenderéis a hacer 00:15:07
El próximo curso 00:15:09
¿Sí? Entonces 00:15:10
¿Qué clases o qué 00:15:13
Elementos me proporciona 00:15:15
Java Swing, ¿vale? 00:15:17
Pues 00:15:20
Son parecidos a lo que ya habéis visto 00:15:20
en HTML, vale, por ejemplo, puedo poner 00:15:23
etiquetas, vale, esto no es 00:15:25
nada, es un comandito que se llama 00:15:27
jlabel 00:15:29
que es, me sirve 00:15:30
para etiquetar, para marcar 00:15:33
para poner un texto normalmente 00:15:35
al lado de otro componente 00:15:37
para decir, este componente es donde tienes que poner 00:15:39
el nombre del alumno, este componente 00:15:41
es donde pone el apellido del alumno, este componente 00:15:43
es, no se que, vale 00:15:45
es solo una 00:15:47
información 00:15:48
para hacer más clara la interfaz 00:15:50
JButton 00:15:53
Pues este es un botón 00:15:55
Esto me creará un botón 00:15:57
Le podré escribir un texto dentro 00:15:58
En plan daña de alumno 00:16:00
Y cuando pincho pues hará algo 00:16:01
Ya veremos como se hacen las cosas 00:16:03
JTextField 00:16:05
Es un campo de texto 00:16:08
JTextArea 00:16:10
Un área de texto 00:16:11
Lo mismo que estaban en HTML 00:16:12
Si no les conocéis o no os acordáis 00:16:15
Me lo preguntáis 00:16:18
Checkbox 00:16:19
Es una de esas casillas de verificación 00:16:21
De las cuadradas que tú puedes pinchar 00:16:23
Es decir, seleccionar o no seleccionar 00:16:25
De estas que puedes seleccionar cuantas te da la gana 00:16:28
JRadioButton 00:16:30
Es las redondas 00:16:31
Las que normalmente van en grupo 00:16:34
Y son excluyentes una a otra 00:16:36
Y tú eliges o esta o esta 00:16:38
Cuando son 00:16:40
Opciones 00:16:41
Que tú no puedes elegir más de una 00:16:44
Puedes elegir una y que cuando pinchas 00:16:46
En otro radiobutton 00:16:48
Que está, digamos, en el mismo bloque 00:16:50
Te quita el anterior y te selecciona el nuevo 00:16:52
¿Vale? 00:16:54
JList para crear una lista 00:16:56
Un menú 00:16:58
Tipo, de esos desplegables 00:16:59
O cosas por el estilo 00:17:02
JScrollBar para crear una 00:17:03
Barra de desplazamiento 00:17:06
Para bajar y subir dentro de la ventana 00:17:08
Que se crea, ¿vale? 00:17:10
Estos son ejemplos 00:17:12
Habrá más, ¿vale? 00:17:14
Un montón de componentes más, pero estos son componentes básicos 00:17:15
Que yo puedo utilizar, los coloco dentro 00:17:18
De una ventanita 00:17:20
Y luego le doy vida 00:17:21
Diciendo que cuando pasa algo 00:17:23
Pues hace otra cosa 00:17:25
Pero esto lo veremos ya más adelante 00:17:27
Por ahora nos centramos simplemente 00:17:29
En el diseño de la interfaz 00:17:31
En lo que se ve 00:17:33
Como se colocan las varias 00:17:35
Cosas 00:17:36
La idea es que en Java 00:17:40
Cuando usamos Swing 00:17:41
Hay una metáfora del concepto de una pared 00:17:42
Nosotros cuando 00:17:46
Creamos una interfaz gráfica 00:17:48
Es como si tuviéramos una pared 00:17:49
¿Vale? 00:17:51
Que estará el 00:17:52
Se usan Jpanels 00:17:53
¿Vale? 00:17:59
Y la idea es que yo tengo 00:18:00
Una pared al fondo 00:18:03
Un panel al final 00:18:04
¿Vale? Encima de este panel 00:18:06
Voy colocando 00:18:09
Las varias 00:18:10
Los varios elementos 00:18:11
Los botones, las etiquetas 00:18:14
Las listas 00:18:17
Lo que me hace falta 00:18:18
Pues lo voy colocando sobre la pared 00:18:20
Lo que puedo hacer 00:18:22
Es colocar encima de esta pared 00:18:24
Otro panel 00:18:26
Para organizar mejor 00:18:27
Sería como poner un corcho 00:18:30
En la pared 00:18:32
Entonces tendría 00:18:34
Mi pared al final 00:18:35
Donde pongo los varios elementos 00:18:38
Y luego tengo un corcho 00:18:40
Donde puedo poner los elementos organizados de otra forma 00:18:41
Y nadie me prohíbe 00:18:44
Dentro de este corcho poner otro corcho 00:18:46
Que me permita organizarlo de otra forma 00:18:48
¿Vale? La idea es que voy 00:18:50
Creando secciones de mi 00:18:51
Interfaz y en cada una de estas secciones 00:18:53
Organizaré los elementos 00:18:56
De alguna forma ¿Vale? 00:18:57
Con un layout o yo 00:18:59
Directamente poniendo 00:19:01
Las coordenadas para decir esto 00:19:03
Pónganlo aquí, esto pónganlo aquí, esto pónganlo aquí 00:19:05
¿Sí? 00:19:07
Entonces 00:19:10
La idea es que 00:19:11
Luego mi pared será una 00:19:13
Ventana ¿Vale? Habrá una 00:19:15
forma de crear una ventana 00:19:17
básica, la ventana básica 00:19:19
tendrá un titulito y tendrá los 00:19:21
clásicos botones estos de cierra 00:19:23
minimiza, maximiza 00:19:25
y cosas por el estilo, que yo 00:19:27
luego podré organizar 00:19:29
para decir, oye mira, quiero que no se pueda 00:19:31
maximizar, quiero que no se pueda cerrar 00:19:32
bueno, mejor que no, quiero que 00:19:35
no se pueda minimizar y cosas por el estilo 00:19:37
entonces puedo quitar estos 00:19:39
botones o cosas por el estilo, pero en general 00:19:41
es así 00:19:43
el fondo de mi 00:19:44
Ventana es la pared 00:19:46
Y lo que yo puedo hacer es 00:19:49
Colocar allí objetos, botones 00:19:51
Etcétera, etcétera, etcétera 00:19:53
Puedo pillar un área de esta de aquí 00:19:54
Y decir, oye, mira, esto 00:19:57
Considéramelo como un panel aparte 00:19:58
O sea que ahora 00:20:01
Voy a poner a la izquierda unos botones 00:20:02
A la derecha este panel 00:20:05
Y dentro de este panel voy a organizar 00:20:06
Las varias etiquetas 00:20:09
Las varias componentes que voy a utilizar 00:20:11
Como me da la gana 00:20:13
A lo mejor con una forma de organizarlos distinta con respecto al panel de abajo 00:20:15
A lo mejor el panel de abajo los organizo que todas las cosas que he añadido 00:20:19
Tienen que ir una al lado de otro y esta de aquí una encima de otro 00:20:24
O que esta de aquí lo organizo en una grid 00:20:28
Grid 00:20:35
Español, grid 00:20:36
Una grid 00:20:38
De dos celdas 00:20:41
Por dos celdas, o sea, dos columnas y dos filas 00:20:43
Pues, y este de aquí 00:20:45
En vez de lo organizo en 00:20:47
Una grid 00:20:48
De diez columnas 00:20:51
Y tres filas, no lo sé, ¿vale? 00:20:53
Puedo organizar 00:20:55
Varias partes de mi 00:20:58
Interfaz 00:20:59
Organizando, haciendo 00:21:01
Varios niveles de contenedores 00:21:03
De estos paneles uno encima de otro 00:21:05
¿Sí? Se entiende más o menos la idea 00:21:07
Entonces vamos a ver 00:21:09
El primer ejemplo de como se construye 00:21:12
Una ventana 00:21:16
¿Vale? 00:21:17
Primera cosa, una ventana en Java 00:21:19
En Java Swing 00:21:21
Es un JFrame 00:21:22
¿Vale? 00:21:25
Entonces, esta es la clase que nosotros vamos a utilizar 00:21:27
Y esto representa 00:21:30
Un marco, una ventana 00:21:31
¿Vale? Cuando yo creo 00:21:33
Un objeto de este tipo 00:21:34
Estoy creando una ventana vacía 00:21:36
¿Sí? 00:21:38
Otras cosas que me pueden servir 00:21:41
Es el Jpanel 00:21:43
Que es, apunto, un corcho 00:21:45
O la pared, donde yo luego 00:21:47
Pondré las cosas y las distribuiré 00:21:49
Y luego le digo, oye, mira 00:21:51
Este panel 00:21:53
El fondo de esta ventana 00:21:55
Por lo tanto, todo lo que he pegado en este panel 00:21:58
Se verá en la ventana 00:22:01
¿Sí? 00:22:02
Entonces, ¿cómo hacemos nosotros para funcionar? 00:22:03
Pues nosotros creamos nuestra nueva clase 00:22:07
Que será la clase que me permitirá hacer mi ventana 00:22:09
Y hacemos que esta extiende GFrame 00:22:13
De esta forma, mi nueva clase, mi nuevo programa que estoy haciendo 00:22:16
Es una ventana 00:22:22
Y hereda todo lo que necesita de una ventana 00:22:24
¿Vale? 00:22:27
A este punto veremos que hay un montón de comandos 00:22:28
Un montón de métodos que me permiten 00:22:31
Gestionar lo que se puede hacer con esta ventana 00:22:33
Como por ejemplo 00:22:36
¿Cuál es el tamaño de la ventana? 00:22:37
¿Dónde aparece la ventana? 00:22:39
¿Qué pasa si la cierro? 00:22:41
¿Vale? 00:22:44
Y cosas por el estilo 00:22:45
Entonces 00:22:45
Esto es un ejemplo 00:22:48
Luego las cosas pueden ser un poquito distintas 00:22:51
Pero para darnos una idea 00:22:53
Mi clase ejemplo, por ejemplo, tendrá dentro 00:22:54
Un JPanel, que será el ContentPane 00:22:57
Que es sustancialmente 00:23:00
El fondo 00:23:01
De mi ventana 00:23:03
Tenemos aquí un main 00:23:06
Este main 00:23:09
Está encargado 00:23:13
De empezar el programa 00:23:16
Cuando yo lo lanzo, entro aquí 00:23:18
Y lo que quiero que haga es que me 00:23:20
Aparezca la ventana 00:23:22
A ver 00:23:23
Para que aparezca la ventana 00:23:25
Uso 00:23:28
Esta cosa aquí 00:23:30
Rara 00:23:32
En realidad 00:23:33
Pero como funciona Swinger 00:23:35
Yo por un lado tengo el main 00:23:38
Todo lo que es la gestión de la interfaz 00:23:41
O sea, como 00:23:45
Que pasa cuando alguien pulsa un botón 00:23:46
Que pasa cuando alguien arrastra 00:23:49
Cuando pasas por encima 00:23:51
Cuando tienes que refrescar la ventana 00:23:52
Porque ha cambiado algo 00:23:55
Eso lo tiene que hacer alguien 00:23:56
Ahora, si yo tengo el main 00:23:59
Que hace sus cosas 00:24:02
¿Vale? Y hace el programa 00:24:03
Que quiero yo 00:24:06
Y le hago hacer al mismo main 00:24:07
También lo que debería hacer 00:24:09
La ventana 00:24:12
O sea, actualizarse 00:24:14
Recibir los botones y cosas por el estilo 00:24:15
Puede ser que estos 00:24:18
Entren en conflicto 00:24:19
Estoy haciendo hacer dos tareas distintas 00:24:21
Por un lado lo que quiera que haga 00:24:24
Mi main 00:24:26
Y por otro lado lo que es la gestión de la ventana 00:24:26
Con todos los problemas que puedan surgir en la ventana 00:24:30
Relacionado con la interfaz gráfica 00:24:32
Lo hago hacer al mismo hilo de ejecución 00:24:35
Pues esto podría causar problemas 00:24:38
Porque si yo me meto a hacer una cosa muy larga y muy compleja 00:24:42
Con mi main 00:24:46
Mi interfaz estaría bloqueada 00:24:47
Porque mientras mi main está calculando el factorial 00:24:50
De un número largo así 00:24:55
Y tarda 10 minutos 00:24:58
Nadie se está encargando 00:24:59
De hacer refresh sobre la ventana 00:25:01
Entonces mi ventana se quedaría allí paralizada 00:25:02
¿Vale? Y eso no gusta 00:25:05
Entonces la idea 00:25:07
Que hoy en día 00:25:09
Lo que se suele hacer es 00:25:10
Dividir en un cierto sentido 00:25:12
Lo que está haciendo el main 00:25:15
Y crear un nuevo 00:25:16
Hilo de ejecución, un hilo de ejecución 00:25:19
Paralelo, una, otro 00:25:21
Thread, ¿vale? 00:25:23
Que sustancialmente me permita 00:25:25
Mientras el main 00:25:27
Sigue haciendo lo que quiera 00:25:29
Que a lo mejor luego no hace nada, como aquí 00:25:30
Muere, ¿vale? 00:25:32
Pero se ha dividido y ha dicho 00:25:34
Mira, tú haz así, créame un nuevo hilo de ejecución 00:25:35
Que se ejecutará como 00:25:39
Independientemente 00:25:41
Y este hilo de ejecución será el que se encarga 00:25:42
De la interfaz 00:25:45
De esta forma, mientras yo estoy haciendo cosas con mi main 00:25:46
Habrá, el procesador 00:25:49
Podrá ejecutar otras cosas 00:25:51
Sobre la interfaz gráfica 00:25:53
Y no parecerá que la interfaz gráfica 00:25:55
Está bloqueada 00:25:58
La interfaz gráfica se podrá actualizar 00:25:58
Y funcionar porque hay 00:26:02
Dos hilos de ejecución 00:26:03
Paralelo que se ejecutarán 00:26:05
En mi procesador 00:26:08
Por ejemplo en núcleos distintos del procesador 00:26:09
Por lo tanto a mi me parece 00:26:12
Que las dos cosas están funcionando 00:26:13
¿Se entiende más o menos la idea? 00:26:15
¿Lo pasarás con interfaz gráfica? 00:26:17
A ver, esto lo vemos por interfaz gráfica 00:26:21
En realidad esto se suele usar 00:26:23
Para mucho más otra cosa 00:26:25
Esto sería programación paralela 00:26:26
Que en la gestión de procesos 00:26:29
Y cosas por el estilo se suele utilizar mucho 00:26:32
Segundo de DAM 00:26:34
¿Vale? En segundo de DAM hay una asignatura 00:26:35
Que se dedica a explicaros esto 00:26:38
¿Vale? 00:26:40
No sé si en segundo de DAW 00:26:42
Habrá algo que 00:26:44
Vais a mirar multithreading también 00:26:45
No lo sé 00:26:48
¿Vale? Con los problemas que surgen por aquí 00:26:49
¿Vale? Pero esta es la idea de que 00:26:51
Esto event queue.invoc later 00:26:54
New runable 00:26:57
¿Vale? 00:26:58
Que pilla de paréntesis 00:26:59
Esta paréntesis aquí se cierra aquí abajo 00:27:00
¿Vale? Todo esto está dentro 00:27:03
De esta paréntesis 00:27:05
Me está sustancialmente diciendo, es un método 00:27:05
Que asumimos como, si, si, sabemos que hace 00:27:08
Pero no lo sabemos muy bien 00:27:11
Que es, oye, mira, cuando vas a crear 00:27:12
Esta GFrame 00:27:15
No lo crea el main 00:27:17
Directamente 00:27:19
El main crea un hermano 00:27:21
Hilo de ejecución 00:27:23
Ahora en vez que un hilo solo de ejecución 00:27:24
Hay dos hilos de ejecución 00:27:26
El main sigue haciendo lo suyo 00:27:27
Y este otro será el encargado 00:27:29
De hacer esto 00:27:31
Para eso, para crear un nuevo thread 00:27:32
Se necesita, hay dos formas 00:27:35
O extend the thread 00:27:37
Que no se lo que es 00:27:39
O creas un nuevo objeto runable 00:27:40
Un objeto ejecutable 00:27:43
Si, no se que sentido 00:27:44
Y aquí 00:27:47
Lo que hacemos es creamos un new runable 00:27:49
Pero runable no es una clase 00:27:51
Es una interfaz 00:27:54
Y nosotros no podemos 00:27:56
crear un objeto runable. Y aquí es una cosa de Java que es una clase anónima. Yo estoy 00:27:57
creando new runable y a continuación abro una llave que se cierra aquí y aquí estoy 00:28:08
definiendo esta clase. Es como si yo hubiese hecho clase mi ejemplo o clase mi 00:28:18
runnable, implements runnable 00:28:27
y dentro hubiese puesto 00:28:29
esto 00:28:31
y luego aquí en vez de hacer 00:28:32
new runnable habría hecho un 00:28:35
new mirannable 00:28:36
pero como esto se suele 00:28:38
hacer mucho, lo veremos después 00:28:41
en clase eventos y cosas por el estilo 00:28:42
y esto también es una feature, es una característica 00:28:45
de Java, vale 00:28:47
Java me permite, si yo aquí quiero 00:28:48
poner una clase 00:28:51
vale, quiero poner un objeto 00:28:53
Pero no tengo definida la clase de este objeto 00:28:55
Y por lo tanto no puedo crear un objeto de esta clase 00:28:58
Puedo crear lo que es una clase anónima 00:29:01
Esta es una clase anónima 00:29:03
Me dice, créame un nuevo objeto runnable 00:29:05
Oye, pero, ¿y qué es este objeto? 00:29:07
Pues te lo describo aquí 00:29:09
Esto es como si fuera una clase 00:29:10
De hecho, allí dentro le estoy definiendo un método 00:29:11
¿Vale? 00:29:16
Ahora cuando vamos a hacer una prueba de esto 00:29:16
¿Vale? 00:29:21
Os hago ver, lo quito de aquí 00:29:22
Lo pongo en otro lado, a lo mejor lo entendéis mejor 00:29:24
Pero que esta es una opción 00:29:26
Que se puede hacer, ¿vale? 00:29:28
En particular, Runnable no es una clase 00:29:30
Es una interfaz, ¿vale? 00:29:33
Y cuando es una interfaz 00:29:34
¿Sabéis cómo es? 00:29:36
Nosotros podemos crear, podemos usar 00:29:38
Objetos Runnable, por ejemplo 00:29:40
En una lista 00:29:42
Yo puedo hacer una lista de Runnable 00:29:44
Hasta si Runnable 00:29:46
No es una clase 00:29:48
Es una 00:29:50
Una interfaz 00:29:51
Nosotros hemos hecho algunos ejemplos de esos 00:29:54
Utilizando como tipo 00:29:56
La interfaz en vez que la clase 00:29:59
Y sabemos que cuando usamos esto 00:30:01
Estamos diciendo 00:30:03
Me vale cualquier objeto 00:30:03
Que implemente esta interfaz 00:30:06
Entonces aquí 00:30:08
Te dice, estoy creando un objeto 00:30:10
Que no sé que objeto es 00:30:12
Pero sé seguramente que tiene que implementar 00:30:13
La clase runable, o sea no me enfado 00:30:16
¿Y qué es la clase runable? 00:30:18
La clase runable es una clase que 00:30:20
Perdón, la interfaz runable 00:30:21
Es una interfaz que me dice 00:30:23
Tienes que implementar el método run 00:30:24
Este método run será 00:30:26
Lo que se ejecuta 00:30:28
Al lanzar este nuevo thread 00:30:30
Si, porque si no 00:30:32
No implementaría run 00:30:36
Runable tensores 00:30:40
Si no habría tenido que poner 00:30:41
Intentando recapitular 00:30:43
Porque aquí hay muchas cosas 00:30:48
En este trocito de código 00:30:49
Hay muchas cosas que se podrían ir en profundidad 00:30:51
Cuanto queráis, ¿vale? 00:30:54
Pero la idea general que tiene que salir aquí 00:30:55
Pregunta 00:30:57
¿Cuántos en este código 00:30:59
Cuántos hilos de ejecuciones hay? 00:31:01
¿Cuántos? 00:31:08
Dos 00:31:10
El primero, ¿vale? 00:31:11
El main 00:31:15
¿Y qué ejecuta el main? 00:31:16
Por ejemplo, ejecuta este código 00:31:18
Y luego ejecutaría este, ejecutaría este 00:31:20
Eso es lo que hace el main 00:31:22
El main después de haber ejecutado este comando 00:31:25
Seguiría aquí debajo 00:31:27
Con los comandos que están aquí abajo 00:31:29
Ese es el main 00:31:31
¿Sí? 00:31:32
Pero el main con este comando 00:31:35
Crea un hermano, un hijo 00:31:37
Pensadlo como os da la gana, ¿vale? 00:31:38
Que es otro thread, otro hilo de ejecución 00:31:40
Independiente 00:31:43
Ahora esto hará su vida 00:31:44
Y esto hará su vida 00:31:45
Este intentará pillar el procesador para ejecutarse 00:31:47
Y este intentará pillar procesador para ejecutarse 00:31:51
Y son tareas distintas 00:31:53
¿Sí? 00:31:55
Mismo proceso 00:31:56
Pero hilos de ejecuciones distintos 00:31:57
¿Sí? 00:32:00
¿Y dónde está el código que tiene que utilizar este segundo hilo? 00:32:01
En el RAM 00:32:06
¿Se entiende? 00:32:07
Entonces aquí es como si hubiese dos main 00:32:12
Un main que es el main 00:32:14
Y el segundo main que es lo que he puesto dentro del RAM 00:32:15
Y los dos van en paralelo 00:32:18
Se ejecutan a la vez 00:32:21
¿Dudas? 00:32:22
El main no llama al método run 00:32:29
Porque si yo meto el main 00:32:32
Y llamara el método run 00:32:34
Lo estoy ejecutando yo 00:32:35
Estas cosas las está haciendo el main 00:32:36
En vez de no 00:32:38
El main lo que está llamando es un método 00:32:39
Que lo que hace es crear otro hilo de ejecución 00:32:42
Que ejecutará el run 00:32:45
Mientras yo hago otras cosas 00:32:46
Es importante 00:32:48
Ahí no estás definiendo lo que hacemos 00:32:50
Lo está 00:32:53
Es el event queue punto invoke later 00:32:54
Que permitirá que se cree 00:32:57
Un nuevo hilo y se ejecute 00:32:59
El main lo que está haciendo es 00:33:01
Las tareas para crear la posibilidad 00:33:05
De hacer eso, pero luego no lo hace 00:33:07
Esto, la parte que está 00:33:09
Aquí dentro de run, el main 00:33:11
No lo ejecutará nunca 00:33:13
Es otro thread que explota esto 00:33:14
¿Se entiende? Vale 00:33:16
A nosotros que nos interesa todo esto 00:33:18
Poco o nada, recordarse esto 00:33:21
¿Vale? 00:33:23
Porque luego nosotros nos centraremos aquí 00:33:24
Ahora mismo, ¿sí? 00:33:26
Simplemente porque lo veréis y decir 00:33:28
Oye, ¿pero qué es esto? ¿Por qué lo tengo que hacer? 00:33:30
Es más, si esto no lo hacéis 00:33:32
Funciona igual 00:33:35
Pero se expone a posibles problemas 00:33:36
Por eso es Long Check 00:33:39
¿Sí? 00:33:40
Ahora, vamos a ver dentro de Run, que es lo que nos interesa 00:33:42
Dentro de Run, por ejemplo 00:33:44
Creo un nuevo frame, ¿vale? 00:33:47
Que es un nuevo objeto 00:33:49
De la clase que estoy definiendo 00:33:50
Esta es mi clase, ¿vale? 00:33:53
Estoy creando un nuevo objeto 00:33:54
Ejemplo 00:33:57
Y os recuerdo que el objeto ejemplo 00:33:58
Es un JFrame 00:34:00
Entonces aquí estoy creando literalmente 00:34:01
Una nueva ventana 00:34:05
¿Sí? Y esta ventana 00:34:06
¿Qué atributos tiene? 00:34:08
Tiene un JPanel 00:34:10
Que se llama ContentPane 00:34:12
Esos son los atributos 00:34:14
De este objeto 00:34:17
¿Sí? 00:34:17
Vale 00:34:21
Y después le digo 00:34:21
Escúchame ventana que te he creado ahora 00:34:23
Set a tu visibilidad 00:34:26
Set visible a true 00:34:28
Una ventana que se crea 00:34:30
No se ve 00:34:32
En el momento que le digo 00:34:33
Set visible.true 00:34:35
Pues aparece 00:34:37
Esto me permite en teoría 00:34:38
Crear varias ventanas 00:34:41
Sin que el usuario lo sepa 00:34:42
Y que cuando hago una determinada acción 00:34:44
Una desaparece, aparece otra 00:34:46
Y parece que has cambiado de ventana 00:34:48
Pero ya estaba ahí 00:34:50
¿Vale? Sin abusar de eso porque cada ventana gasta recursos 00:34:51
¿Sí? 00:34:56
Si explota algo, pues, largo 00:34:58
Y ya está, ¿qué he hecho aquí? 00:35:02
Nada, la ventana vacía 00:35:04
La vamos a ver 00:35:06
Vamos a abrirla 00:35:07
Entonces, me pongo aquí 00:35:10
Tengo mi ejemplo 00:35:20
Mi ejemplo de ventana 00:35:22
Hemos dicho que para hacer 00:35:34
Mi ejemplo de ventana 00:35:36
Tengo que extender 00:35:38
JFrame 00:35:39
¿Vale? 00:35:43
Y JFrame se enfada 00:35:46
Dice ¿Qué es JFrame? 00:35:47
Vamos a verlo 00:35:49
JFrame la tengo que importar 00:35:50
Desde javax.swing 00:35:52
¿Vale? 00:35:54
Entonces ahora 00:35:55
He importado JFrame 00:35:56
Vale, fenomenal 00:35:58
Hemos dicho que 00:36:00
Si queremos podemos poner 00:36:01
Por ahora no lo utilizamos 00:36:03
Por eso no lo pongamos 00:36:04
Creo un main 00:36:05
Vale, esto será el punto de inicio de mi 00:36:06
De mi programa 00:36:10
Y lo que tiene que hacer este main es crear una ventana 00:36:15
Hemos dicho que lo podría hacer directamente aquí 00:36:18
Ahora si queréis luego lo hacemos y vemos que funciona 00:36:20
Pero como esto luego me podría dar problemas de 00:36:22
Deadlock 00:36:25
En español es 00:36:27
Interbloqueo 00:36:32
Entre los varios componentes que tengo 00:36:37
Pues entonces voy a crearme 00:36:40
Un thread adicional al que le dedicaré 00:36:42
Oye mira, tú te encargas de la 00:36:44
De la interfaz gráfica 00:36:46
Y entonces aquí 00:36:47
Para hacerlo lo que hago es 00:36:49
Eventqw 00:36:51
Punto invoque later 00:36:53
De un objeto 00:36:56
Runnable 00:36:58
¿Vale? Aquí dentro 00:36:59
Tiene que ir un objeto runnable 00:37:02
¿Vale? 00:37:03
Entonces, no lo tengo el objeto runable 00:37:04
¿Qué podría hacer? 00:37:07
Lo que podría hacer es esto 00:37:08
Me creo una nueva class 00:37:10
Que es mi runable 00:37:13
Y aquí digo 00:37:15
Implements runable 00:37:19
Se enfada porque dice 00:37:22
Oye, mira, implementas runable 00:37:26
Pero no está nada 00:37:27
Pues, espera 00:37:29
Añade los métodos no implementados 00:37:30
Que es solo el método run 00:37:32
¿Vale? 00:37:34
Y entonces, aquí dentro 00:37:35
Le pongo eso de 00:37:37
Ejemplo 00:37:39
Vui 00:37:41
Frame 00:37:43
Es igual a new 00:37:47
Ejemplo 00:37:49
Vui 00:37:50
Me estoy creando un objeto de este de aquí 00:37:52
¿Sí? 00:37:55
Y le digo 00:37:57
Frame 00:37:58
Punto set visible 00:38:01
True 00:38:02
Esto se enfada 00:38:06
Porque probablemente 00:38:09
Es el visible 00:38:11
Que he hecho 00:38:13
Ahí 00:38:14
¿Vale? Ya está 00:38:23
Ahora, ¿cómo uso 00:38:25
Esto aquí dentro? 00:38:28
Pues, tengo que poner 00:38:30
Un new 00:38:31
My run 00:38:32
Ya está, ¿vale? 00:38:34
Este señor de aquí me está diciendo 00:38:45
Oye, mira, créame un nuevo objeto 00:38:47
My run, ¿cuál es el objeto my run? 00:38:50
Es este objeto aquí, vale 00:38:51
Que hará sus cosas 00:38:53
Que es un objeto runnable 00:38:55
Tened en cuenta que aquí 00:38:57
Aquí dentro va un objeto runnable 00:38:58
Si yo voy a mirar 00:39:02
Event 00:39:04
Punto 00:39:12
Veis que 00:39:14
Invoke later 00:39:18
Pilla un objeto runnable 00:39:19
No un objeto concreto, runnable es un interface 00:39:21
Vale, me vale 00:39:24
Cualquier objeto que tenga un run dentro 00:39:25
Porque yo usaré ese run como código para este otro thread 00:39:28
El main de este otro thread será lo que está dentro del run 00:39:33
¿Se entiende? 00:39:36
Vale 00:39:38
Entonces, puedo crearme mi propio run 00:39:38
Y aquí dentro ponerlo 00:39:42
¿Vale? 00:39:44
Pero a veces, y muchas veces lo veremos sobre todo con los listeners 00:39:45
¿Vale? 00:39:49
No quiero crearme una clase nueva y darle un nombre y utilizarla 00:39:51
Quiero crear lo que se llama una clase anónima 00:39:56
¿Vale? 00:39:59
Clase anónima es, estoy definiendo una clase 00:40:00
Sin definir el nombre de la clase 00:40:02
Simplemente te estoy diciendo 00:40:05
Mira, aquí dentro iría un objeto 00:40:06
Que tiene esta característica, estos métodos 00:40:08
Estas clases, te las pongo aquí 00:40:10
Creamos un objeto desde aquí 00:40:12
¿Cómo se llama? No se llama 00:40:13
Creamos un objeto así 00:40:15
¿Cómo se hace eso en Java? 00:40:16
Pues en vez de hacer así 00:40:20
Yo te digo, mira, oye 00:40:21
Ponme aquí un objeto run 00:40:23
Unable 00:40:24
Porque, cuidado 00:40:25
Aquí tiene que ir un método 00:40:28
Un runable, pero yo no puedo 00:40:30
Crear un runable 00:40:32
¿Sí? Porque runable es 00:40:33
Una interfaz 00:40:36
No se puede crear una estancia de una interfaz 00:40:37
Entonces te digo, sí, sí, no te preocupes 00:40:41
Que esta es una clase 00:40:43
¿Cómo se dice? 00:40:44
Anónima, o sea que 00:40:48
Lo que antes estaba aquí 00:40:49
Te lo voy a poner ahora a continuación 00:40:52
Para que tú lo sepas 00:40:56
De hecho él se enfadece 00:40:57
Mira que faltan los métodos 00:40:59
Mira, aquí está 00:41:01
¿Veis que esto 00:41:02
Es sustancialmente 00:41:07
Lo que antes ponía aquí 00:41:12
Estoy definiendo la clase 00:41:13
Sin definir una clase 00:41:17
O la característica 00:41:19
O los 00:41:25
¿Cómo se dice? 00:41:26
los atributos o los otros métodos 00:41:28
o las llamas, todo lo que quiera 00:41:31
lo puedo poner aquí 00:41:33
como todo lo que quiera lo puedo poner en esta 00:41:33
declaración de aquí, aquí estoy 00:41:36
declarando, como si aquí yo 00:41:38
se puede esto, new class, o sea 00:41:40
new runable de una clase 00:41:42
que es la clase miran 00:41:44
no sé qué, no sé cuánto, solo que no la he llamado 00:41:46
no tiene un nombre esta clase 00:41:48
por lo tanto es lo que se llama una clase anónima 00:41:50
¿sí? 00:41:52
es como 00:41:55
voy a construir un objeto 00:41:56
Hecho ad hoc ahora aquí 00:41:57
Porque no lo voy a reutilizar 00:42:00
Que lo utilice en 50 veces 00:42:02
Como alumno, que lo utiliza aquí, aquí, aquí 00:42:04
Pues entonces me creo su tipo 00:42:06
Lo llamo alumno y lo usaré 00:42:08
Pero como aquí lo uso solo aquí 00:42:09
Y no lo vuelvo a reutilizar en otro lado 00:42:11
Pues te lo creo aquí directamente 00:42:13
Esto es lo que quiero hacer y ya está 00:42:15
Lo veremos con los listeners 00:42:16
Que se utilizará la misma cosa 00:42:18
Es una opción 00:42:20
Es algo que te permite hacer 00:42:23
Java 00:42:25
Dejadme simplemente lanzarlo una vez 00:42:26
Para que veáis que es 00:42:29
Y os dejo ir 00:42:30
Entonces, aquí dentro pongo esto 00:42:32
¿Vale? Y ahora 00:42:35
Fijaos que mi run aquí no lo uso 00:42:37
Por lo tanto, se me ve inútil 00:42:39
Lanzo el main y lo que pasa es 00:42:40
Esto 00:42:43
Esto 00:42:45
Esto 00:42:51
¿Vale? 00:42:54
¿Vale? He hecho mi JFrame 00:42:57
Ahora, no le he dicho el tamaño, no le he dicho 00:42:59
donde se tiene que crear, pues ahí me he creado una cosa pequeña 00:43:00
pero está allí 00:43:03
¿eh? y fijaos 00:43:04
si yo os dejo ir, que si yo lo cierro 00:43:07
mi programa 00:43:09
bueno, no he escrito nada 00:43:11
pero mi programa no acaba 00:43:14
mi programa sigue allí 00:43:16
está funcionando, continúa a funcionar 00:43:18
¿sí? 00:43:21
¿veis? 00:43:35
sigue funcionando 00:43:37
ya está, espera aquí, apago allí 00:43:38
y si no grabo el feo... 00:43:46
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
19
Fecha:
22 de abril de 2024 - 13:13
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 49″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
109.16 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid