Saltar navegación

Clase 07-05-2024 - 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 11 de mayo de 2024 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Un poquito por encima para que a partir de ahí ya podéis investigar y hacer muchas más cosas, ¿vale? 00:00:02
Ya con eso dejaríamos completado pues lo que vamos a ver de Swing, que es una especie de visión, visión global por encima de cómo funciona, de las posibilidades que tiene y a partir de ahí ya uno se mete y hace lo que quiera, pero nosotros nos quedamos aquí. 00:00:10
Bueno, ¿qué nos ha faltado? ¿Qué nos ha faltado a nosotros ahora en interfaces gráficas? 00:00:26
pues sí, mucha interfaz gráfica 00:00:31
pero ahí ni hemos dibujado 00:00:33
ni hemos hecho nada 00:00:36
no pide el cuerpo dibujar un poco 00:00:36
hemos puesto botones, comandos 00:00:40
y ya está, pero no hemos dibujado 00:00:44
y una interfaz gráfica pues uno a lo mejor querría también 00:00:45
hacer sus propias figuras, sus cuadraditos 00:00:47
sus cosas, de eso no hemos hecho nada 00:00:49
lo que hemos metido es componentes que ya existen 00:00:51
nada más, normalmente 00:00:54
una interfaz gráfica 00:00:56
es eso, un conjunto 00:00:57
de componentes de una paleta 00:01:00
que uno 00:01:02
diseña, elabora un prototipo 00:01:03
y ya está, pero uno también tiene que poder 00:01:06
dibujar sus propios elementos 00:01:08
a veces, bueno pues 00:01:10
efectivamente hay una clase 00:01:12
que permite dibujar 00:01:14
que es la clase graphics 00:01:15
lo que pasa es que la clase graphics 00:01:17
no es una clase que uno instancie 00:01:20
que pueda instanciar 00:01:22
y usar sus métodos para dibujar 00:01:23
no funciona así 00:01:26
uno no instancia un objeto 00:01:27
de la clase graphics y dibuja, no 00:01:29
los objetos de la clase 00:01:31
graphics tienen que 00:01:33
recibirse a través 00:01:35
de un método 00:01:37
y entonces tú coges el parámetro que has 00:01:38
recibido, o sea, es una estructura un poco medio 00:01:41
rara, la que hace, pero bueno 00:01:43
vamos a ver un poquito por encima como es y ya está 00:01:45
a ver, por ejemplo 00:01:47
ejemplo graphics, aquí 00:01:49
pues vamos a ver, vamos a hacernos una clase 00:01:51
un frame 00:01:58
vamos a hacernos 00:02:00
un frame 00:02:05
vale, aquí tenemos nuestro frame 00:02:06
y vamos a hacer 00:02:23
el constructor 00:02:30
y el constructor, pues ahora mismo lo único 00:02:31
que va a tener es, vamos a darle 00:02:38
un tamaño 00:02:40
y que sea visible 00:02:41
a ver, para que no me aparezca 00:02:50
todo el rato en la esquina, le vamos a poner 00:02:57
en unas 00:02:59
aquí 00:03:00
pero este, si yo le pongo coordenadas 00:03:01
No era setSize, sino setBounce, ¿verdad? 00:03:07
Sí, vale 00:03:09
Vale, entonces este es mi frame 00:03:09
Que vamos, bueno, voy a hacer un main, claro 00:03:12
Para poder ejecutar esto 00:03:15
A ver 00:03:17
Vale, pues nada 00:03:18
Eh, ala, ya está 00:03:41
Pues ya está 00:03:47
Este es mi frame, que no tiene nada 00:03:57
Tiene un panel por defecto 00:03:59
Porque ya sabemos que todos los frames vienen con un panel por defecto 00:04:01
Pero panel por defecto 00:04:04
Al que yo no le he puesto nada todavía 00:04:06
No le he puesto ningún componente ni nada 00:04:08
Espera, le voy a poner lo del 00:04:09
Para que se salga 00:04:12
Como era ese método 00:04:16
This.set 00:04:19
Default close operation 00:04:22
Este será 00:04:26
Y esto era 00:04:27
Exit on close 00:04:28
Sería 00:04:32
Imagina 00:04:32
Así, ¿no? Con esto ya se cierra 00:04:34
Sí, vale 00:04:38
bueno, ya está, mi frame básico 00:04:48
que no tiene nada, salvo la opción de cerrar 00:04:52
colocarlo en coordenada 00:04:54
x100 y 100, tamaño 00:04:56
500, 400 00:04:58
ser visible y se acabó 00:05:00
vale, pues nosotros ahora 00:05:04
queremos dibujar en el panel 00:05:06
queremos dibujar en el panel que tiene por defecto 00:05:08
vale, pues necesitamos un objeto 00:05:10
graphics que es el que me provee de los métodos 00:05:12
para dibujar, dibujar cuadraditos, dibujar no sé qué 00:05:14
rellenarlos, patatín, necesito 00:05:16
ese objeto graphics, ese objeto graphics 00:05:18
no lo podemos instanciar 00:05:20
aquí, no podemos hacer 00:05:22
un graphics 00:05:24
new graphics e instanciarlo 00:05:25
y a partir de ahí dibujar, no podemos hacerlo 00:05:28
este objeto graphics que es el que 00:05:30
necesitamos para dibujar, tenemos que cogerlo 00:05:32
a través de un 00:05:34
método que se llama paint 00:05:36
que lo recibe como parámetro 00:05:38
bueno y ese método paint de donde ha salido 00:05:39
vale pues 00:05:42
los contenedores como los 00:05:44
frames, los paneles 00:05:46
son clases que ya existen en Java 00:05:47
obviamente, JPanel 00:05:50
JFrame, ya existen 00:05:52
y tienen un método Paint 00:05:54
que yo puedo sobreescribir o no 00:05:56
si quiero 00:05:58
entonces el método Paint es un método 00:05:59
que es el que la máquina virtual 00:06:03
llama automáticamente 00:06:04
cuando tiene que redibujar el panel 00:06:06
o el frame, ¿cuándo lo tiene que redibujar? 00:06:08
pues cuando uno da un clic 00:06:11
obviamente lo tiene que redibujar 00:06:12
porque lo que tú visualmente ves 00:06:14
ha cambiado, de hecho al hacer el clic el botoncito 00:06:16
ha cambiado mínimamente el color 00:06:18
en algún momento, tú ves físicamente 00:06:20
el botón hundiéndose o cambiando de color 00:06:22
entonces cada vez que haces algo 00:06:24
en el que tú físicamente has visto 00:06:26
que algo ha cambiado o cuando 00:06:28
redimensionas una ventana 00:06:29
cualquier cosa, ahí se está llamando 00:06:32
automáticamente al método paint 00:06:34
sin que todos lo veamos, sin que todos lo hagamos 00:06:36
¿vale? 00:06:38
cada vez que se hace algo que cambia 00:06:40
el aspecto de la ventana 00:06:42
cualquier cosa que hagamos 00:06:44
se está llamando automáticamente a ese método 00:06:47
que no lo hemos hecho nosotros 00:06:49
pero ese método lo tiene ya 00:06:51
la clase JFrame, lo tiene ya 00:06:53
la clase JPanel 00:06:55
entonces desde el momento en que le damos de JFrame 00:06:56
o cuando usamos un panel 00:06:58
ya tienen ese método Paint 00:07:00
entonces por eso no lo tenemos que hacer 00:07:02
porque ya está hecho y se llama automáticamente 00:07:03
para redibujar 00:07:06
entonces Paint es el método que sirve para 00:07:07
dibujar en pantalla 00:07:10
lo que nosotros vemos 00:07:12
ese método 00:07:13
entonces, resulta que ese método Paint 00:07:14
es el que recibe como 00:07:18
parámetro un objeto 00:07:19
Graphics, entonces si yo 00:07:21
sobreescribiera el Paint, ese método 00:07:23
si yo lo sobreescribo 00:07:25
ya tengo el objeto Graphics 00:07:26
porque es un parámetro del Paint 00:07:29
luego lo puedo utilizar dentro del Paint 00:07:32
ese Graphics 00:07:33
entonces, ¿qué tengo que hacer? 00:07:35
sobreescribir el método Paint 00:07:37
y a través de él 00:07:39
puedo sacar ya el Graphics para dibujar 00:07:40
bueno, pues esa es la idea 00:07:43
esa es la idea 00:07:45
¿vale? entonces todo, como veis 00:07:46
todo parte de las ideas que ya conocemos 00:07:48
y que se supone que tenemos interiorizadas 00:07:51
pues de herencia, de sobrescribir 00:07:52
de parámetros, de todo eso 00:07:54
todo está construido sobre esas ideas 00:07:56
que se supone que hemos ido cogiendo a largo del curso 00:07:58
vale, vamos a hacer una cosa 00:08:01
vamos a hacer nosotros un panel 00:08:02
que herede de jPanel 00:08:04
y vamos a sobrescribir el paint 00:08:06
entonces ya automáticamente al sobrescribir 00:08:08
el paint ya tenemos el grafis, que es lo que queremos 00:08:11
y ese panel vamos a hacer que sea 00:08:12
el panel por defecto de ese frame 00:08:15
con lo cual todo lo que dibujemos a través de ese 00:08:16
gráfico va a aparecer en el panel 00:08:19
que es lo que queríamos, entonces es una posibilidad 00:08:20
para dibujar 00:08:23
pero uno puede sobre escribir el paint de frame 00:08:24
que también lo tiene, bueno 00:08:27
pues venga, vamos a hacernos 00:08:28
aquí 00:08:31
una clase que herede 00:08:31
de jPanel 00:08:40
vale 00:08:42
jPanel es la clase 00:08:43
panel que existe en swing 00:08:48
entonces yo puedo hacer mi propia clase 00:08:50
heredando de ella 00:08:52
ala, si yo aquí no hago nada más 00:08:53
mi panel 00:08:57
es idéntica a jPanel 00:08:58
idéntica, vale 00:09:00
pues entonces, pero vamos a sobrescribir paint 00:09:04
entonces 00:09:06
el método paint, vamos a ver 00:09:07
si me lo pone como sobrescrito 00:09:10
porque si no me lo pone como sobrescrito 00:09:12
voy a mirarlo en 00:09:14
alguna chuleta 00:09:15
vale, he acertado con la cabecera 00:09:17
vale, veis que 00:09:27
efectivamente 00:09:30
en cuanto yo he escrito esta cabecera 00:09:32
en cuanto yo la he escrito 00:09:34
me ha puesto aquí el símbolo 00:09:36
de está sobrescribiendo 00:09:38
el paint, perfecto 00:09:40
es justo lo que quería, si me hubiera 00:09:42
equivocado y hubiera puesto 00:09:44
aquí otra cosa 00:09:46
pues ya obviamente 00:09:47
no estoy sobrescribiendo 00:09:49
el paint, sino que estoy haciendo otro método distinto 00:09:52
pero yo no 00:09:54
quiero hacer otro método, quiero sobreescribir este 00:09:56
porque este es el que se llama automáticamente 00:09:58
se llama cuando 00:10:00
el panel se tiene que redibujar 00:10:02
a ver si se tiene que redibujar 00:10:04
vale, pues entonces 00:10:05
ahora ya a través 00:10:07
de este 00:10:11
método paint de aquí 00:10:12
ya tengo un graphics para dibujar 00:10:15
que es este 00:10:17
y este graphics aquí tiene 00:10:18
un montonazo de métodos 00:10:21
de dibujo, hacer rectas 00:10:23
líneas, dibujar no sé qué 00:10:26
todo, todo tipo de 00:10:27
tonterías, por ejemplo 00:10:29
vamos a dibujar un 00:10:31
un óvalo 00:10:36
que esté 00:10:42
pues yo que sé si la ventana está en 00:10:48
imagino 00:10:50
que eso será coordenada X, coordenada Y 00:10:52
vamos a probar 00:10:54
150 a 150 00:10:55
y que sea pues de 00:10:58
60 a 60 00:11:00
o sea pequeñajo 00:11:02
vale 00:11:03
he dibujado este cacharro de aquí 00:11:05
vale, entonces ahora 00:11:08
este panel cada vez que 00:11:10
se tenga que dibujar 00:11:12
porque ha cambiado el aspecto de la ventana 00:11:14
o lo que sea, pues va a llamar a paint 00:11:16
en este caso 00:11:18
el paint lo único que hace es dibujar 00:11:21
el mismo óvalo una y otra vez 00:11:23
pero yo aquí podría jugar y hacer mil cosas 00:11:24
pues hacer una variable 00:11:27
que esa variable se fuera incrementando 00:11:29
y lo multiplicara por aquí 00:11:31
con lo cual cada vez que redimensiono 00:11:34
el panel, el óvalo se va haciendo cada vez más grande 00:11:36
más grande, yo aquí ya con esto ya podría hacer 00:11:38
mil combinaciones y mil historias 00:11:40
solo con esta idea, a partir de esta idea 00:11:42
ahora mismo mi paint dibuja todo el rato 00:11:44
el mismo óvalo, todo el rato, vale 00:11:46
pero a ver, este panel 00:11:48
es el que tiene que estar en la interfaz, claro 00:11:49
es el que tiene que estar, entonces vamos a 00:11:52
fijar 00:11:54
al mi frame, que su panel por 00:11:56
defecto sea este 00:11:58
new 00:12:00
como se llama 00:12:06
la clase que hemos hecho, mi panel 00:12:09
vale, pues entonces, mi frame 00:12:10
su panel por defecto hemos puesto 00:12:20
que sea ese que hemos 00:12:22
hecho, vale 00:12:24
y este panel 00:12:25
pues lo que hace es dibujar esto de aquí 00:12:27
y a partir 00:12:29
de aquí pues podría 00:12:32
ya hacer cualquier cosa que quisiera 00:12:33
vale, vamos a probarlo 00:12:36
a ver si me ha escapado algo o vemos el OVA 00:12:37
no lo vemos porque así sobre la 00:12:39
marcha es muy probable que me haya escapado 00:12:41
algo 00:12:43
vale, pues no, pues ala, ahí está 00:12:44
el dibujillo 00:12:47
entonces con esta estructura 00:12:48
con esta es la idea, ya uno puede dibujar 00:12:51
y hacer cualquier chorrada 00:12:53
entonces, por ejemplo 00:12:55
yo os 00:12:56
propondría 00:13:01
que os entretengáis, primero haciendo 00:13:02
los ejercicios que tenéis que hacer 00:13:05
porque ese es nuestro examen 00:13:06
y luego ya 00:13:08
que os entretengáis haciendo esto, que se hace rapidísimo 00:13:09
Y podéis, por ejemplo, a ver, ¿dónde lo tenemos? Aquí, creo. 00:13:13
Por ejemplo, esto de aquí se hace en dos líneas, ¿vale? 00:13:28
Que le quiero cambiar, por ejemplo, la velocidad, pues le voy a poner este 3 y 3. 00:13:36
Ahora va más rápido 00:13:51
Que quiero ir 00:13:56
Que vaya a toda leche 00:14:00
¿Vale? 00:14:01
No, es imposible 00:14:10
Vale, pues entonces 00:14:12
Cuando acabéis los ejercicios 00:14:15
Tratad de hacer algo así con el graphics 00:14:19
Que más o menos 00:14:20
Para consolidar esta idea 00:14:21
Y ya está 00:14:24
¿Vale? 00:14:27
Entonces 00:14:29
Repito 00:14:30
Para dibujar el objeto que dibujas 00:14:31
un objeto de esta clase 00:14:35
este no se instancia en cualquier sitio de cualquier manera 00:14:36
este lo recibe 00:14:39
como parámetro este método 00:14:40
con lo cual yo tengo que dibujar dentro del paint 00:14:42
tengo que dibujar dentro del paint 00:14:45
y el paint donde está 00:14:47
el paint es un método 00:14:49
de los paneles o de los frames 00:14:51
entonces yo los puedo sobre escribir 00:14:52
también puedo sobre escribir 00:14:54
el paint de frame, de hecho aquí 00:14:56
si me hago un 00:14:58
dentro del frame 00:15:00
me hago esto 00:15:03
también aparece como sobrescrito 00:15:06
este está directamente en el frame 00:15:10
y en cuanto lo he escrito 00:15:12
me ha aparecido 00:15:16
efectivamente estoy sobrescribiendo el paint 00:15:20
de frame 00:15:22
lo que pasa es que lo normal es que uno trabaje 00:15:23
con paneles, meta componentes 00:15:26
a paneles, dibuje en paneles, etc 00:15:28
se trabaja con paneles 00:15:30
uno o muchos, los que uno quiera 00:15:31
no directamente en el frame, el frame suele ser un elemento 00:15:33
raíz para luego ya poner uno 00:15:36
varios paneles, lo que uno quiera 00:15:38
¿vale? 00:15:39
Vale, entonces, repito, el Paint se invoca automáticamente 00:15:43
cada vez que uno hace algo con la ventana 00:15:48
que obliga a que sea redibujada. 00:15:51
Pero uno lo puede invocar por código, 00:15:54
que es lo que yo he tenido que hacer aquí 00:15:57
para que la peloteja esta se moviera. 00:15:59
O sea, cada vez que la pelota se mueve 00:16:02
es porque se está llamando al Paint 00:16:05
y el Paint la dibuja en otro sitio, simplemente. 00:16:07
El Paint la dibuja en otro sitio. 00:16:10
Entonces, aquí el Paint se está llamando 00:16:12
no se está llamando porque la ventana 00:16:13
cambie, entonces ¿cómo puede uno llamar 00:16:16
al paint por código? también puede llamar al paint 00:16:18
por código, ¿por qué? porque 00:16:20
existe repaint 00:16:23
¿vale? entonces, por ejemplo 00:16:25
aquí 00:16:27
mi panel es que no le he puesto una referencia 00:16:28
entonces no puedo llamar a repaint, vamos a 00:16:35
darle una referencia 00:16:37
igual a esto 00:16:38
y ahora aquí pongo panel 00:16:45
¿veis? existe el método 00:16:53
Repaint por código 00:17:05
Que por código obligas a que se redibuje el panel 00:17:06
Entonces por ejemplo 00:17:09
Vamos a hacer eso que os he dicho 00:17:12
Rápidamente 00:17:14
Pues que el óvulo 00:17:14
En que estaría pensando yo 00:17:16
Que el óvalo encoja 00:17:17
Vamos a hacer una 00:17:19
Una variable 00:17:22
A ver 00:17:26
Vamos a pensar 00:17:27
Que hay que hacerlo de vez en cuando 00:17:30
Queremos 00:17:31
Que este método Paint 00:17:33
el tamaño 00:17:35
sea 60 o sea 00:17:36
120 en función del valor 00:17:39
de una variable 00:17:41
¿vale? una variable 00:17:42
sí, entonces 00:17:44
aquí esto en lugar de 60 00:17:46
en lugar de 60 00:17:49
esto va a ser una variable 00:17:50
el tamaño del óvalo va a ser un tamaño variable 00:17:53
¿vale? esa variable 00:17:55
¿cómo la recibo? 00:17:57
no puedo recibirla por parámetro 00:17:59
porque este método tiene que ser el sobrescrito 00:18:00
luego de la cabecera 00:18:03
no puedo tocar nada, de ese método no lo puedo 00:18:04
tocar, entonces 00:18:06
esta variable no la puedo recibir por parámetro 00:18:08
no queda más remedio que sea una variable de clase 00:18:10
¿vale? tienes una variable de clase 00:18:13
vale 00:18:15
ahora ya sí 00:18:16
entonces, esta variable de clase 00:18:17
esta variable de clase 00:18:20
la tengo yo que pasar 00:18:22
a... espera 00:18:27
no, es que 00:18:31
lo voy a complicar demasiado 00:18:32
tenemos una idea mejor 00:18:35
así, que es 00:18:41
como esta es una clase interna 00:18:43
como es una clase interna, tiene acceso 00:18:45
a todas las variables de la clase 00:18:48
en la que está, que para eso de hecho 00:18:50
tiene sentido que sea interna 00:18:52
entonces, esta variable 00:18:53
tamaño que esté aquí 00:18:55
¿vale? 00:18:57
esta variable tamaño está aquí, este es el tamaño del 00:18:59
del óvalo 00:19:02
del círculo, ese es el tamaño 00:19:03
¿vale? ese es el tamaño 00:19:05
entonces, cada vez que se llama el método paint 00:19:06
el tamaño será el que figura 00:19:10
en esta variable, eso está claro 00:19:12
cada vez que se haga 00:19:13
se llame a este método 00:19:15
el tamaño con el que se dibujará 00:19:17
será el que diga esa variable 00:19:19
el que diga 00:19:21
vale, pues entonces podemos meternos aquí en un bucle 00:19:22
infinito 00:19:25
en el que estamos 00:19:26
continuamente repintando 00:19:29
el panel 00:19:35
pero 00:19:36
cambiando el n 00:19:38
vale 00:19:40
Por ejemplo así 00:19:42
Podemos hacer un 00:19:44
Un contador 00:19:47
Que empieza siendo 0 00:19:53
Lo vamos incrementando aquí 00:19:55
Y ahora cuando sea par 00:19:58
N tiene un valor y cuando sea impar 00:20:04
Tiene otro, por ejemplo 00:20:06
Entonces N va a ser igual a 00:20:07
El resto de dividir 00:20:09
C entre 2 00:20:12
es igual a 0 00:20:14
pues entonces 00:20:16
n que es el tamaño 00:20:18
del círculo va a ser 00:20:21
50 y si no 00:20:22
va a ser 100 00:20:27
vale, entonces 00:20:29
n va cambiando 00:20:31
de valor 50, 100, 50, 100 00:20:33
50 y 100 en cada iteración del bucle 00:20:35
¿verdad? en cada iteración 00:20:37
entonces cada iteración del bucle 00:20:39
me dibuja el panel con un tamaño 00:20:41
del óvalo distinto 00:20:43
Este de aquí me dice 00:20:47
Como es wild true, no llegas nunca aquí 00:20:50
Etcétera, etcétera 00:20:52
Código inalcanzable, porque el wild true es normal 00:20:53
Que no le guste, etcétera 00:20:56
Entonces vamos a poner 00:20:58
El wild true 00:20:59
Aquí debajo 00:21:05
Vamos a hacer una cosa 00:21:07
Vamos a probarlo y ya paramos, vale 00:21:11
Que no quiero ponerlo después del set visible 00:21:22
Entonces vamos a ponerlo 00:21:27
Vamos a dejarlo donde estaba 00:21:29
Y esto 00:21:32
Lo voy a sacar 00:21:33
Aquí 00:21:38
Y aquí pongo 00:21:41
Y V 00:21:57
Vale, y esto lo quito 00:21:59
Vale, entonces 00:22:03
¿Qué ocurre? 00:22:09
Que si, como esto es instantáneo 00:22:10
El repaint se está haciendo 00:22:13
Cada nanosegundos 00:22:15
Yo no me va a dar tiempo a ver 00:22:16
Lo del, de hecho vamos a probarlo 00:22:18
No vamos a ver nada 00:22:20
Claro, es que tengo el set visible después 00:22:21
Es que claro, el while true es muy mala idea 00:22:28
El while true es muy mala idea 00:22:29
Vamos a dejarlo como estaba 00:22:31
Así 00:22:40
Y vamos a poner 00:22:41
Mientras c 00:22:44
Sea menor 00:22:46
Que 00:22:48
Diez mil 00:22:50
Vale 00:22:53
Entonces 00:22:54
Así es que no nos da tiempo a ver nada 00:22:57
no podemos ver nada 00:23:02
entonces vamos a hacer que pare 00:23:04
la ejecución un segundo 00:23:06
que pare la ejecución un segundo 00:23:08
cambie esto, la pare un segundo 00:23:10
y haga el repaint 00:23:12
incremente c 00:23:13
vuelvo a poner n 00:23:15
la pare otro segundo y haga el repaint 00:23:17
entonces como se para un programa 00:23:19
como se detiene una ejecución un ratito 00:23:22
pues simplemente haciendo esto 00:23:23
con esta sentencia 00:23:26
que es el método 00:23:32
estático sleep de esta clase 00:23:34
se queda parado el programa detenido 00:23:36
es como una pausa, es como hacer un pause 00:23:39
como cuando uno hace un system pause 00:23:40
¿cuántos milisegundos? 00:23:42
los milisegundos que uno le diga aquí 00:23:45
¿vale? 00:23:46
entonces en este caso un segundo 00:23:48
¿qué ocurre? que este método 00:23:50
lanza una excepción de las que 00:23:52
estamos obligados a capturar 00:23:55
o a propagar 00:23:57
porque es de tipo exception, es un time exception 00:23:58
entonces me obliga, pues venga 00:24:00
captúrala y ya está 00:24:03
A la capturada 00:24:05
Vale, entonces ahora 00:24:06
Vale, vamos a 00:24:11
A ver, es que 00:24:21
Claro, no lo veo, tengo el set visible después 00:24:27
Vale, es que estoy metiéndome 00:24:34
Unos berenjenales yo sola 00:24:36
Para enseñaros esto 00:24:37
Vale, vamos a parar aquí 00:24:39
Vale, he dado pausa 00:24:40
Vale, vamos a ver 00:24:46
Donde estábamos 00:24:48
vale, pues el bucle 00:24:49
que muestra, que dibuja 00:24:56
que hace el dibujito 00:24:58
el bucle que repinta cada vez 00:24:59
con un tamaño de 00:25:02
circulito distinto, este de aquí 00:25:03
lo he puesto 00:25:06
después del set visible para que se vea 00:25:08
por ejemplo lo tenía puesto antes, por eso no lo veía 00:25:10
lo he puesto después y se acabó 00:25:12
entonces ahora efectivamente 00:25:13
si uno ejecuta esto 00:25:16
pues lo que sale 00:25:17
me hace el primer dibujo, el segundo 00:25:22
vuelvo a hacer el primero, pero ya no lo veo 00:25:24
porque está encima 00:25:26
me hace el primero, pasa un segundo 00:25:27
me hace el otro, pasa un segundo 00:25:31
me hace el grande de nuevo, pero claro, ya no lo veo 00:25:32
porque está el otro 00:25:34
pero sí que me está haciendo el pain 00:25:37
aunque yo ahí no lo vea 00:25:39
lo podría estar viendo si 00:25:40
este n 00:25:43
en lugar de ir variando entre 50 y 100 00:25:45
fuera creciendo, por ejemplo 00:25:47
pero así veo el primero 00:25:48
veo el segundo, el tercero ya no lo veo 00:25:50
porque está encima del primero, etc. 00:25:53
Entonces, ¿qué es lo que nos faltaría? 00:25:54
Claro, este método sobrescrito de aquí 00:25:57
Este método paint de aquí sobrescrito 00:25:59
Dibuja sobre lo que ya había de antes en el panel 00:26:03
Dibuja sobre lo que ya había 00:26:08
Si yo no quiero que dibuje sobre lo que ya había 00:26:10
Sino que dibuje de limpias y de cero 00:26:12
Tengo que volver a llamar 00:26:14
Tengo que llamar al paint del JPanel 00:26:18
super es el objeto 00:26:23
del queredo, la clase de la queredo 00:26:27
tengo que llamar al paint del jPanel 00:26:29
y entonces como me reinicia 00:26:31
el panel de cero 00:26:33
me lo limpia, entonces ahora ya si 00:26:33
si ya lo ejecuto 00:26:37
ahora ya cada segundo que pasa 00:26:38
hace el paint 00:26:41
pero ya sobre un panel limpio 00:26:42
vale 00:26:47
bueno pues ya con este objeto, con todos los métodos 00:26:47
que tiene y 00:26:53
combinando simplemente esto 00:26:55
que para la ejecución 00:26:57
El tiempo que uno quiera 00:26:58
Podéis hacer cualquier cosa 00:27:00
En realidad 00:27:01
¿Vale? 00:27:02
Con esta estructura de aquí 00:27:03
Relacionada con dibujo 00:27:04
Si uno quiere dibujar 00:27:07
O hacer cualquier chorrada 00:27:08
¿Vale? 00:27:09
Venga 00:27:11
Y ahora ya se 00:27:12
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
11
Fecha:
11 de mayo de 2024 - 0:16
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′ 12″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
113.44 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid