20261022 Ambito_Variables | Mediateca de EducaMadrid

Bueno, pues aquí ¿qué haríamos? Pues la misma situación que la anterior, tenemos que sumar un montón de cosas, un montón de cosas tenemos que sumar, vale, pues entonces, como hay que sumar un montón de cosas, un montón de sumas acumulativas, pues una variable suma que empieza valiendo cero y dentro de un bucle, dentro de un bucle, iremos haciendo esta operación. 00:00:01

suma igual a lo que tuviera de antes, más el sumando nuevo que tenga yo que incorporar, ¿vale? 00:00:27

Hemos identificado que es un montón de sumas, inicialmente cero y cada vuelta del bucle un sumando nuevo, 00:00:35

siguiente vuelta, otro sumando nuevo. Ahora lo que pasa es que tenemos que particularizarlo a nuestra situación, 00:00:43

¿Qué es? ¿De dónde llegan los sumandos? Los sumandos llegan de números que se van leyendo por teclado, de ahí llegan. Pues entonces, el sumando lo tendré que pedir aquí, tendré que pedirlo aquí, para lo cual voy a necesitar, pues, el escáner para leer del teclado. 00:00:49

vale, lo tendré que pedir aquí 00:01:16

y ahora pues por ejemplo 00:01:25

mi sumando que sea 00:01:26

igual a esto 00:01:29

a scan.nextIn 00:01:30

vale, en este caso 00:01:33

lo tengo casi más fácil que el anterior 00:01:36

aquí el cada sumando 00:01:38

de cada iteración es un 00:01:40

número nuevo que he leído 00:01:42

pues lo leo, en el ejercicio 00:01:43

anterior, cada sumando 00:01:46

lo tenía yo que ir 00:01:48

obteniendo a partir de un valor 00:01:50

inicial al que le iba sumando 00:01:52

de uno en uno 00:01:54

porque en ese caso me decían suma uno, luego dos 00:01:55

luego tres, me decían los que había que sumar 00:01:58

luego cuatro, luego cinco, me lo estaban diciendo 00:02:00

pues ya está 00:02:02

aquí me están diciendo, los que tienes que sumar no son 00:02:03

primero uno, luego dos, luego tres, tienes que sumar 00:02:06

este que yo te doy 00:02:08

y ahora este que yo te doy, y ahora este que yo te doy 00:02:09

bueno, pues entonces 00:02:13

cada uno de los sumandos 00:02:14

que voy sumando es 00:02:16

este que yo te doy, para adentro de la suma 00:02:17

Ahora este otro que yo te doy, para dentro de la suma, en cada suma acumulativa, los sumandos que se van generando en cada iteración, tengo que ver de dónde salen, pues en este caso salen de que los voy leyendo del teclado, de ahí salen. 00:02:20

Vale, pues esto ya está bastante hecho 00:02:35

Es una suma acumulativa 00:02:38

Donde estos números 00:02:41

Estos sumandos cada vez 00:02:42

Lo voy pidiendo 00:02:44

Vale, pero esto sigue sin terminar 00:02:46

Por supuesto 00:02:49

Me faltaría 00:02:50

Lógicamente mostrar la suma 00:02:52

Pero también está sin terminar 00:02:55

Porque, oye, ¿cuándo termino yo? 00:02:59

¿Cuándo termino yo? 00:03:02

Pues estoy en las mismas 00:03:03

cuando el número que 00:03:05

estás leyendo, que en este caso 00:03:08

el número que estás leyendo sea este 00:03:10

sea igual a cero 00:03:12

vale, pues estoy 00:03:14

en la misma situación que ya he visto 00:03:16

que ya conozco, que ya tengo en la cabeza 00:03:18

ah, vale, estoy en 00:03:20

un programa que está pidiendo un valor 00:03:22

para hacer algo, pidiendo un valor para hacer algo 00:03:24

pero la primera vez 00:03:26

tiene que entrar sí o sí, o sea 00:03:28

el primer valor tiene que entrar sí o sí 00:03:30

ah, vale, estoy en las mismas de siempre 00:03:32

Pues voy a cambiarlo por un do while 00:03:33

Me hago yo aquí mi do 00:03:35

Lees el primer número 00:03:37

Y lo sumas 00:03:41

Y esto mientras ocurra que 00:03:43

Mientras ocurra que el número leído 00:03:45

Sea diferente de cero 00:03:49

Lo mismo del primer ejemplo 00:03:51

Que hemos hecho hoy 00:03:53

Mientras sumando sea diferente 00:03:54

De cero 00:03:57

Entonces casi está 00:03:58

Lo he cambiado un do while 00:04:02

simplemente porque me he dado cuenta 00:04:05

que tiene que entrar una primera vez sí o sí 00:04:07

el primer número tengo que dárselo 00:04:09

que ese número ya es cero, no pasa nada 00:04:11

no vuelvo, pero el primer número tengo que dárselo 00:04:13

sí o sí 00:04:16

entonces lo he cambiado a un do while porque veo que se 00:04:16

adapta al do while 00:04:19

pues venga, leo el primer número 00:04:21

lo sumo a la suma acumulativa 00:04:24

ese número es 00:04:26

diferente de cero 00:04:27

vuelvo al siguiente y así todo el rato 00:04:28

vale 00:04:31

Casi está, si no fuera porque el compilador me ha dado un problema. 00:04:33

De nuevo, ¿qué problema? 00:04:37

¿Por qué me está dando ese problema el compilador? 00:04:38

Ahora ya no es tan fácil de verlo, aunque, ¿vale? 00:04:48

Porque es, oye, no puede ser porque no esté inicializada cuando llegue aquí, 00:04:55

porque claro que lo está. 00:05:01

Yo lo primero que hago es leerlo. 00:05:03

Y podríais decir, pero no puede ser que sea porque no está declarada, 00:05:06

porque si es que la estoy viendo declarada aquí arriba. 00:05:11

Entonces, no puede ser por eso, porque no está declarada. 00:05:14

Vale, pues entonces, ¿por qué me da este error? 00:05:23

Pues me da por una cosa interesantísima y básica y fundamental en programación, 00:05:31

que es el ámbito de las variables. 00:05:37

O lo que es lo mismo, ¿cuánto tiempo están vivas las variables? 00:05:47

el error me da por esto 00:05:51

¿vale? 00:05:57

no me da porque no 00:06:00

esté declarada anteriormente 00:06:01

en principio, porque yo la estoy viendo aquí arriba 00:06:03

no me da porque no esté 00:06:05

inicializada, porque claro que lo está 00:06:07

yo entro una primera vez y lo está 00:06:09

me da por otra cosa 00:06:11

otra cosa que tenemos que 00:06:13

entender ahora muy bien 00:06:15

¿vale? entonces vamos a aprovechar para explicarla 00:06:17

ahora, porque es el sitio en el 00:06:19

que encaja 00:06:21

Entonces, pues a ver, vámonos aquí a la pizarra. 00:06:23

Vale, pues nosotros ahora, ¿vale? 00:06:48

Vamos a mencionar que es esto del ámbito de las variables, que es muy importante. 00:06:51

Bueno, como todo. 00:06:59

Vale, pues nosotros ya conocemos, nos suena el término bloque de código. 00:07:05

Nos suena el término bloque de código. 00:07:14

que era un bloque de código 00:07:16

cualquier trozo de código 00:07:17

entre llaves 00:07:19

eso es un bloque de código 00:07:21

entonces 00:07:24

ahora ya estamos viendo programas 00:07:26

que tienen varios bloques de código 00:07:28

al principio de los tiempos 00:07:29

cuando nuestro programa tenía solamente 00:07:31

el bueno class 00:07:33

no se que 00:07:36

y aquí el main 00:07:36

el bla bla bla 00:07:40

main 00:07:42

decíamos nuestro programa va siempre aquí dentro 00:07:42

aquí va siempre 00:07:49

ya entenderemos por qué, por qué hace falta esto 00:07:50

cuando va a funcionar en todo objeto 00:07:54

pero lo que sí que sabemos desde ya 00:07:55

porque estamos partiendo de eso es que nuestro programa 00:07:57

siempre va aquí, vale, eso está claro 00:07:59

bueno, pues 00:08:01

en los primeros tiempos 00:08:03

nuestro programa 00:08:06

estaba en un único bloque 00:08:07

que es en este, ¿verdad? 00:08:09

entre esta llave que se abre aquí 00:08:11

y esta llave que se abre aquí, era un único 00:08:13

bloque de código donde hacíamos todo 00:08:15

pues declarar valiables, las sumas 00:08:17

las operaciones, lo que fuera, un único bloque 00:08:19

¿qué ocurre? 00:08:21

que cuando hemos incorporado 00:08:24

las sentencias de decisión 00:08:25

y los bucles 00:08:27

han empezado 00:08:29

a aparecer bloques anidados 00:08:31

que lo hemos 00:08:33

pasado un poco por alto, no pasa nada 00:08:35

y no nos hemos parado a pensar 00:08:37

qué implicaciones podía tener, que las tiene 00:08:39

y muchas, y muy gordas 00:08:41

vale, por ejemplo 00:08:43

pues eso, nosotros tenemos aquí nuestro programa 00:08:45

pues una variable n que leemos del teclado 00:08:48

scan no sé qué, bla bla bla 00:08:54

y ahora hemos hecho, por ejemplo, si mi variable n es mayor 00:08:57

que cero y aquí hemos abierto otras llaves 00:09:02

para poner un conjunto de sentencias, hemos abierto 00:09:06

otras llaves, con lo cual desde que hemos incorporado los if y los while 00:09:10

nos están apareciendo 00:09:14

subbloques más pequeños 00:09:16

dentro del bloque grande 00:09:18

que es este, el bloque más grandote 00:09:20

¿vale? cada vez que hemos abierto 00:09:23

un if con una llave nos ha aparecido un bloque 00:09:24

pequeñito 00:09:26

luego, los bloques 00:09:27

primera cosa de la que nos damos cuenta 00:09:31

pueden estar, de hecho 00:09:33

están unos dentro de otros 00:09:34

aquí tengo yo un bloque de código 00:09:36

con esas sentencias 00:09:38

y resulta que este bloque de código está dentro 00:09:40

de este otro grandote 00:09:43

no pasa nada, los bloques están unos dentro de otros 00:09:44

vale, ya está 00:09:47

y lo que es más 00:09:48

imaginaos que dentro de este if 00:09:50

si n es mayor que 0 00:09:52

yo quiero hacer no sé qué operación que implica 00:09:54

un bucle 00:09:56

pues entonces, dentro de ese if 00:09:57

yo podría a lo mejor tener aquí un while 00:10:00

porque quiero hacer no sé qué 00:10:02

con lo cual abro otras llaves 00:10:04

con lo cual ahora tengo 00:10:06

tres bloques 00:10:08

este bloque con sus sentencias dentro 00:10:09

que está dentro de este otro más grandote 00:10:12

que es el asociado al id 00:10:15

que está dentro del mayor 00:10:16

luego los bloques pueden estar perfectamente 00:10:19

unos dentro de otros 00:10:21

y así hemos estado programando 00:10:22

y ya está 00:10:25

pero, ¿qué implicación tiene un bloque? 00:10:26

pues desde el momento 00:10:31

en que aparece un bloque 00:10:31

lo que ocurre es que 00:10:32

las variables que estén declaradas 00:10:35

dentro de un bloque 00:10:37

solo tienen vida 00:10:38

solo existe en el trozo de código correspondiente a ese bloque, solo, fuera no existe, es decir, 00:10:41

imaginaos que yo tengo efectivamente aquí un programa en el cual, pues tengo aquí mi 00:10:50

mail y ahora, pues yo que sé, tengo una variable n por aquí y ahora me hago un if, que sea 00:10:57

oye, si n es mayor que 3 o me da igual, pues leo una variable m y yo la declaro aquí dentro, 00:11:09

la leo por teclado, me da igual, le doy un valor, leo una variable m y súmasela a la n, 00:11:19

n igual a n más m. Yo qué sé, imaginaos este código. 00:11:24

Vale, en este bloque más pequeñito, que está aquí dentro, en este bloque, 00:11:31

yo he declarado una variable y puedo, no hay ningún problema porque yo he declarado las variables 00:11:36

en el punto que a mí me dé la gana 00:11:41

siempre y cuando las declare antes de su primer uso 00:11:42

claro, esta está declarada 00:11:45

antes de su primer uso, ningún problema 00:11:47

pero ¿qué ocurre? 00:11:49

que está declarada dentro de este 00:11:51

¿eso qué significa? 00:11:53

que esta variable al estar declarada 00:11:57

dentro de este bloque 00:11:59

solo es visible o accesible 00:12:00

para las sentencias del interior 00:12:02

de este bloque, solo para ellas 00:12:05

para esta lo ha podido ser 00:12:07

sin problema 00:12:08

pero si yo salgo de este bloque 00:12:09

me voy fuera e intento acceder a M 00:12:12

para mostrar M 00:12:14

pues me va a decir 00:12:16

¿eh? ¿M quién es? 00:12:19

no lo sé 00:12:20

porque la variable M solo es visible 00:12:21

solo existe 00:12:24

en el bloque más interno en el que está declarada 00:12:25

solo en este 00:12:29

¿vale? 00:12:30

entonces esta variable está declarada en este bloque 00:12:32

luego solo existe en este bloque 00:12:34

de aquí 00:12:37

no en los que le contienen 00:12:37

en los que le contienen no existe, no es visible 00:12:39

Cuando este código termine 00:12:41

La variable m desaparece 00:12:44

Se va a la basura 00:12:46

En cuanto este código termine 00:12:46

Con lo cual si yo intento mostrarla 00:12:48

Una vez que he acabado este bloque 00:12:50

Es imposible porque m va a haber desaparecido 00:12:52

Esto como va a haber funcionado 00:12:56

Cuando la máquina virtual lo ejecute 00:12:59

Pues la máquina virtual llegará por aquí 00:13:00

Y dirá n igual a 3 00:13:03

Ah muy bien, me declaro mi variable n 00:13:04

Esta cajita n y le doy el 3 00:13:06

Vale 00:13:08

Ahora entro en el if 00:13:09

n es mayor que 3, ah vale, bueno, mayor o igual que 3 00:13:11

para que entre, por ejemplo 00:13:15

n es mayor o igual que 3, sí, pues entro en el bucle 00:13:16

¿qué hago en el bucle? 00:13:19

abro un nuevo bloque 00:13:21

y ahora, ah, declaro una variable m 00:13:22

5, muy bien 00:13:25

pues declaro una variable m que se llama 5 00:13:27

y ahora hago 00:13:29

n igual a n más m, luego n más m 00:13:30

es 3 más 5, 8 00:13:33

este 3 desaparece 00:13:34

y se convierte en 8, muy bien 00:13:36

y este código terminó 00:13:39

entonces en cuanto termina la ejecución 00:13:40

de un código 00:13:44

todas las variables que estaban declaradas dentro 00:13:44

todas se van a la basura 00:13:48

todas desaparecen 00:13:49

en cuanto este código ha terminado 00:13:51

la variable m fuera 00:13:53

ya no existe, a la basura 00:13:55

¿vale? 00:13:57

la variable n no 00:14:00

porque la variable n estaba en el código 00:14:01

superior que no ha terminado 00:14:03

entonces 00:14:05

si una vez terminado este código yo intentara 00:14:07

acceder a M para hacer lo que fuera 00:14:09

me diría, ¿y M quién es? 00:14:11

si es que no hay ninguna caja que sea M, ha desaparecido 00:14:13

claro, porque 00:14:16

cuando un bloque termina 00:14:18

todas las variables declaradas 00:14:19

dentro de ese bloque 00:14:22

desaparecen, todas 00:14:23

yo las habré usado 00:14:26

aquí dentro para hacer cosas, porque para eso 00:14:28

las declaré, lógicamente, para hacer cosas 00:14:30

pero en cuanto el bloque termina 00:14:32

todas esas variables 00:14:34

declaradas aquí dentro han desaparecido 00:14:35

todas, a eso se les llama 00:14:37

variables locales 00:14:43

a un bloque 00:14:44

m es la variable local 00:14:46

de este bloque 00:14:49

ahí solamente 00:14:49

dura, vive el tiempo 00:14:52

que esté este bloque ejecutándose 00:14:55

en cuanto estas llaves ya se cierran 00:14:56

ya he terminado 00:14:59

esta que está aquí declarada 00:15:00

desaparece 00:15:02

¿vale? a ver en un ejemplo 00:15:03

entonces voy a 00:15:11

ponerlo aquí en una clase aparte para 00:15:32

vale, pues este es un bloque, está claro 00:15:35

este es un primer bloque 00:15:56

el bloque más grande que hay 00:15:57

en el que puede haber código, este 00:16:00

entonces yo aquí me puedo declarar una variable 00:16:02

todas las que quiera, vale, y aquí están 00:16:04

mis variables, ya está 00:16:08

ahora 00:16:15

yo voy a hacer un bloque cualquiera 00:16:17

por ejemplo, mientras 00:16:19

n 00:16:21

sea 00:16:23

menor o igual 00:16:24

que 18 00:16:27

pues que voy a hacer 00:16:29

pues a la variable n 00:16:32

le voy a ir sumando un valor 00:16:34

n igual a 00:16:36

n 00:16:45

más igual 00:16:46

1 yo que sé cualquier tontería 00:16:50

vale 00:16:52

entonces a n o n más más me da igual 00:16:53

vale pues estoy yo aquí en este bucle 00:16:56

en este bucle a mi variable n 00:16:59

le voy sumando 1 y cuando n llega a valer 18, pues ya está, sale, cualquier tontería, vale, pues con este código chorra aquí resulta que tengo otro bloque más, vale, entonces tengo este bloque que está dentro de este otro, bueno, primera cosa, desde un bloque interno no hay ningún problema con acceder a las variables de los bloques que están fuera, 00:17:01

porque estas variables declaradas aquí 00:17:27

al estar declaradas en este bloque gordo 00:17:30

van a existir todo el tiempo hasta que el bloque termina 00:17:33

que el bloque termina aquí 00:17:38

entonces estas variables N y M están asociadas al bloque que empieza aquí 00:17:39

ese bloque no termina hasta aquí 00:17:44

con lo cual hasta este punto 00:17:47

N y M están visibles 00:17:50

en particular aquí dentro, ningún problema en todas partes 00:17:53

n y m están visibles 00:17:56

vale 00:17:58

ahora vamos a imaginar que en este bloque 00:17:58

que está aquí dentro 00:18:02

dentro del otro interno, interior 00:18:03

este bloque que es el 00:18:05

del while, aquí declaro 00:18:08

yo una variable 00:18:12

porque yo que sé, por cualquier cosa 00:18:13

declaro una variable por ejemplo 00:18:16

para leerla por teclado 00:18:19

vale, leo esta variable 00:18:23

del teclado y 00:18:43

que quiero hacer con esta variable 00:18:45

pues sumarse la n, por ejemplo 00:18:47

n igual a 00:18:49

n más n2 00:18:52

por ejemplo, voy a cambiar el programa 00:18:54

así, entonces este programa 00:18:55

lee una variable del teclado 00:18:58

y se la suma a n2 00:19:00

lee una variable del teclado y se la suma 00:19:01

a n, perdón, a n2 00:19:04

lee una variable del teclado 00:19:06

y se la suma a n, vale 00:19:08

bueno, pues ya está 00:19:09

este programa hace lo que tenga que hacer 00:19:11

y en este caso en particular que he hecho yo 00:19:13

a la variable 00:19:16

la variable n2 esta de aquí 00:19:18

la he declarado aquí dentro 00:19:20

bueno muy bien 00:19:22

está declarada antes de su primer uso 00:19:24

y no hay ningún problema 00:19:26

pero que ocurre 00:19:28

que en cuanto este bucle while ha terminado 00:19:30

en cuanto este while acabó 00:19:32

y yo ya estoy aquí colocada 00:19:34

la variable n2 ya ha desaparecido 00:19:36

esta variable n2 00:19:39

solo va a existir 00:19:41

durante todo el tiempo en el que se esté ejecutando 00:19:42

ese bucle, solo ahí 00:19:45

porque está declarada aquí dentro 00:19:46

solo ahí, no va a existir fuera 00:19:48

entonces si yo aquí 00:19:50

intentara mostrar 00:19:52

el valor con el que se ha quedado N2 00:19:54

su valor último, cuando el bucle salió 00:19:56

pues N2 habrá tenido su última lectura 00:19:59

el compilador 00:20:01

me va a decir un mensajito que sea 00:20:03

N2 no lo encuentro 00:20:05

N2 está sin declarar 00:20:07

no existe 00:20:09

claro porque N2 00:20:10

está declarada en un bucle 00:20:12

interno a este 00:20:14

en el que está esta sentencia 00:20:16

en un bucle interno, luego N2 00:20:18

no existe 00:20:20

dentro del bucle superior 00:20:21

¿vale? N2 no existe ahí 00:20:24

entonces si yo quiero 00:20:26

que N2 00:20:28

sea visible también aquí 00:20:29

fuera 00:20:32

lo podría arreglar 00:20:33

declarándola aquí 00:20:35

yo la declaro ahí en vez de aquí 00:20:37

y ya está 00:20:39

está declarada afuera 00:20:43

está declarada aquí 00:20:45

aquí es donde recibe su valor, se va sumando 00:20:46

pero al estar declarada afuera 00:20:49

esta caja 00:20:51

esa caja no se pierde ni desaparece 00:20:52

hasta el final de su bloque 00:20:55

y ahí se queda 00:20:56

¿vale? 00:20:58

entonces, tenéis que ver esto 00:21:02

lo del ámbito de las variables 00:21:08

los bloques tenéis que verlos 00:21:20

como si fueran espacios 00:21:22

donde uno puede declarar variables 00:21:24

este sería mi bloque grande, el main 00:21:26

Entonces yo aquí puedo declarar mi variable n, mi variable m, por ejemplo, y ahora resulta que tengo un bloque más pequeñito asociado a un if que va aquí dentro. 00:21:28

Entonces si dentro de ese bloque del if yo declaro la variable x e y, pues esas cajas están aquí solamente, están ahí. 00:21:40

e imaginaos que dentro de las llaves de ese if 00:21:48

yo hago otra sentencia if o while 00:21:51

con lo cual 00:21:53

a ver, para que se vea mejor 00:21:55

voy a ponerlo en otro color 00:21:57

lo que pongo en verde son los bloques de código 00:21:58

y lo que pongo en rojo 00:22:07

serían las variables 00:22:09

por ejemplo, yo aquí tengo mi variable n declarada 00:22:10

y mi variable m 00:22:13

vale, este es mi main 00:22:14

dentro del bloque de mi main 00:22:17

resulta que yo he abierto un if 00:22:21

que empieza y se cierra ahí 00:22:23

y dentro de mi if resulta que yo 00:22:26

a lo mejor he abierto un while 00:22:28

que empieza y se cierra aquí 00:22:30

entonces tendría tres bloques, este bloque 00:22:31

que está dentro del bloque del if 00:22:34

que a su vez está dentro del main 00:22:36

vale, si dentro del bloque del if yo declaro 00:22:37

x e y, pues x e y 00:22:40

están declaradas solo 00:22:45

en este bloque de aquí, imaginaos que dentro 00:22:46

del while yo he declarado otra 00:22:48

variable t, ahí, vale 00:22:50

aquí he declarado esta 00:22:52

aquí he declarado estas 00:22:53

y aquí he declarado estas 00:22:57

vale 00:23:02

pues cuando el while termine 00:23:03

esta variable int 00:23:06

desaparece 00:23:08

se acabó 00:23:10

pero sin embargo dentro del while 00:23:11

yo puedo acceder a estas 00:23:14

sin problema y a estas 00:23:16

vale, pero cuando el while termine 00:23:17

esto 00:23:20

desaparece 00:23:22

con lo cual esta variable desapareció 00:23:23

luego desde aquí yo no puedo acceder aquí 00:23:25

cuando yo esté en este bloque 00:23:28

yo no puedo acceder a esta variable 00:23:30

aunque está declarada antes 00:23:32

claro, pero está declarada dentro de este bloque 00:23:34

entonces en cuanto este bloque 00:23:36

terminó, esto ha desaparecido 00:23:38

desde aquí, t, no lo puedo ver 00:23:40

no puedo verlo 00:23:42

y aquí lo mismo 00:23:43

int x e int y, yo las puedo ver en cualquier zona 00:23:45

de aquí, en cualquier zona 00:23:48

donde a mí me dé la gana, aquí dentro también 00:23:49

las puedo ver, donde a mí me dé la gana 00:23:51

Pero en cuanto este if termine, tanto int x como int y han desaparecido en cuanto este if termine. 00:23:54

Con lo cual aquí, fuera de esa caja, yo no podría acceder ni a la x ni a la y. 00:24:03

Ahí no puedo, porque esta caja ya terminó, sus variables asociadas desaparecieron. 00:24:08

Y eso es lo que se llama variables locales. 00:24:17

Esta variable es local a este while, solo se puede usar aquí dentro. 00:24:19

estas variables x y y son locales 00:24:23

al bloque del if, solo las puedo usar 00:24:26

aquí 00:24:28

y estas variables n y m son locales 00:24:29

al mail, las puedo usar en cualquier sitio 00:24:32

¿vale? 00:24:34

y luego además 00:24:36

en un bloque en particular no solo 00:24:37

puedes usar las locales a que 00:24:40

hayas declarado tú, sino también 00:24:42

lógicamente las que 00:24:44

están declaradas por encima de ti 00:24:46

¿vale? 00:24:47

entonces 00:24:52

aquí por tanto 00:24:53

n2 imposible usarlo 00:25:06

perdón, aquí n2 00:25:08

ya si podríamos, vale 00:25:10

aquí el error que nos da 00:25:12

ya no es n2 00:25:14

no la puedo ver, claro que la puedes ver 00:25:16

está declarada aquí n2 00:25:18

está aquí, aquí el error que te da 00:25:19

es otro, te dice, oye podría no estar 00:25:22

inicializada, efectivamente 00:25:24

podría no estar inicializada, ¿por qué? porque el 00:25:27

compilador no sabe si 00:25:29

va a entrar aquí alguna vez o no, no tiene ni idea 00:25:32

el compilador ve reglas 00:25:34

no ve los valores concretos 00:25:35

entonces ve que esto es un while 00:25:38

él sabe que a un while 00:25:39

puede que no se entre nunca 00:25:42

a lo mejor no se entre nunca, depende de la condición 00:25:43

entonces el compilador te dice 00:25:45

oye, ¿qué pasa si a este while 00:25:47

no entras nunca? 00:25:49

n2 no tendría valor, no puedo mostrártela 00:25:51

es el error que te da 00:25:54

no que no esté declarada, porque sí que lo está 00:25:55

entonces bueno, ese error en particular 00:25:58

yo que si lo inicializamos a cualquiera y ya está 00:26:00

entonces como veis desde este bloque pequeñito 00:26:02

he podido acceder tanto a n que está declarada aquí fuera 00:26:07

como a n2 que está declarada aquí dentro 00:26:11

cuando lo estaba, desde este bloque puedo acceder 00:26:15

tanto a n que está aquí como a n2 que está local 00:26:26

pero cuando este while termina esta variable ya 00:26:29

desaparece y desde aquí ya es imposible que yo pueda 00:26:34

acceder a ella para ver qué valor tiene 00:26:38

lo que sea, porque ya ha desaparecido 00:26:40

solamente puedo acceder 00:26:41

a las que están declaradas ahí 00:26:43

¿vale? pues ese es el problema 00:26:45

que nos daba en este ejercicio de aquí 00:26:50

que sumando 00:26:52

resulta que está 00:26:54

declarada dentro de este bloque 00:26:56

la he declarado yo aquí 00:26:58

con lo cual 00:26:59

fuera de estas llaves es inaccesible 00:27:01

fuera de estas llaves es inaccesible 00:27:04

entonces 00:27:06

no pasa nada 00:27:08

la declaro fuera 00:27:09

y arreglado 00:27:11

tengo ya mi programa arreglado 00:27:13

vale 00:27:16

la he declarado fuera 00:27:19

ella toma valor dentro, que es donde tiene que tomarlo 00:27:21

en cada iteración del bucle va tomando 00:27:24

su valor, va tomando valor, va tomando valor 00:27:26

va tomando valor, aquí va tomando su valor 00:27:27

pero está declarada afuera 00:27:30

entonces al estar declarada afuera, esa caja 00:27:32

de esa variable, ya va a estar 00:27:34

viva, aunque este bucle 00:27:36

termine, su valor 00:27:38

lo va a ir recibiendo aquí dentro, pero lo que es la caja 00:27:40

va a estar 00:27:42

viva y va a existir todo el rato 00:27:44

porque está declarado aquí, todo el rato 00:27:46

va a existir ahí la caja 00:27:48

con lo cual la puedo usar aquí sin ningún problema 00:27:49

vale, y ahora este programa 00:27:52

pues ya sí que parece que lo tiene todo 00:27:55

vamos leyendo 00:27:57

dame número, lo sumo 00:27:59

a la variable 00:28:02

acumuladora 00:28:04

¿es diferente de cero? 00:28:04

siguiente, otra vez 00:28:08

es diferente de 0 siguiente otra vez a sumar 00:28:09

cuando ya el bucle ha terminado 00:28:12

es porque el sumando que me han introducido 00:28:14

es 0 pues muestro la suma y punto pelota 00:28:16

vale 00:28:19

entonces hemos aplicado 00:28:21

de nuevo 00:28:24

pues lo que ya sabíamos 00:28:25

primero que esto es una suma acumulativa 00:28:27

pues ya tengo yo mi estructura 00:28:30

mi variable acumuladora 00:28:32

iniciándose a 0 y la operación 00:28:34

de incorporar sumando 00:28:36

que lo estoy poniendo así para que se vea más claro 00:28:37

lo que hacemos, pero ahora ya que lo tenemos 00:28:40

claro, esto quedaría más bonito 00:28:42

así, ¿verdad? que ya sabemos que es equivalente 00:28:43

a lo anterior 00:28:46

estos operadores cuando los vimos 00:28:46

pues ya sabemos que se queda entre lo anterior 00:28:50

vale, pues entonces 00:28:52

suma acumuladora, empieza valiendo 00:28:54

cero y voy sumando lo que toque 00:28:56

¿qué es lo que toca? 00:28:58

pues depende del ejercicio 00:29:00

voy a pensarlo, ah, pues lo que toca es lo que yo 00:29:01

meta por teclado, pues lo meto por teclado 00:29:04

como esta suma acumulativa 00:29:06

tiene que ir dentro de un bucle, pues 00:29:08

condición del bucle, pues esta 00:29:10

y ya está, ¿vale? 00:29:12

estoy reutilizando todo el rato lo que ya he 00:29:14

aprendido a hacer, vamos a hacer 00:29:16

la prueba final ejecutándolo por si hubiéramos 00:29:23

hecho algo raro 00:29:25

hay algo que no he 00:29:26

corregido aquí 00:29:30

ah bueno, vale, que hay un error 00:29:32

en el otro, vale, pues 00:29:46

venga, vamos a ir sumando el 2 00:29:48

el 3, el 1, el 4 00:29:50

y el 0, la suma es 00:29:52

efectivamente 10 00:29:54

2 más 3 más 1 más 4 00:29:56

¿Vale? 00:29:58

Bueno, pues ahora con estas ideas ya podéis hacer vosotros 00:30:05

Este que se nos ha quedado colgado 00:30:08

10 00:30:11

El 10 tiene un matiz 00:30:14

Este, esto, pero que es una cosa que se añade 00:30:17

Que es 00:30:20

Si el primer valor que se introduce no es menor 00:30:21

Intercambiar uno por otro 00:30:26

Entonces pensad a ver como podéis intercambiar el borde de una variable con otra 00:30:28

Pensadlo a ver 00:30:31

y luego habrá que una vez que lo tengáis 00:30:32

es de nuevo hacer una suma acumulativa 00:30:35

aquí hay 00:30:37

en lugar de suma acumulativa es 00:30:39

producto acumulativo 00:30:40

porque es A por A por A por A 00:30:42

a ver si se os ocurre 00:30:45

aquí es producto acumulativo 00:30:47

es la misma idea pero en lugar de sumando 00:30:49

multiplicando igual 00:30:51

en lugar de sumar multiplicar 00:30:52

porque es multiplicar un número por otro por otro 00:30:54

por otro por otro es igual 00:30:56

factorial 00:30:57

buscáis que operación es 00:31:00

el factorial de n es n por n-1 por n-2 00:31:02

luego de nuevo es una multiplicación acumulativa 00:31:06

es hacer lo mismo y una y otra vez 00:31:08

aquí es una suma y un contador 00:31:11

porque la media es la suma entre el total de números 00:31:15

luego hay que sumar y además contar 00:31:19

entonces con esto podríamos aplicarlo 00:31:21

con un nivel de complejidad pues quizá cada vez mayor 00:31:27

porque hay que hacer más cositas pero todo usando lo mismo una y otra vez 00:31:30

adaptándolo hasta el 16 00:31:33

¿vale? 00:31:35

venga, pues poneos con ello 00:31:41

y mañana seleccionamos algunos 00:31:42

para corregir 00:31:44

algunos os ocurrirá más fácil 00:31:46

otro más complicado, pero todo el tiempo 00:31:50

dediquéis a pensarlo 00:31:51

y a hacer 00:31:54

bocetos de programa, aunque al final no los terminéis 00:31:56

es todo ese tiempo el que habrá servido 00:31:58

para aprender 00:32:00

ver la solución de partida desde el principio 00:32:00

se entiende que bien que bonito, no habrá servido 00:32:04

para aprender 00:32:06

el único aprendizaje habrá sido 00:32:06

el rato que uno está tratando de hacerlo 00:32:09

probando, haciendo cosas 00:32:11

y seguramente no llegando a nada 00:32:12

pero habrá avanzado una barbaridad 00:32:14

haciendo eso 00:32:17

¿vale? 00:32:18

20261022 Ambito_Variables - Contenido educativo

Del mismo autor…

Clase 05-04-24 - 2

Clase 05-04-24 - 1

Clase 02-04-24 - 2

Clase 02-04-24 - 1

Clase 19-03-24 - 2

Clase 19-03-24 - 1

Clase 18-03-24 - 2