Saltar navegación

20241114 ProgrEstruct-Funciones_ejer_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 17 de noviembre de 2024 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues venga, el ejercicio es hacer una función 00:00:00
Luego esa función si queremos probar si funciona 00:00:05
Pues tendremos ya que desde un main llamarla, claro 00:00:07
Pero el ejercicio es hacer la función 00:00:09
Venga, pues la función necesitamos 00:00:12
Parámetros que recibe en caso de que reciba alguno 00:00:15
Tipo de dato que retorna si es que retorna alguno 00:00:19
Y luego ya lo que hace 00:00:23
Vale, pues a esta función le vamos a pasar dos números enteros 00:00:25
y que hace, muestra por consola 00:00:28
cosas, entonces como muestra por consola 00:00:31
cosas, no devuelve nada en realidad 00:00:33
porque el objetivo de la función 00:00:35
es ya mostrar directamente por consola 00:00:37
no devuelve, entonces tipo de retorno 00:00:39
void, porque no devuelve nada 00:00:41
parámetros, dos 00:00:43
números enteros 00:00:45
nombre, pues elegimos un nombre 00:00:47
pues mostrar 00:00:49
números, cualquier cosa 00:00:51
pues venga, entonces la función 00:00:52
sabemos que tenemos que ponerle 00:00:55
un static delante, sí o sí. 00:00:57
Por ahora 00:01:01
tenemos que poner un static delante, sí o sí. 00:01:01
Aunque no entendamos por qué. 00:01:04
Valor que va a devolver 00:01:06
la función. Ya hemos dicho, no me 00:01:07
devuelve nada. No es que sea una función que 00:01:09
diga, devuélveme la suma de todos los 00:01:11
números comprendidos entre dos que yo te dé 00:01:13
o devuélveme no sé qué. 00:01:15
Yo estoy poniendo public static porque así la puedo 00:01:17
llamar desde otros. Ah, bueno, sí. 00:01:19
¿Vale? Como nosotros hasta ahora lo estamos llamando solamente 00:01:22
desde el main, pero si quisieras llamarlo desde otro 00:01:23
de fuera del paquete. No entendía muy bien 00:01:25
Sí, eso ya lo veremos 00:01:27
cuando veamos. Necesitas que sea público para llamarla 00:01:30
desde fuera del paquete. 00:01:32
Desde el mismo paquete no. 00:01:34
Desde una clase distinta en el mismo paquete no. 00:01:36
Claro, entonces sí. 00:01:40
Tiene que ser público. 00:01:41
Y tener el public delante. 00:01:43
No vale con que sea public aquí si no hay public ahí arriba. 00:01:44
Vale. Pero bueno, eso ya explicaremos 00:01:47
por qué y a qué se debe. 00:01:48
Vale. Entonces, 00:01:51
hemos dicho que no va a devolver nada porque va a mostrar 00:01:52
por consola. Pues ya nos adelantamos 00:01:54
y void, venga vamos a llamarla 00:01:57
mostrar secuencia porque va a mostrar la secuencia 00:02:00
entre dos extremos 00:02:03
y ahora que recibe 00:02:04
los dos extremos de la secuencia 00:02:06
que va a mostrar 00:02:08
pues venga 00:02:09
el numerito 1 y el 00:02:12
numerito 2 00:02:14
la lista de parámetros de la función 00:02:15
puede ser tan larga como a uno le 00:02:18
de la gana o como uno necesite 00:02:20
siempre y cuando estén todos 00:02:22
separados por comas 00:02:24
vale 00:02:25
hay otra manera de expresar la lista 00:02:27
de parámetros que se incorporó a partir de cierta 00:02:30
versión de Java, por si la veis 00:02:32
alguna vez, con tres puntos, pero bueno 00:02:34
esa no la mencionamos porque 00:02:36
liamos y tampoco se usa tanto 00:02:38
entonces ahora ya podemos hacer el código 00:02:40
el código que va a hacer, mostrar todos 00:02:46
los números entre N1 y N2 00:02:48
bueno, pues esto 00:02:50
ya directamente que plantaríais aquí 00:02:52
un bucle for 00:02:54
un bucle for donde aprovechamos la variable índice 00:02:58
para que esa variable índice arranque desde n1 y acabe en n2 00:03:01
y uso esa variable índice para mostrar 00:03:06
y ya está, perdón, 0 no, n1 00:03:08
entonces jugamos con los límites del for 00:03:16
en la medida en la que nos interesa 00:03:25
aquí nos interesa decir, oye, el primero es l1 00:03:27
voy incrementando de 1 en 1 y el segundo es n2 00:03:30
pues ya está, juego con esos límites para hacer lo que sea 00:03:33
En este caso, lo que queremos hacer es 00:03:36
Mostrarlo sin más 00:03:39
Pues ya está 00:03:41
Ya, ya, ya 00:03:42
Bueno, sí, pero vamos 00:03:49
¿Vale? 00:03:50
Entonces esto es lo que se nos podría ocurrir 00:03:52
Pues ya está, un for, jugamos con el índice 00:03:54
Ya está, empieza valiendo en e1 00:03:57
Se va incrementando 00:03:58
Y mientras no haya llegado en e2, lo mostramos 00:03:59
Y ya está 00:04:02
Y nada más 00:04:04
entonces 00:04:05
te lo quería preguntar, porque no lo he probado 00:04:07
si cambio una variable dentro de ese 00:04:09
pero como no retorno nada, la variable 00:04:11
original no se toca, ¿no? 00:04:12
no, no, no, no, no 00:04:14
no, no, no, ahora vamos a hacer el ejemplo 00:04:16
claro, por ejemplo 00:04:19
vale, bueno, antes de hacer 00:04:20
ese ejemplo, ¿esto está claro? 00:04:23
está claro, ¿no? entonces ahora llevamos a la función 00:04:25
a la función, ¿cómo la llamaríamos? 00:04:27
pues con su nombre, como siempre 00:04:29
pero ahora hay que pasarle unos valores 00:04:31
concretos 00:04:33
¿vale? pues por ejemplo 00:04:33
si le pasamos el 6 y le pasamos el 12 00:04:36
pues está claro que esta 00:04:38
función va a 00:04:40
mostrar todos los 00:04:42
números entre 6 y 12 00:04:44
¿vale? y podría hacer 00:04:45
más cosas, podría pues en lugar de mostrar 00:04:48
los números, pues a lo mejor hacer 00:04:50
la suma, pues nada, haríamos aquí 00:04:52
la suma acumulativa y devolveríamos la suma 00:04:54
lo que fuera, ya está 00:04:56
¿vale? entonces en relación a la 00:04:57
pregunta que 00:05:00
que hacías tú 00:05:01
claro, sí, sí, no, pero 00:05:03
vale, es que eso tiene que ver 00:05:06
con paso por valor y referencia de objetos 00:05:08
entonces ya insistiremos en ello 00:05:10
cuando veamos objetos, pero 00:05:12
sí que se puede responder 00:05:14
a tu pregunta 00:05:16
entonces, vamos a 00:05:17
la pregunta que ha hecho Juanjo 00:05:20
es, claro, yo aquí 00:05:22
le paso, sí, sí, sí 00:05:24
sí, va a poner una función 00:05:27
específica para 00:05:28
La pregunta que ha hecho Juanjo 00:05:29
Yo tengo una variable 00:05:32
Y hago aquí una función 00:05:33
A la que le paso un parámetro n 00:05:34
Y ahora aquí hago 00:05:46
n igual a 8 00:05:48
Por ejemplo 00:05:51
¿Vale? Y mi función termina 00:05:52
Vale, imagina, entonces le voy a pasar aquí 00:05:54
Una variable, un valor 00:05:56
Le paso un valor 00:05:58
¿Vale? Y a ese valor n 00:05:59
Que le he pasado le pongo a 8 00:06:02
Y luego hago con él lo que sea, vamos a suponer que lo mostramos 00:06:04
Por ejemplo 00:06:06
Y aquí se verá el 8 00:06:07
Es evidente que ahí veremos el 8 00:06:10
Entonces vamos a poner aquí dentro de la función 00:06:12
Dentro de la función 00:06:15
Vale, entonces ahora 00:06:20
Vamos a llamar aquí a la función pasándole esta variable 00:06:28
La función se llama cambiarNumero 00:06:31
Más liso, pues no lo tiene más liso 00:06:35
No pillo nada 00:06:44
Vale, entonces vamos a llamar a cambianúmero 00:06:48
Pasándole esta variable 00:06:52
Esta variable que tiene el valor 9 00:06:53
Dentro de la función 00:06:55
Ponemos a 8 00:06:57
Mostramos y ahora vamos a mostrar 00:06:59
Vamos a mostrar lo que vale n 00:07:01
Aquí después 00:07:04
Vamos a mostrar el valor de n 00:07:04
Vamos a poner aquí fuera de la función 00:07:10
Fuera de la función 00:07:11
Vale, a ver 00:07:16
Esto es importante 00:07:20
Para que uno, pues el programa 00:07:21
No haga cosas que no espera 00:07:24
Vale, entonces, ¿entendéis lo que estoy haciendo? 00:07:25
He creado una función 00:07:28
Cambia número, que recibe un parámetro 00:07:30
A través de este 00:07:32
De esta variable de aquí, recibe un parámetro 00:07:33
Que hace la función dentro 00:07:36
Este parámetro que ha recibido 00:07:38
Lo pone a 8 y ahora muestra su valor 00:07:40
Dentro de la función su valor 00:07:42
Vale, yo llamo aquí a la función 00:07:44
Pasándole un valor entero 00:07:46
Pues este en particular 00:07:47
Le paso este 00:07:49
Y ahora, una vez que esta función ha terminado 00:07:50
Voy a llamar al valor de n 00:07:54
Vale 00:07:57
¿Qué creéis que va a mostrar aquí? 00:07:58
¿9 u 8? 00:08:02
Todo el mundo cree que 9 00:08:04
dentro de la función 8 00:08:07
y fuera de la función 9 00:08:20
efectivamente, a ver 00:08:21
¿cómo funciona el paso de parámetros 00:08:23
en funciones? 00:08:26
importante que lo entendáis porque si no 00:08:28
el programa puede hacer cosas que no esperáis 00:08:29
que haga y no sabéis por qué 00:08:32
¿cómo funciona? 00:08:33
vamos a ver 00:08:35
cuando uno declara una función 00:08:36
aquí indicamos 00:08:39
que tiene que recibir un valor 00:08:41
lo indicamos de esta manera 00:08:42
pero lo que recibe 00:08:44
es el valor 00:08:46
no recibe la caja entera 00:08:47
para trabajar con ella 00:08:50
recibe el valor 00:08:51
entonces vamos a verlo en la pizarra 00:08:53
para que quede 00:08:56
vale, vamos a hacer esa función que hemos hecho antes 00:08:56
teníamos cambia número 00:09:16
int n 00:09:18
entonces cuando llamamos 00:09:18
desde nuestro main 00:09:21
nuestro main pues tenía 00:09:22
int n igual a 9 00:09:24
y luego ya llamábamos 00:09:27
a cambia número 00:09:29
pasándole n 00:09:33
¿vale? 00:09:34
esto es lo que está en nuestro main 00:09:36
esto es lo que está en nuestro main ¿verdad? 00:09:38
una variable que le ponemos a 9 00:09:41
y le pasamos el valor 00:09:42
y llamamos a esta función 00:09:44
¿vale? pues ¿qué se hace cuando se hace 00:09:45
una llamada a una función pasándole un valor? 00:09:48
bueno pues a cambia número 00:09:51
a cambio de número, nosotros tenemos aquí está claro en el main nuestro 00:09:52
en este main tenemos una cajita que se llama n 00:09:56
eso ya lo sabemos porque eso es lo que hacemos cuando declaramos una variable 00:10:01
cuando declaramos una variable hacemos que aparezca en memoria 00:10:04
una cajita con nombre n y en esa cajita ya se van dando 00:10:08
los valores que vaya siendo necesario, en este caso le hemos dado el 9 00:10:12
pues con esta sentencia de aquí 00:10:16
con esta sentencia de declaración 00:10:19
int n igual a 9 lo que hemos hecho es esto 00:10:23
crear la caja, ponerle el nombre n 00:10:25
y pasarle 9 00:10:28
ahora, ¿qué hacemos cuando llegamos a la función? 00:10:29
cuando llegamos a la función, cambia número 00:10:32
pues entonces 00:10:34
la máquina virtual 00:10:35
salta al código que hay aquí 00:10:37
que el código que hay aquí es este 00:10:39
salta al código que hay aquí 00:10:48
¿y qué es lo que le pasa a este código? 00:10:49
¿qué es lo que le pasa? 00:10:52
no le pasa a la caja 00:10:53
no le pasa la caja, saca el valor 00:10:54
saca el valor 9 00:10:56
y se lo pasa a la función 00:10:58
y le dice, oye 00:11:00
créate tú una caja temporal 00:11:02
que llames como se ponga ahí, como tú quieras 00:11:04
porque ya sabemos que esta variable 00:11:07
este nombre se puede llamar como uno quisiera 00:11:08
entonces le dice, oye, créate tú 00:11:10
una caja temporal, llámala como quieras 00:11:12
una caja temporal, en este caso la estoy llamando n 00:11:14
créate tú una caja temporal 00:11:16
porque en esa caja local 00:11:18
tuya, temporal tuya 00:11:20
te voy a pasar el numerito este 00:11:22
de aquí, entonces 00:11:25
el numerito 00:11:26
es el que se pasa aquí 00:11:28
a esta caja temporal de aquí, el 9 00:11:30
entonces 00:11:33
en un código como este tenemos dos 00:11:34
cajas, la de la clase 00:11:37
main, la del método main 00:11:39
la n que tiene el 9 00:11:41
y ahora cuando hemos llamado a la función 00:11:42
cada una de estas 00:11:45
es una cajita o una variable 00:11:46
local suya, que desaparece 00:11:48
en cuanto la función termina, es una variable 00:11:51
local suya, entonces 00:11:52
esta función durante el tiempo que 00:11:54
se está ejecutando tiene su propia variable 00:11:56
local n, y que ha 00:11:58
ocurrido cuando la hemos llamado 00:12:00
que se ha inicializado con 00:12:02
este valor, si le hubiéramos 00:12:04
dado aquí 10 en vez de n 00:12:07
pues esta variable local se habría inicializado 00:12:08
con 10, depende 00:12:11
esta variable local que crea 00:12:12
esta función a la que llama 00:12:15
n, se inicializa 00:12:17
con el número que vemos aquí, pero 00:12:19
tenemos dos variables separadas una es la de mi clase main las que están en main que están ahí 00:12:20
todas con sus valores y luego cada vez que se llama una función se crean tantas variables locales como 00:12:25
haya en parámetros tantas y son sus propias variables locales y esas variables locales se 00:12:32
llenan con los valores que le demos aquí entonces cuando hemos hecho un igual a 8 el 8 se ha colocado 00:12:38
en esta variable local de ahí se ha colocado ahí 00:12:45
pero sin embargo 00:12:49
cuando ya hemos salido 00:12:52
cuando ya hemos vuelto aquí 00:12:53
esta variable local ya ha desaparecido 00:12:55
cuando ya hemos vuelto aquí esa variable ha desaparecido 00:12:57
y ha quedado esta 00:12:59
y esta sigue teniendo el valor que tenía 00:13:00
el 9, ¿vale? 00:13:03
sigue teniendo el valor que tenía 00:13:06
¿vale? entonces, un segundo 00:13:07
dos minutos para verlo con otro ejemplo 00:13:10
que quede claro, que no os enfriéis 00:13:12
y ya paramos, ¿vale? 00:13:13
vamos a verlo con otro ejemplo 00:13:15
y luego ya paramos 00:13:17
para que no 00:13:19
os enfriéis ahora que lo tenéis 00:13:20
¿y el programa a la hora de ejecutarse 00:13:23
cuenta con las funciones 00:13:24
para guardar RAM? 00:13:27
no, no es que cuenta 00:13:31
a ver, el proceso tendrá 00:13:32
el sistema operativo, su planificador de procesos 00:13:35
tendrá una RAM y la irá llenando 00:13:37
hasta que se acabe 00:13:39
depende de la RAM que tenga el equipo 00:13:40
¿no hay tres programas? 00:13:42
¿Se declaran las variables para dejar el espacio para el programa? 00:13:44
¿Se declaran las variables para que el programa tenga el espacio? 00:13:47
No, a ver. 00:13:50
¿En teoría? 00:13:51
No, no, porque es que sobre todo en un programa orientado a objetos 00:13:52
es que no sabes cuántos objetos van a aparecer. 00:13:55
Entonces el proceso tendrá su rama asociada y se va de forma dinámica para el programa. 00:13:58
¿Vale? Entonces si me escucháis y os concentráis, paramos antes. 00:14:03
Otro ejemplo de esto mismo. 00:14:08
Imaginaos que tenemos una función 00:14:10
Que la 00:14:12
Imaginaos que la llamamos 00:14:14
Intercambia 00:14:16
Por ejemplo 00:14:18
Y yo le paso 00:14:19
Imaginaos que tenemos esta función 00:14:22
X e Y, por ejemplo 00:14:29
¿Y qué vamos a hacer? 00:14:32
Vamos a intercambiar estos dos valores 00:14:33
Vamos a hacer un código que intercambie estos dos valores 00:14:35
Por ejemplo 00:14:38
¿Vale? 00:14:38
esto, nada, devuelvo y voy 00:14:40
vamos a hacer un código que intercambie estos dos 00:14:42
vale, pues entonces este código 00:14:44
pues ya sabemos como lo haríamos 00:14:46
int aus igual a x 00:14:47
x igual a y 00:14:50
e y igual a 00:14:53
aus, ¿no? 00:14:57
¿vale? 00:15:01
entonces 00:15:03
¿qué ocurre cuando esta función se le llama? 00:15:03
cuando esta función es llamada 00:15:07
desde cualquier sitio 00:15:08
Esta función automáticamente crea dos variables locales x e y 00:15:10
Dos variables locales x e y 00:15:17
Entonces tenéis que ver los parámetros de una función 00:15:19
Los parámetros como variables locales suyas 00:15:24
Tenéis que verlos como variables locales suyas 00:15:26
Entonces esta función en el momento en que es llamada 00:15:29
Crea dos variables locales x e y 00:15:32
Y trabaja con ellas 00:15:35
¿qué ocurre cuando la función ya termina? 00:15:37
estas variables locales 00:15:41
han desaparecido 00:15:43
¿vale? luego los parámetros 00:15:44
de una función son variables locales suyas 00:15:46
que se crean en el momento 00:15:49
en que entramos en la función 00:15:50
se trabaja con ellas y luego 00:15:52
desaparecen, son variables locales 00:15:54
¿vale? entonces ¿qué ocurre 00:15:57
si ahora llamáramos a esta función 00:15:58
desde un main cualquiera? 00:16:00
pues imaginaos que ahora tenemos un main 00:16:04
Int x igual a 7, int y igual a 9, y ahora llamamos a intercambia, llamamos a intercambia pasándole x e y, vale, pues entonces cuando hacemos esta llamada, lo que estamos pasando a la función intercambia son solo estos valores, estamos diciendo, oye función, cuando te crees tú tu variable local x y tu variable local y, 00:16:06
porque recuerdo, los parámetros de una función 00:16:36
son variables que se crean en ese momento 00:16:38
y son locales a la función 00:16:40
pues estamos diciendo, oye, cuando te crees tú 00:16:41
tu propia variable local x 00:16:44
y tu propia variable local y 00:16:46
inicializa x con este valor que yo te doy 00:16:48
que resulta que es 7 00:16:51
e inicializa y con este valor 00:16:52
que yo te doy aquí 00:16:55
que resulta que es 9 00:16:56
como si yo le diera 11 y 13 00:16:57
le estaríamos diciendo, oye, cuando te crees 00:17:00
tu propia variable local x 00:17:02
y te crees tu propia variable local y 00:17:04
inicializa la x con el 11 00:17:06
y la y con el 13 00:17:09
es decir, lo que pasamos aquí 00:17:11
son solamente 00:17:13
los valores con los que inicializamos 00:17:15
las variables locales 00:17:17
que se crean cuando entramos en la función 00:17:19
¿vale? 00:17:21
entonces cuando esta función ha terminado 00:17:23
x e y 00:17:25
las variables del main 00:17:26
no se han enterado de nada de lo que ha pasado 00:17:28
no se han enterado de nada 00:17:30
porque con quien ha trabajado la función 00:17:31
es con las variables locales suyas 00:17:33
que ha creado 00:17:36
y lo que pasamos aquí 00:17:37
son sólo valores 00:17:39
para inicializar esas variables locales 00:17:41
sólo pasamos valores 00:17:43
no pasamos la variable, la caja entera 00:17:44
porque si pasáramos 00:17:47
la caja entera, todo lo que 00:17:49
hiciéramos aquí, luego se vería 00:17:51
al salir, pero es que no pasamos 00:17:53
la caja entera, pasamos 00:17:55
dos valores que inicializan 00:17:57
las cajitas locales 00:17:59
y cuando la función termina 00:18:01
estas cajitas locales han desaparecido 00:18:03
la función habrá devuelto un valor 00:18:05
o lo que sea, pero las cajitas locales 00:18:08
x y y han desaparecido 00:18:10
¿vale? entonces por eso 00:18:12
se dice que el paso 00:18:14
de parámetros a 00:18:15
funciones es por valor 00:18:18
se llama así, por valor, porque lo que 00:18:19
se pasa es el valor, no se pasa la caja entera 00:18:22
¿vale? se pasa 00:18:24
el valor, paso el valor de 00:18:25
x para tu cajita local y paso 00:18:28
el valor de y para tu cajita local 00:18:30
se pasa el valor 00:18:31
entonces a veces sería útil 00:18:33
pasar la caja entera 00:18:37
sería utilísimo pasar la caja entera 00:18:39
oye, ya que haces cosas 00:18:41
con lo que yo te paso 00:18:43
que eso que haces 00:18:44
afecte ya al programa 00:18:45
ojalá pudiera yo pasarte la caja entera 00:18:47
pero en cualquier caso 00:18:49
sí, podríamos devolver los valores 00:18:55
y luego asignarlos 00:18:57
ahora mismo no tendríamos 00:18:59
o sea, devolver un array con dos valores 00:19:01
y asignarlos 00:19:03
pero ni siquiera hace falta 00:19:03
o sea, hay una manera de 00:19:07
oye, mira, te voy a pasar la caja 00:19:09
entera, entera, te paso la caja entera 00:19:11
y así todas las operaciones que 00:19:13
hagas no van a ser con 00:19:15
copias locales, sino con 00:19:17
cajas enteras, pero pasar la caja 00:19:19
entera significa pasarlo en 00:19:21
modo objeto 00:19:23
entonces, cuando veamos objetos 00:19:23
veremos cómo puedo pasar 00:19:26
yo la caja enterita para que todo lo que haga 00:19:29
aquí dentro 00:19:31
se refleje 00:19:31
en el mail 00:19:33
porque al haber pasado 00:19:34
el contenedor 00:19:35
si yo trabajo 00:19:36
con este contenedor 00:19:37
aquí dentro 00:19:38
lo que haga 00:19:39
se va a reflejar 00:19:39
pero con lo que 00:19:40
estamos haciendo 00:19:41
nosotros hasta ahora 00:19:42
lo que estamos creando 00:19:43
es siempre 00:19:44
cajitas locales 00:19:45
variables locales 00:19:47
y pasamos el valor 00:19:48
cuando esta función 00:19:49
ha terminado 00:19:51
eso ha desaparecido 00:19:51
¿vale? 00:19:53
por eso se llama 00:19:54
paso por valor 00:19:54
y lo otro se llama 00:19:55
paso por referencia 00:19:56
pero bueno 00:19:56
vale, ahora sí que 00:19:57
paramos entonces 00:19:58
Justo, un objeto es una dirección 00:19:59
Entonces le pasas la dirección 00:20:03
Entonces te da igual llegar a esa dirección 00:20:04
Desde una función que desde aquí 00:20:06
O vas al mismo lado 00:20:08
Es justo eso, claro 00:20:09
Venga, pues 00:20:11
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
17 de noviembre de 2024 - 17:29
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
20′ 14″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
69.91 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid