Saltar navegación

20250121 HerenciaEjemplos_3 - Contenido educativo

Ajuste de pantalla

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

Subido el 21 de enero de 2025 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos a ver, vamos a completar por tanto este ejercicio que va a ser repasar lo mismo de siempre, 00:00:00
para arrancar ya con este que nos permitirá introducir clases abstractas. 00:00:08
Y ya acabaríamos con herencia, pero nos seguiría pidiendo el cuerpo algo más 00:00:13
porque se nos quedaría corto, que serán las interfaces. 00:00:17
Vale, pues entonces, ahora tenemos ya empleado, gerente y departamento. 00:00:20
y ahora vamos a ampliar la 00:00:26
aplicación 00:00:28
para que pueda haber varios departamentos 00:00:30
si hay varios departamentos 00:00:33
entonces aparece ya de forma natural el concepto 00:00:35
de una empresa que los engloba 00:00:37
y es la clase que habéis hecho 00:00:39
bueno pues la clase 00:00:41
que habéis hecho es 00:00:43
esta que tiene 00:00:45
la propiedad nombre 00:00:46
¿verdad? 00:00:48
y la propiedad 00:00:51
a raíz de departamentos 00:00:52
A ver, no 00:00:54
Aquí no tendría sentido que fuera static 00:01:02
Lo que sí que tendría sentido 00:01:05
Es que luego 00:01:10
Que tú en un main 00:01:11
Cuando ya vas a trabajar con una empresa 00:01:14
Y declaras ya tu empresa 00:01:16
Pues que a lo mejor hicieras esto 00:01:18
Por ejemplo, esto sí 00:01:20
Porque entonces tú me puedes decir 00:01:28
oye, mi aplicación va a trabajar 00:01:30
solo con una empresa 00:01:33
entonces si solo va a trabajar 00:01:34
con una empresa 00:01:37
pues en todo caso 00:01:38
esta variable 00:01:40
podrías hacerla estática 00:01:42
porque solo vas a trabajar con una empresa 00:01:44
pero la propiedad 00:01:46
nombre de empresa 00:01:49
no tiene sentido que sea estática 00:01:51
porque 00:01:52
si hay varias empresas 00:01:54
cada una tendrá su nombre 00:01:56
si yo le pongo a este el modificador 00:01:58
static, el mensaje 00:02:00
que estoy transmitiendo es 00:02:02
todas las empresas del universo se van 00:02:04
a llamar igual 00:02:06
ese mensaje es cierto, es falso 00:02:07
todas las 00:02:11
empresas del universo es imposible que se llamen igual 00:02:12
no tiene ningún sentido 00:02:14
pues es el mensaje que transmito cuando pongo aquí un static 00:02:15
con lo cual ese static ahí no tiene 00:02:18
sentido, entonces quiero 00:02:20
que os vaya 00:02:22
llegando cada vez más que lo más 00:02:24
importante del desarrollo 00:02:26
es hacer buenos diseños 00:02:28
en realidad, no que 00:02:30
aprendáis de carrerilla cosas relacionadas 00:02:32
con la sintaxis, si pongo un 00:02:34
static lo puedo llamar con el nombre de la clase 00:02:36
si pongo no sé qué, cuestiones 00:02:38
prácticas de sintaxis 00:02:40
hay que conocerlas, por supuesto 00:02:42
pero solo con esas no programamos 00:02:44
y hacemos nada 00:02:46
con esas podemos 00:02:47
escribir código 00:02:50
sintácticamente 00:02:52
correcto, pero no tendría ningún 00:02:54
sentido, ¿vale? tú tienes un montón de palabras 00:02:56
las tiras 00:02:58
al azar y las unes siguiendo las reglas 00:03:00
de la sintaxis y te puedes 00:03:02
salir un texto que no 00:03:04
tiene ningún significado 00:03:06
la mesa comió patatas fritas 00:03:07
y me voy a pasear mañana 00:03:10
no te sirve para nada ese texto 00:03:11
y es un texto 00:03:14
perfectamente válido 00:03:16
si te sirve escribir el Quijote, por ejemplo 00:03:17
¿vale? pues entonces 00:03:20
tú pones aquí static 00:03:22
¿vale? 00:03:24
muy bien, como solo vas a tener una empresa 00:03:26
te da igual que esa empresa 00:03:28
el nombre que tenga de repente 00:03:30
se haya convertido en el nombre para todas 00:03:32
las del universo, como solo tienes una 00:03:34
te da igual, pero eso no tiene ningún sentido 00:03:36
no tiene ningún sentido 00:03:38
luego, si quito el static 00:03:39
significa, si yo tengo varios 00:03:44
objetos empresa en mi aplicación 00:03:46
puede que los tenga, puede que no 00:03:48
pero si tengo varios objetos empresa 00:03:50
cada uno tendrá su propio 00:03:52
nombre y eso si tiene sentido 00:03:54
¿vale? bueno pues 00:03:55
la clase empresa que habréis hecho 00:03:58
tendrá su propiedad nombre 00:04:00
y su conjunto de departamentos 00:04:01
como cualquier 00:04:03
bin que es, recordad que 00:04:06
estos son los que se llaman los objetos bin en general 00:04:08
para que no se os vayan olvidando terminologías 00:04:10
pero luego se os van olvidando cosas 00:04:13
uy, split, eso no lo hemos mencionado nunca 00:04:16
claro que lo hemos mencionado 00:04:17
bueno, pues 00:04:19
vale, esta clase como buena clase 00:04:20
de entidad que representa entidad 00:04:24
que se le suele llamar bin 00:04:25
en terminología de desarrollo 00:04:27
¿vale? pues tendrá 00:04:29
sus constructores, sus getter y sus setter 00:04:31
vale 00:04:34
aquí he hecho un constructor solo con 00:04:35
el nombre porque es muy útil 00:04:37
en clases, entidades 00:04:40
que tienen propiedades 00:04:42
que son a raíz 00:04:44
que haya constructores 00:04:45
para inicializar solo las que no son a raíz 00:04:47
porque luego ya 00:04:50
los elementos de la raíz ya se irán metiendo 00:04:51
luego después en métodos ¿vale? ya se irán 00:04:53
transmitiendo después, vale, pues entonces he hecho un constructor 00:04:55
que recibe el nombre, inicializa nombre y ya está 00:04:58
departamento ya se iniciará, se inicia el solo con un array vacío 00:05:01
y luego he hecho los get y los set 00:05:06
y tengo mi objeto empresa 00:05:08
vale, me dice algo más aquí de la clase empresa 00:05:12
me dice, oye, a esa clase empresa, añádele un método 00:05:16
que calcule el salario de la empresa 00:05:21
vale, entonces ese método 00:05:24
calcular el salario total de la empresa 00:05:27
como es un método que afecta 00:05:29
a una empresa, lo metemos en esta clase 00:05:31
que es donde tiene que ir 00:05:33
y por ejemplo lo podemos colocar aquí abajo 00:05:34
le damos un nombrecito 00:05:37
decidimos que va a devolver 00:05:39
como va a calcular un sueldo 00:05:42
total, pues devuelve un double 00:05:43
y ahora ya nos ponemos a programarlo 00:05:45
como hemos programado hace 3 meses 00:05:48
vale 00:05:50
el sueldo total de la empresa, ¿cuál va a ser? 00:05:51
el sueldo de todos 00:05:54
sus departamentos. 00:05:56
¿Vale? Yo es que lo que pasa es que 00:05:59
tengo que subir y bajar, pero intentaré hacerlo despacito. 00:06:00
No, a ver, 00:06:04
todavía no copiéis nada porque estamos pensando. 00:06:05
De hecho, esto... No, no, esto está borrado. 00:06:07
Esto no existe. 00:06:09
Lo he borrado. ¿Vale? 00:06:10
Lo siento, ya no hay nada. Vale, entonces, 00:06:13
vamos a hacer este método. Repito, 00:06:16
esta es programación de hace dos meses. 00:06:17
¿Vale? El sueldo 00:06:20
total, ¿cuál va a ser? Una suma de sueldos. 00:06:21
Luego va a ser una suma 00:06:24
acumulativa, estupendo, una suma 00:06:25
acumulativa, pues mi variable acumuladora 00:06:27
que empieza a cero 00:06:29
vale, los integrantes 00:06:31
de la suma, ¿de dónde me van a salir? 00:06:33
¿es el sueldo 00:06:36
o que pagan los departamentos de la 00:06:37
empresa? bueno, los departamentos 00:06:39
de la empresa están aquí en esta variable, están 00:06:41
aquí, pues tendré que ir 00:06:43
departamento por departamento 00:06:45
y cogiendo de cada departamento 00:06:47
el sueldo que paga ese departamento 00:06:49
para sumarlo 00:06:51
vale, pues entonces 00:06:52
el bucle mío, para ir obteniendo 00:06:54
los sumandos del sueldo 00:06:56
total, el bucle mío tendrá 00:06:58
que iterar por aquí 00:07:00
venga, pues mi bucle tendrá que iterar 00:07:01
por aquí, como vamos 00:07:05
a consultar solo, pues podemos hacer un 00:07:06
for each que es más rápido 00:07:08
departamento de 00:07:09
en departamentos 00:07:11
ahora, ¿qué hacemos 00:07:14
con cada uno de los departamentos? 00:07:16
pues tendríamos que sumarle 00:07:19
a mi variable acumuladora suma 00:07:20
tendríamos que sumarle 00:07:22
el sueldo que paga este 00:07:24
departamento, para así incluir todos 00:07:26
vale, el sueldo 00:07:28
que paga este departamento 00:07:30
a su vez es el sueldo 00:07:32
de cada empleado 00:07:34
porque departamento 00:07:35
que tiene, tiene un montón de empleados 00:07:39
y cada 00:07:41
empleado, este ya 00:07:42
sí que tendrá cada uno 00:07:44
su salario 00:07:45
pero claro 00:07:48
no nos hace falta meternos 00:07:50
en cada departamento y a su vez 00:07:52
ir sumando el sueldo de cada empleado 00:07:54
porque en la clase 00:07:56
departamento ya hemos hecho un 00:07:58
método 00:08:00
¿vale? si yo me voy a la clase departamento 00:08:00
efectivamente tenemos un método aquí 00:08:04
que me va sumando el sueldo de todos 00:08:06
los empleados, que fue el que hicimos el otro día 00:08:10
entonces este método 00:08:12
si lo llama un objeto 00:08:14
departamento, que es donde 00:08:16
está declarado el método, ¿vale? 00:08:18
Está declarado en la clase departamento. 00:08:19
Pues si a este método lo llamo un objeto departamento, 00:08:22
irá empleado por empleado, tal y como hicimos el otro día, 00:08:25
y me va a construir el sueldo total de todos los empleados 00:08:29
y me lo va a devolver. 00:08:31
Luego me puedo aprovechar de este método 00:08:33
que está en la clase departamento 00:08:35
y llamarlo desde aquí e incorporarlo. 00:08:37
La variable no se llama departamento, 00:08:44
sino de dos, se llama así, ¿vale? 00:08:46
pues ya está, ya tengo la suma hecha 00:08:50
voy sumando sobre la variable suma 00:08:52
todos y cada uno de los sueldos 00:08:54
de todos y cada uno de los departamentos 00:08:56
que forman parte de la empresa 00:08:58
y la devuelvo 00:09:00
ala, pues este método ya está 00:09:03
el método que nos calcula 00:09:07
todo el sueldo que paga la empresa 00:09:09
a todos los empleados 00:09:11
de todos sus departamentos 00:09:13
entonces siempre nos apoyamos 00:09:15
para hacer unos métodos 00:09:18
en los métodos de otras clases 00:09:20
claro, no podemos reprogramarlo 00:09:22
todo una y otra vez 00:09:24
bueno 00:09:25
claro 00:09:27
ahora lo que tendríamos que haber hecho 00:09:30
si no tuviéramos ese método y pasáramos del método 00:09:32
pues tendríamos que haber hecho aquí un foran y dado 00:09:34
en el que hubiéramos ido 00:09:36
departamento, perdón 00:09:38
empleado por empleado 00:09:39
de cada departamento de 00:09:41
de cada 00:09:45
perdón, de cada conjunto de empleados 00:09:47
y ahora aquí 00:09:49
ir sumándole 00:09:51
a este 00:09:52
pues el salario 00:09:57
de este empleado 00:10:00
y eso sin distinguir si es 00:10:00
gerente o no, es decir 00:10:03
me tendría que haber metido en 00:10:05
el array de empleados de cada departamento 00:10:07
de, y para cada 00:10:10
empleado ir uno por uno a la suma 00:10:11
pero no me hace falta 00:10:13
hacer esto, porque ya tengo aquí 00:10:15
un método que ya se 00:10:17
mete él en el array de empleados del 00:10:19
departamento de 00:10:21
y me obtiene 00:10:22
la suma total, pues yo esa suma 00:10:24
total de todos los sueldos 00:10:26
de todos los empleados que están dentro de D 00:10:28
se la sumo a esta variable 00:10:30
y así voy sumando para cada departamento 00:10:32
bla bla bla, cuando este for termina 00:10:35
ya lo tengo 00:10:36
luego todo esto de aquí no nos hace falta 00:10:37
vale, entonces siempre nos tenemos que apoyar 00:10:40
en los métodos 00:10:45
que ya están hechos en las clases 00:10:47
si no, nos harán cosas 00:10:49
inmanejables 00:10:51
vale, bueno pues ahora ya simplemente 00:10:52
dice aquí que hagamos un main 00:10:56
pues vamos a hacer 00:10:57
vamos a completar el main y ya está 00:11:00
ah bueno no, tenemos que hacer 00:11:01
la empleado temporal, vale 00:11:04
ahora nuestra aplicación se ha 00:11:05
ampliado y nos han 00:11:08
dicho, oye además de gestión de empleados 00:11:10
normales y gerentes 00:11:11
necesito que gestiones empleados temporales 00:11:13
de los que tienen solamente 00:11:16
de los que tienen una fecha de fin 00:11:18
entonces la fecha de fin 00:11:19
de contrato no la puedo incluir 00:11:21
ni en empleado ni en gerente 00:11:23
porque ellos no tienen fecha de fin 00:11:25
solo tienen los empleados temporales 00:11:27
entonces me aparece automáticamente otra entidad 00:11:28
para trabajar con estos 00:11:31
empleados temporales 00:11:33
pues entonces tenemos que crear 00:11:36
esa clase adicional 00:11:37
pues no pasa nada 00:11:38
la creamos 00:11:39
nos vamos a nuestro paquete otra vez 00:11:41
new 00:11:44
y hacemos nuestra clase 00:11:44
empleado 00:11:48
temporal 00:11:49
y aquí es donde 00:11:50
al integrar, al agregar una nueva 00:11:54
entidad, miramos a ver 00:11:57
si tiene sentido que se meta en nuestra 00:11:59
jerarquía de herencia 00:12:01
porque si se puede meter 00:12:02
en nuestra jerarquía, nos va 00:12:05
a facilitar la reutilización de código que ya 00:12:07
tengamos hecho y muchas cosas 00:12:09
entonces nos hacemos preguntas 00:12:10
¿un empleado temporal es un departamento? 00:12:12
pues no, no tiene sentido que le dé departamento 00:12:15
¿un empleado temporal es una 00:12:17
empresa? no 00:12:19
un empleado temporal 00:12:20
es un empleado 00:12:22
ah sí, un empleado temporal 00:12:25
es un empleado, lo que pasa es que añade 00:12:26
además la fecha de fin 00:12:28
pues entonces yo ahora 00:12:30
digo, ojo 00:12:32
lo meto en la jerarquía 00:12:33
empleado temporal, estens 00:12:36
empleado 00:12:38
con lo cual un empleado temporal 00:12:40
automáticamente, sin que nosotros lo hagamos 00:12:42
tiene ya 00:12:45
su nombre, su salario 00:12:46
y su fecha de contratación 00:12:48
pero el temporal además de esto 00:12:49
que hereda de empleado 00:12:53
además de esto añade una fecha de 00:12:55
fin de contrato 00:12:57
añade una fecha de fin 00:12:58
pues vamos a ponerle esa única 00:13:00
propiedad que añade 00:13:02
que es 00:13:04
la fecha de fin 00:13:06
como es una fecha, un objeto date 00:13:11
pues venga 00:13:14
la propia java útil nos vale 00:13:15
entonces 00:13:17
los get y los set de las propiedades 00:13:20
anteriores están heredadas, 00:13:22
los constructores nos heredan, 00:13:24
luego vamos a hacer uno específico 00:13:26
como hacíamos los constructores 00:13:28
ahora ya, con los super. 00:13:30
Pues nos vamos a hacer un constructor 00:13:32
empleado 00:13:34
temporal. 00:13:40
Y este constructor 00:13:43
va a recibir los cuatro 00:13:44
parámetros que tiene empleado. 00:13:46
Empleado temporal, aunque yo no los vea 00:13:48
con mis ojos, empleado temporal 00:13:50
tiene cuatro propiedades. Tiene estas tres, 00:13:52
Nombre, salario, fecha de contratación 00:13:54
Y fecha de fin, tiene cuatro 00:13:56
Aunque yo no las vea, pues entonces hay que pasarle las cuatro 00:13:58
Que son el nombre 00:14:00
Del empleado 00:14:04
Era nombre o era 00:14:06
Si era nombre 00:14:10
El salario o sueldo 00:14:11
La fecha 00:14:14
De contrato, ¿no? 00:14:16
Y la fecha de fin 00:14:19
¿Vale? 00:14:22
Porque esas son 00:14:26
las cuatro propiedades que tiene empleado temporal 00:14:27
luego vamos a inicializarlo 00:14:30
vale, entonces yo ahora podría ir una por una 00:14:32
dis.nombre igual a nombre 00:14:34
dis.salario igual a salario 00:14:36
podría, ¿verdad? hacer esto 00:14:37
dis. 00:14:40
ah, no, tendría que hacer como está heredada 00:14:46
pero 00:14:48
recordad que los 00:14:49
constructores de clases heredadas 00:14:52
se suelen 00:14:55
hacer llamando 00:14:57
al constructor de la superclase 00:14:58
Es decir, ¿cuál es la superclase de empleado temporal? 00:15:00
Empleado. 00:15:03
Empleado tiene ya un constructor al que si yo le paso las tres primeras cosas, 00:15:05
que es este, ya me hace esta inicialización. 00:15:09
Si yo le paso las tres primeras cosas. 00:15:12
Vale, pues entonces vamos a llamar al constructor de arriba, 00:15:15
pasándole las tres primeras propiedades 00:15:19
y luego ya inicializamos la que nos falta. 00:15:21
¿Vale? Que es lo que vimos el otro día. 00:15:23
¿Cómo se llama el constructor de arriba? 00:15:27
así 00:15:28
constructor de arriba 00:15:30
que te paso 00:15:32
estas tres cositas primeras 00:15:33
que me han pasado a mi 00:15:35
a mi me han pasado estos tres parámetros 00:15:38
me han pasado 00:15:40
estos tres parámetros 00:15:44
me los han pasado 00:15:45
aquí, nombre, salario, fecha 00:15:48
de contrato, pues estos tres parámetros 00:15:50
te los paso yo a ti 00:15:52
constructor de arriba, te paso estos tres parámetros 00:15:54
a ti y ahora ya 00:15:56
el constructor de arriba los coge 00:15:58
y los usa para 00:16:00
inicializar estas propiedades 00:16:02
vale, lo que pasa es que 00:16:03
nos ha quedado una propiedad sin inicializar 00:16:10
que es esta, porque esta el constructor de arriba 00:16:12
no sabe ni que existe lógicamente y no la puede 00:16:14
ni recibir siquiera, el constructor 00:16:16
de arriba recibe solo tres propiedades 00:16:18
bueno pues este 00:16:20
último parámetro de aquí 00:16:21
ese ya si que vamos a usarlo 00:16:24
para 00:16:26
inicializar la propiedad 00:16:29
que nos falta 00:16:34
ya tenemos un constructor 00:16:34
con parámetros 00:16:40
lo normal es hacer uno sin parámetros 00:16:42
get y set 00:16:44
dejamos el constructor sin parámetros 00:16:45
vamos a añadir el get y set de lo que nos falta 00:16:48
nos falta 00:16:50
el get y set de fecha fin 00:16:53
porque los get y set de las otras tres propiedades 00:16:54
ya los hemos heredado 00:16:59
bueno pues empleado temporal 00:17:00
ya está, heredaría de empleado y se acabó 00:17:03
dime 00:17:05
si pones fecha contratación 00:17:06
¿dónde? no entiendo 00:17:11
en el súper 00:17:12
si pones fecha contratación 00:17:13
no me da error, pero si lo pongo me da error 00:17:14
pues será que no tienes un constructor 00:17:17
arriba que reciba los tres parámetros 00:17:19
será que no es del mismo tipo 00:17:23
a ver 00:17:25
tú tienes que entender lo que estás haciendo, estás llamando al constructor 00:17:27
de arriba, si lo estás llamando 00:17:29
pasándole los tres parámetros que el constructor 00:17:31
de arriba necesita, no te tienes por qué dar ningún error 00:17:33
o que sea de otro tipo 00:17:35
claro, con lo cual su constructor no tiene esto 00:17:38
entonces si tu constructor no tiene esto 00:17:55
pues es normal que 00:17:58
no lo puedas llamar con eso 00:17:59
Vale 00:18:01
Bueno, pues empleado temporal 00:18:04
Ya se ha metido en la jerarquía y es esto 00:18:06
Entonces 00:18:08
El haberlo metido 00:18:10
En la jerarquía 00:18:12
Haciendo un extends 00:18:13
Le facilita a la aplicación las cosas 00:18:15
Facilita el haber incorporado esto 00:18:18
Porque imaginaos que la aplicación 00:18:20
Ya estaba funcionando como antes 00:18:23
Con sus empleados, gerentes 00:18:24
El main de agregar empleado 00:18:26
Y nos dicen, oye, agrega ahora 00:18:27
la posibilidad de que haya empleados temporales 00:18:30
pues nosotros nos olvidamos 00:18:31
de la herencia y hacemos 00:18:34
la clase empleado temporal 00:18:36
la hacemos poniendo aquí todas las propiedades 00:18:38
su nombre, su no sé qué 00:18:40
con lo cual este extens no haría 00:18:42
ninguna falta, porque hemos puesto ahí todo 00:18:44
olvidándonos de la herencia 00:18:46
pues ya está, empleado temporal está perfecta 00:18:47
pero que ocurre 00:18:50
que ahora departamento la hemos liado 00:18:51
porque el departamento 00:18:54
ahora no podría tener 00:18:56
empleados temporales 00:18:58
no podría, porque el departamento 00:18:59
tiene que tener 00:19:02
en su array de empleados 00:19:03
todo lo que quepa en la caja 00:19:05
empleado, y en la caja 00:19:07
empleado cabe gerente porque 00:19:09
hereda de empleado, pero 00:19:11
no cabe algo que no herede de empleado 00:19:13
entonces si yo quisiera 00:19:15
ampliar mi aplicación para que los 00:19:17
departamentos incorporaran empleados 00:19:19
temporales también, que para eso he hecho la 00:19:21
entidad, tendría que hacerme aquí 00:19:23
otro array de, oye 00:19:25
tus empleados temporales cuáles son 00:19:27
y esto es una caca 00:19:29
porque he tenido que retocar esta clase 00:19:37
tendría que retocar 00:19:40
el método sueldo total 00:19:42
porque en el sueldo total tendría que recorrer ahora 00:19:43
este array, el array de aquí 00:19:46
o sea, tendría que hacer un montón 00:19:48
de retocamientos 00:19:50
en todas las clases 00:19:52
para incluir en mi aplicación 00:19:53
el que haya aparecido un empleado 00:19:56
temporal, tendría que 00:19:58
retocar en mil sitios 00:19:59
pero si yo diseño bien 00:20:01
y identifico 00:20:03
ojo, que empleado temporal 00:20:05
es también un empleado 00:20:08
pues si lo 00:20:09
identifico, me hago mi stents 00:20:11
y al hacerme mi stents 00:20:13
en el propio 00:20:15
array de empleados del departamento 00:20:17
en este ya van a caber empleados 00:20:19
temporales también 00:20:21
y no tengo que retocar nada de la clase departamento 00:20:22
nada 00:20:26
porque en este mismo array nos van a caer también 00:20:26
los temporales si nos da la gana 00:20:29
porque heredan de empleado 00:20:31
si no lo hubiéramos hecho 00:20:32
metiéndolo en la jerarquía 00:20:35
y haciéndolo otra vez todo nuevo empleado temporal 00:20:37
nos hemos cargado 00:20:40
de apartamento y tenemos que rehacerlo 00:20:41
metiendo también un array 00:20:44
para empleados temporales, etc. 00:20:45
¿vale? 00:20:48
perdón 00:20:51
ya está aquí 00:20:51
¿está bien? 00:20:54
sí 00:20:56
vale, ¿os habéis enterado? 00:20:57
Vale, ¿necesitáis parar un momentín? 00:21:01
Venga, pues paramos 00:21:06
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
21 de enero de 2025 - 17:40
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
21′ 07″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
97.81 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid