Saltar navegación

20241202 POO-Clases_4 - 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 2 de diciembre de 2024 por Raquel G.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues todo el mundo tiene claro que este bucle me está haciendo la suma de los sueldos de todos los profesores del array, ¿no? 00:00:01
Va recorriendo el array en toda su longitud y me está incorporando a la variable acumuladora suma, me está incorporando los sueldos. 00:00:08
Luego ya para hacer la media me va a tocar dividir, claro. 00:00:16
Sueldo medio menos igual profesores.length. 00:00:21
vale 00:00:27
bueno, entonces cuando recorremos 00:00:29
un array, solo para 00:00:32
consultar, no para modificar 00:00:34
sus valores 00:00:36
en este caso solo para 00:00:37
consultar, para consultar su sueldo 00:00:40
y llevarlo a otra variable 00:00:42
pues hay otra 00:00:44
estructura de for que mencionamos 00:00:46
en su momento que es más sencilla 00:00:48
que era esta 00:00:49
el for each que 00:00:52
es el for y ahora 00:00:53
¿Qué ponemos aquí? Ponemos el tipo de dato al que pertenece el array. En nuestro caso es profesor. Aquí un nombre de variable que yo no haya usado que me guste, pues p o prof o lo que sea. Y ahora aquí el array. Esta es otra estructura para recorrer una colección en general. Y un array en concreto es una colección. Ya veremos lo que es una colección, pero bueno, un array es un ejemplo concreto. 00:00:56
Bueno, pues esta es una estructura para recorrer un array también. ¿Y qué significa? Pues el for va recorriendo, va saltando por el array, por todas y cada una de las posiciones y en cada iteración la posición se queda guardada en prof. 00:01:25
Lo que haya en esa posición se queda guardado en prof 00:01:46
¿Vale? Entonces 00:01:48
En la primera iteración 00:01:51
Este prof de aquí 00:01:52
Tiene el profesor que está en la primera posición 00:01:54
En la segunda iteración 00:01:58
Tiene el que está en la segunda 00:02:00
Entonces si yo quiero hacer esto 00:02:01
Con for each 00:02:03
Sería esto 00:02:05
Sueldo medio más igual prof 00:02:06
Punto sueldo 00:02:12
Entonces el for de arriba 00:02:13
Y el for de abajo hacen lo mismo 00:02:16
Bueno, si yo vuelvo a inicializarlo a cero, claro 00:02:17
el for de arriba y el for de abajo 00:02:20
hacen lo mismo 00:02:25
este for va recorriendo 00:02:26
todas y cada una de las posiciones 00:02:31
del array que yo ponga aquí 00:02:33
después de los dos puntos 00:02:35
todas, desde el principio hasta el final 00:02:36
y en cada iteración 00:02:39
me mete al profesor 00:02:41
que esté en esa posición, me lo mete en esta variable 00:02:43
local que está creada aquí 00:02:45
y solo existe dentro de ese for 00:02:47
solo existe en ese for 00:02:49
¿vale? 00:02:51
Entonces, en la primera iteración 00:02:52
Prof es el primer profesor 00:02:55
En la segunda iteración 00:02:58
Prof es el segundo 00:03:01
En la tercera iteración 00:03:02
Prof es el tercero 00:03:04
Luego esta es una forma muy fácil 00:03:05
De escribir 00:03:08
Cómo recorrer un array 00:03:08
¿Vale? 00:03:11
Pero tiene dos pegas 00:03:13
Dos pegas 00:03:15
La buena 00:03:17
la mala y la peor 00:03:21
vale, la mala 00:03:24
que este for te recorre todo el array entero 00:03:26
sí o sí, desde el momento en que uno planta aquí este for 00:03:28
este for te recorre 00:03:30
este array entero de principio a fin 00:03:32
se hace todas las 00:03:34
iteraciones 00:03:36
solo habría una forma 00:03:36
de salir de este for 00:03:39
que es haciendo el bestia, pero el bestia 00:03:41
muy bestia 00:03:44
que es el bestia bestísimo 00:03:45
más bestia, que es poner un break 00:03:48
en medio de un bucle, cuando uno pone un break 00:03:50
en medio de un bucle, sales 00:03:52
entonces si yo hiciera aquí un if 00:03:54
con cualquier cosa 00:03:56
y no sé qué 00:03:58
y pongo aquí un break 00:03:59
yo estoy haciendo este for each 00:04:01
cuando esta condición se cumpliera 00:04:04
pam 00:04:06
ese bucle terminaría y yo saldría por aquí 00:04:07
sería la única forma 00:04:10
de que este bucle no 00:04:12
recorriera todas y cada una 00:04:14
de las posiciones 00:04:16
esa es la primera pega que tiene 00:04:17
sin embargo con el 00:04:20
for de índice 00:04:22
que llamamos el for de índice, tú aquí haces lo que te da la gana 00:04:24
que quieres empezar en la 00:04:27
quinta posición, pues empiezas 00:04:28
con igual a 4 y vas desde la quinta 00:04:30
que quieres 00:04:32
acabar 3 posiciones 00:04:34
antes, pues pones aquí menos 3 00:04:37
acabas 3 posiciones antes 00:04:38
que quieres ir de 2 en 2 00:04:40
me he perdido abajo, ¿qué has intentado? 00:04:42
¿qué he intentado? he intentado y he conseguido 00:04:44
¿qué has conseguido? 00:04:46
recorrer el array con otra sintaxis 00:04:47
que es la del for each 00:04:50
y estoy viendo la diferencia entre unas y otras 00:04:51
esta es la sentencia, el bucle for each 00:04:53
que te recorre este array entero 00:04:58
de principio a fin 00:05:00
y en cada iteración 00:05:01
lo que hay en una posición va aquí 00:05:03
entonces este no tiene libertad 00:05:06
es lo que decía 00:05:09
lo único que puedes hacer aquí es 00:05:10
poner un break 00:05:12
y en ese momento te sales del bucle 00:05:12
pero es lo más que puedes hacer 00:05:15
Si no, ese bucle se va a ejecutar de principio a fin, 00:05:17
todas las iteraciones, desde la primera hasta la última. 00:05:21
Entonces, un segundinín. 00:05:23
Sin embargo, con este puedes jugar y hacer lo que te dé la 00:05:25
gana. 00:05:27
Empezar donde quieras, saltarte los que te den la gana, 00:05:28
poner aquí un montón de condiciones para que salga la 00:05:32
mitad si procede. 00:05:34
Entonces, este for es el que te permite recorrer el array con 00:05:36
toda la libertad que tú quieras. 00:05:39
¿Vale? 00:05:41
Lo que pasa es que en este ejemplo concreto, así, 00:05:43
el de arriba y el de abajo 00:05:47
están haciendo lo mismo. 00:05:49
En esta situación correcta 00:05:50
están haciendo lo mismo, ¿vale? 00:05:51
Pero aún así hay una diferencia. 00:05:53
¿Qué le vamos a decir? 00:05:55
Dime. 00:05:55
¿Qué tiene de malo el break? 00:05:56
Pues que el código se hace más ilegible. 00:05:59
A ver, nosotros ahora mismo, 00:06:03
todo nuestro código está recogido en 20 líneas. 00:06:05
Entonces, tú ves un break 00:06:07
y rápidamente vas a encontrar 00:06:08
por qué el bucle tiene que interrumpir ahí. 00:06:10
Lo vas a encontrar en la línea más arriba, 00:06:13
lo que sea. 00:06:15
pero con bucles que te van llegando 00:06:15
cosas de una clase y de repente 00:06:17
ves un break y dices, ostras 00:06:19
¿por qué se interrumpe esto de repente? 00:06:21
para entender realmente el código 00:06:24
igual tienes que moverte muchas maneras más arriba 00:06:25
muchas maneras más abajo, entonces si tú 00:06:27
sales por condiciones, si tú 00:06:29
sales incorporándolo en el 00:06:31
propio bucle, es que dentro del bucle 00:06:33
del que sales, ya vas a estarlo viendo 00:06:35
sobre todo se hace 00:06:38
porque en general 00:06:39
facilita la legibilidad el que 00:06:40
no haya muchos break, es un tema 00:06:43
de elegancia, pero luego 00:06:45
al final pues se hacen muchos break y se hacen 00:06:47
continuos, que también es otra forma de saltarse 00:06:49
digamos que el break tiene 00:06:52
mala fama, porque 00:06:53
antes de la programación estructurada 00:06:55
con el basic y estas cosas 00:06:57
se podían 00:06:59
hacer los programas de forma que tú te ibas a 00:07:02
te daba la gana en cada momento 00:07:03
con la asistencia go to te ibas a donde querías 00:07:05
con la break salías 00:07:07
esos eran programas que hacían sus cosas 00:07:09
pero eran lo que se llamaba 00:07:11
desestructurados, entonces eran muy 00:07:13
legibles y muy difíciles 00:07:15
de mantener, cuando tú tienes en un código 00:07:18
un break y quieres cambiar la funcionalidad 00:07:19
es muy probable que tenga implicaciones 00:07:22
grandes en muchos sitios 00:07:24
entonces, se estructuró 00:07:25
todo y se dijo, a ver, no hace falta 00:07:27
no hacen falta ni los go to's 00:07:29
ni los break, ni nada 00:07:31
si tú tienes asignaciones a variables 00:07:32
decisiones y bucles 00:07:35
sin break, sin go to, ni nada, puedes hacer lo que quieras 00:07:36
combinando eso 00:07:39
entonces eso ya fue la programación estructurada 00:07:40
Entonces, ahí ya cogió mala prensa los break, porque era como arrastrar los malos hábitos de antes. Entonces, la idea es esa, que en general el abuso de los break puede hacer que el programa sea difícil de entender, a lo mejor. 00:07:43
pero es solamente esa la razón 00:07:59
pues en muchas ocasiones 00:08:01
es cómodo y está claro, pues se pone 00:08:04
y ya está, pero hombre, abusar de ellos 00:08:06
programar abusando de ellos 00:08:08
pues no tiene buena 00:08:10
no tiene buena prensa, ¿vale? 00:08:11
puede llegar un momento en que tu programa 00:08:14
está muy bien y que ha habido un montón de break 00:08:16
lo hereda otro 00:08:18
y esa persona ahora tiene que hacer una modificación 00:08:19
y tiene que hacer muchos más 00:08:22
cambios seguramente que si tú lo hubieras 00:08:24
estructurado de otra manera 00:08:26
vale 00:08:27
Bueno, pues entonces, la pega mala es esta primera que hemos dicho, que este lo recorre de principio a fin. Y no hay forma de salirte a la mitad si no es poniendo un break. Aquí te puedes salir a la mitad con una condición, puedes empezar cuando quieras, etc. Eso por un lado. Esa es la pega mala. 00:08:29
pero tiene otra que esa es la peor 00:08:49
que esa es la peor 00:08:51
que es 00:08:53
que este profesor es de i 00:08:55
es directamente 00:08:57
es directamente 00:08:59
la variable donde está la 00:09:01
que está en el array 00:09:02
directamente 00:09:04
pero esta es una copia 00:09:05
con lo cual vamos a ver que ocurriría 00:09:08
vamos a 00:09:11
claro, este bucle for 00:09:12
que hemos hecho aquí 00:09:15
que rellena los profesores 00:09:16
Vamos a hacer esto mismo 00:09:17
Porque según lo que yo he dicho 00:09:19
Ah, pues esto no lo podríamos hacer con un for each 00:09:21
Y nos quedamos tan anchos 00:09:23
Vamos a hacerlo con un for each, esto mismo de arriba 00:09:24
Rellenarlo 00:09:26
Pues para cada profesor 00:09:27
En profesores.le 00:09:31
Uy, que tontería estoy haciendo 00:09:35
En profesores 00:09:38
Vale 00:09:39
Vamos a hacer esto pero con 00:09:40
Con prof 00:09:42
Copio y pego esto 00:09:44
Y hacemos 00:09:46
Prof 00:09:53
Prof y prof 00:09:54
Vale, teóricamente 00:10:02
Hemos, bueno, aquí es que no puedo 00:10:04
Poner el i, pero le pongo algo aleatorio 00:10:06
Y se acabó, para que cambie los nombres 00:10:08
Math.random 00:10:10
Y aquí que 00:10:13
También concatene con 00:10:14
Math.random, y así me aseguro que los 00:10:16
Nombres y los nifs son distintos 00:10:18
Vale 00:10:20
Entonces 00:10:22
voy a quitar esto de aquí para ver el programa 00:10:24
o con otros hay diferencias 00:10:26
bueno, aquí todavía no he hecho nada 00:10:28
he hecho la media, vamos a mostrar la media 00:10:30
para que 00:10:32
es que tienes 00:10:35
los algoritmos de random casi todos 00:10:43
parten del 00:10:45
tiempo del sistema 00:10:47
porque ese es el único que es único 00:10:48
claro, tienes que mirar el reloj 00:10:50
claro, porque la aleatoriedad 00:10:53
no existe en programación, es imposible 00:10:59
claro, entonces 00:11:01
se simula, y la mejor 00:11:03
semilla para simularla es la hora del 00:11:05
sistema medida al segundo, porque esa es única 00:11:07
entonces hay diferentes algoritmos 00:11:09
para simularla, pero no es completamente aleatoria 00:11:11
entonces 00:11:13
claro 00:11:15
las lámparas de lava 00:11:17
si, hay una empresa de seguridad muy grande 00:11:18
que lo que tienen es a la entrada 00:11:21
un montón de lámparas de lava 00:11:23
y una cámara va captando 00:11:25
las posiciones de las figuras que hace 00:11:27
y va generando las contraseñas a base de eso. 00:11:32
Eso es efectivamente bastante más aleatorio 00:11:35
que la obra del sistema, lógicamente. 00:11:37
Claro que sí. 00:11:39
Claro, es que encontrar... 00:11:40
Venga, entonces, seguimos. 00:11:48
Vale. 00:11:54
A ver, hacedme caso que esto es muy interesante 00:11:54
No os despistéis 00:11:58
Vale 00:12:00
Aquí 00:12:01
Pero si esto es lo de antes 00:12:02
Vale, vamos a volver a 00:12:05
Ejecutar este programa 00:12:10
Vamos a revisar que tenía este programa 00:12:12
Que nadie esté perdido, ni se pierda 00:12:14
¿Tú estás perdido? 00:12:15
Ah, es que me miras con cara de qué coñazo me está soltando esta tía 00:12:17
Es que le he leído los labios 00:12:20
Bueno 00:12:24
Pero al menos 00:12:25
Mastica escondido detrás de la pantalla 00:12:28
Que yo no te vea 00:12:31
No sé si están prohibidos 00:12:32
Pero bueno 00:12:35
Siempre será mejor que 00:12:36
Vale, el chicle lo pasamos por alto 00:12:37
Creo que no están las normas de aula 00:12:40
La comida sí 00:12:41
Venga, a ver, seguimos 00:12:41
Vamos a revisar este programa 00:12:44
Que hace parte grave 00:12:46
A ver 00:12:50
Habíamos hecho 00:12:51
un array de 100 profesores 00:12:52
venga, 100, a lo bestia 00:12:55
lo rellenamos con un for 00:12:56
de toda la vida 00:12:59
vale, entonces, este lo vamos a comentar 00:13:00
porque ahora vamos a hacer este mismo programa 00:13:03
pero usando el for each 00:13:05
con lo que yo he dicho, esto y esto es lo mismo 00:13:06
¿no? esto va haciendo iteraciones 00:13:09
una tras otra 00:13:11
va una tras otra profesores, en cada iteración 00:13:12
cada posición del array 00:13:15
se carga aquí 00:13:17
en cada iteración, cada 00:13:18
posición de la raíz se carga aquí 00:13:21
con lo cual lo de arriba 00:13:22
y lo de abajo es lo mismo 00:13:25
me da igual profesores de i 00:13:27
empezando con i igual a cero 00:13:28
y acabando al final yendo de uno en uno 00:13:30
me da igual que esto 00:13:32
vale, pues entonces vamos a cambiarlo 00:13:34
para hacerlo de esa otra manera 00:13:37
vale, rellenamos los profesores 00:13:40
y ahora ya hacemos todo lo que 00:13:43
teníamos que hacer, ya los tenemos rellenos 00:13:45
pues vamos a mostrar los datos 00:13:47
que tenía, que lo mostrábamos aquí 00:13:49
vamos a ver el que más gana con el sueldo máximo 00:13:50
y luego aquí además 00:13:53
hemos incorporado la media de dos 00:13:55
bueno, esto ya lo probamos el otro día 00:13:56
y bien, y nos hizo el máximo y todo estupendo 00:13:58
¿vale? rellenando con esto 00:14:01
pues vamos a hacer ahora la misma prueba 00:14:03
en la que hemos cambiado a este otro for 00:14:05
que teóricamente es lo mismo 00:14:06
venga 00:14:09
ala 00:14:11
directamente 00:14:17
teóricamente hemos hecho lo mismo 00:14:18
y si vosotros no tuvierais la suerte 00:14:22
de que yo fuera a explicar ahora la diferencia 00:14:24
entre el for it y el for the índice 00:14:27
pues cometeréis errores muchas veces en vuestra vida 00:14:28
y este es el que más sale 00:14:31
el null pointer exception 00:14:33
null pointer exception 00:14:34
un objeto nulo 00:14:37
¿dónde me está saliendo objeto nulo? 00:14:38
pues cuando intentas recorrer el array 00:14:41
para mostrarlo, pero ¿cómo que null pointer exception? 00:14:43
o sea, lo que me está diciendo la excepción 00:14:46
es, si la leemos bien 00:14:47
claro, me está diciendo 00:14:49
no puedo leer la propiedad 00:14:51
nombre porque profesores de i es 00:14:53
null 00:14:55
entonces efectivamente 00:14:56
pinchamos ahí, pero como va a ser 00:14:59
profesores de i null, si yo he rellenado 00:15:01
el array, he rellenado el array 00:15:04
claro, pero como ha funcionado 00:15:05
como funciona el for each 00:15:07
pues el for each funciona, vamos a ver 00:15:09
si ahora nos sale un paint 00:15:11
vamos a ver si nos sale un paint tan estupendo 00:15:13
como el del otro día 00:15:15
ay cuando lleguen las pizarras 00:15:16
digitales que feliz voy a ser 00:15:19
bueno 00:15:20
a ver, ¿qué hace el for each? 00:15:22
importante que lo entendáis 00:15:25
a ver, el caso 00:15:27
es que yo juraría que tengo una en casa guardada 00:15:31
de cuando el confinamiento 00:15:33
la voy a buscar 00:15:35
y os vais a cagar 00:15:35
entonces ya sí que 00:15:39
vale, este es nuestro array 00:15:40
vale, ¿qué hace el for each? 00:15:45
pues cuando el for each arranca 00:15:48
¿el qué hace? 00:15:49
se crea una variable local 00:15:50
a la que llama prof 00:15:53
como hayamos puesto aquí 00:15:55
en nuestro caso a la que llama prof 00:15:56
a esta, y a esta variable local 00:15:58
la llama prof, vale 00:16:01
y ahora, en cada iteración 00:16:06
del for each, en cada iteración 00:16:09
de estas, vale 00:16:11
pues que hace el for each, en cada iteración 00:16:26
de esta, mete en esta variable 00:16:28
prof local suya que se ha creado 00:16:30
mete una copia 00:16:32
de lo que hay aquí. Mete una copia. 00:16:33
¿Qué había aquí en este 00:16:37
array cuando lo hemos creado al principio? 00:16:38
Cuando este array lo hemos creado 00:16:40
al principio, lo único que había aquí 00:16:42
era un montón de nules. 00:16:44
Vale. Había un montón 00:16:46
de nules ahí. 00:16:48
Vale. Todo esto iba a nul. 00:16:50
Sí. 00:16:54
Sí. 00:16:55
Sí está triste. 00:16:59
Espera, espérate. 00:17:04
Escucha todo lo que estoy diciendo porque es importante 00:17:05
Vale, entonces teníamos 00:17:07
Este array que iba a null 00:17:09
Pues que ha hecho este for 00:17:11
Ha cogido este array 00:17:13
En cada iteración 00:17:15
Se ha llevado una copia, con lo cual al llevarse 00:17:17
Una copia, esto sigue apuntando 00:17:19
A null, vale, sigue apuntando a null 00:17:21
Hasta ahí está claro, luego que ha 00:17:23
Hecho, que hemos hecho después 00:17:25
Aquí 00:17:27
Ha creado un nuevo objeto 00:17:28
Vale, ha creado un nuevo objeto 00:17:30
Lo ha dejado 00:17:33
apuntando ese nuevo objeto que ha creado 00:17:36
por la variable prof 00:17:38
es decir, lo ha dejado apuntando por esta 00:17:40
conclusión 00:17:43
el nuevo objeto se ha quedado en prof 00:17:46
el array no se ha enterado de nada 00:17:48
el nuevo objeto se ha quedado en prof 00:17:49
siguiente iteración del for each 00:17:51
ha creado otro objeto 00:17:54
lo ha dejado apuntando por prof 00:17:56
y la ha desaparecido 00:17:57
claro 00:17:58
porque está trabajando con la copia 00:18:00
con lo cual, cuando consultamos 00:18:04
para consultar 00:18:06
no hay problema, porque cuando el objeto ya existe 00:18:08
claro, cuando el objeto ya existe 00:18:11
me da igual llegar a él 00:18:13
desde la copia 00:18:14
que desde aquí, que desde la RAI 00:18:16
me da lo mismo, cuando el objeto ya existe 00:18:19
me da igual acceder por profesores de I 00:18:21
que será este, que por prof que será este 00:18:22
pero cuando ya existe 00:18:25
ya, pero es muy cómodo 00:18:27
describirlo otro, y lo vais a ver 00:18:29
mucho, ¿vale? 00:18:31
entonces cuando solo vais a consultar 00:18:34
El forEach es lo más cómodo porque me da igual consultar desde profesores de I que consultar desde la copia. 00:18:36
Pero cuando vamos a cambiar el objeto del array, vamos a cambiarlo, si lo cambiamos, solo lo cambiamos en prof. 00:18:41
El array no se ha enterado de nada. 00:18:49
Entonces, por eso, cuando después de haber hecho este forEach, hemos tratado de hacer a profesores de I, este profesores de I seguía teniendo null. 00:18:52
Bueno, pues cuidado con el foreach 00:19:00
Porque se usa continuamente, porque es muy cómodo 00:19:04
Pero si lo que hay dentro 00:19:06
Cambia a donde 00:19:08
Apunte profesores de i 00:19:10
Porque crea un objeto nuevo 00:19:11
O porque lo lleva a apuntar a otro, por lo que sea 00:19:13
El i menor que el array 00:19:15
También es muy cómodo 00:19:18
Ya, ya, bueno 00:19:19
Vale, pero 00:19:22
Sí, porque 00:19:23
Sí 00:19:25
Porque además para colecciones, de hecho 00:19:26
Para conjuntos 00:19:29
El for de índice no lo podrías usar 00:19:31
Entonces más o menos es un hábito 00:19:33
Vale, conclusión 00:19:34
Nunca jamás utilizaríamos 00:19:36
Esto jamás 00:19:38
Jamás 00:19:40
Y además entendéis por qué 00:19:42
Que es lo que importa 00:19:46
Vale, pues esto ya se queda comentado 00:19:47
Y esta parte de rellenar 00:19:49
Sí que nos importa 00:19:52
A mí esa parte me da error 00:19:53
Pero si esta es del otro día 00:19:56
No te puede dar error 00:19:59
Venga 00:20:00
no pasa nada 00:20:00
tú como eres hombre puedes hacer dos cosas a la vez 00:20:04
y según vamos explicando tú vas encontrando tu error 00:20:06
venga 00:20:09
vale pues entonces 00:20:10
estábamos con el 00:20:12
estábamos con el sueldo 00:20:14
medio y subir 00:20:17
vale pues el sueldo medio 00:20:18
este si lo hacemos sin miedo con un for each 00:20:19
porque aquí lo único que hacemos es acceder a los datos 00:20:22
del objeto 00:20:24
pues esto lo hacemos con un for each 00:20:25
con lo cual esto de aquí 00:20:28
ya hasta lo borro directamente. Lo hacemos 00:20:30
con un for each y ya está, porque solamente estamos haciendo 00:20:32
los datos, ¿vale? Y a todos 00:20:34
además, luego. Y ahora 00:20:36
ya, ¿qué teníamos que hacer aquí? 00:20:38
Pues ahora ya subir el sueldo a los 00:20:40
que tuvieran menos de la media. Pues 00:20:42
venga, pues vamos a 00:20:44
hacer eso y ya está. 00:20:46
Aquí de nuevo, 00:20:48
el objeto no lo muevo de sitio, 00:20:50
solamente haced a los datos, con lo cual puede ir 00:20:52
a un for each, no pasa nada. 00:20:54
Y además voy a... 00:20:56
Está volviendo a rellenar el sueldo. 00:20:58
sí, pero el objeto 00:21:00
que ya está creado 00:21:02
este, entonces me da igual apuntarlo desde aquí 00:21:04
que desde aquí, lo que estoy cambiando 00:21:07
es lo que va aquí dentro, pero no estoy 00:21:08
moviendo el objeto de un sitio a otro 00:21:10
claro, porque 00:21:12
el problema es cuando este objeto se 00:21:18
mueve a otra dirección de memoria 00:21:20
¿vale? como cuando creas 00:21:22
uno nuevo, claro, porque inicialmente 00:21:24
es nul, al crear otro es otra dirección, que no es 00:21:26
la nul. O si le hicieras a 00:21:28
profesores de i, le asignaras otro objeto diferente. 00:21:30
Profesores de z. Pues 00:21:33
ese se asignaría a este. Cuando 00:21:34
cambias la dirección donde está 00:21:36
el objeto. Pero aquí estamos cambiando los valores. 00:21:38
El objeto sigue ahí colocado. Entonces 00:21:40
me da igual acceder desde aquí que acceder desde aquí. 00:21:42
Llego a los mismos valores y la 00:21:45
modificación se queda ahí. ¿Vale? 00:21:46
Vale, pues entonces 00:21:49
para cada profesor en 00:21:50
profesores, ¿qué hacemos? 00:21:54
Pues ya está. Ponemos 00:21:57
las llavecitas, si el sueldo 00:21:58
de prof, entonces 00:22:01
su sueldo es 00:22:02
menor que el sueldo 00:22:04
medio 00:22:06
pues le subimos un 10% 00:22:07
que era 00:22:11
prof.sueldo 00:22:11
más 00:22:16
por igual 00:22:16
por igual 1,1 00:22:18
1,1 00:22:22
y ya está 00:22:27
He subido el sueldo el 10% 00:22:28
A todos los que ganan menos de la media 00:22:30
Vamos a mostrar 00:22:33
Los nuevos sueldos 00:22:35
Pues venga 00:22:36
Copio el for en el que tenía 00:22:37
Los nombres y los sueldos 00:22:41
Pues este mismo for 00:22:48
Vale 00:22:51
Y en lugar de 100 voy a poner 00:22:56
10 para verlo 00:22:58
Que si no no vemos nada 00:23:00
Vale 00:23:02
Vale pues ya está 00:23:04
Los 10 pepitos 00:23:07
Estos son sus sueldos 00:23:11
El que más gana es el 6 00:23:13
Que gana casi 1000 euros 00:23:14
Casi, casi 00:23:17
Y ahora ya nos han subido 00:23:18
Un 10% a todos 00:23:21
Ah no, a todos no, a los que ganan menos de la media 00:23:22
Al pepito 6 que ganaba tantísimo 00:23:26
No le han subido nada 00:23:28
Pero si le han subido 00:23:28
Pues al 9 00:23:30
Que ganaba menos, pues si le han subido 00:23:33
bueno, pues todo no funciona 00:23:35
y todo bien 00:23:38
¿hasta dónde lo muestro? 00:23:39
sí, luego después al final, claro 00:23:56
¿qué? 00:23:58
¿a dónde hay que subir y bajar? 00:24:06
a ver, aquí 00:24:08
de primeras 00:24:09
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:
15
Fecha:
2 de diciembre de 2024 - 19:48
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′ 12″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
104.32 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid