Bloque 2. Conceptos de Programación - Tutorial 4 Paso de referencias

00:07:30
https://www.youtube.com/watch?v=rwGudEnxPEE

摘要

TLDRO vídeo explica o concepto de referencias en programación, utilizando o exemplo dun elevador que ten un peso máximo e capacidade. As referencias son direccións de memoria que apuntan a un obxecto na memoria. O vídeo mostra como dúas referencias poden apuntar ao mesmo obxecto e como calquera modificación a través dunha referencia afecta a todas as referencias que apuntan a ese obxecto. É importante entender este concepto para evitar problemas no código, especialmente cando se traballa con datos compartidos.

心得

  • 📝 As referencias son direccións de memoria que apuntan a obxectos.
  • 🔄 Modificar un obxecto a través dunha referencia afecta a todas as referencias.
  • 📊 O exemplo do elevador ilustra como funcionan as referencias.
  • 💡 É importante entender as referencias para evitar problemas no código.
  • 🔍 As referencias permiten compartir datos entre diferentes partes do código.

时间轴

  • 00:00:00 - 00:07:30

    Neste vídeo, aprendemos sobre referencias que surxen do acceso a datos, utilizando o exemplo dun elevador. O elevador chico ten un peso máximo de 400 e unha capacidade de cinco persoas. As referencias apuntan a obxectos na memoria, e ao imprimir o elevador, vemos que se mostra como unha referencia en lugar do obxecto en si. A continuación, creamos outra referencia chamada 'outro elevador' que apunta ao mesmo obxecto que 'elevador chico'. Ao modificar a capacidade máxima de 'elevador chico', tamén se modifica 'outro elevador', demostrando que ambas referencias apuntan á mesma dirección de memoria. Este concepto é crucial para evitar problemas ao modificar datos que son compartidos entre diferentes referencias.

思维导图

视频问答

  • ¿Qué son las referencias en programación?

    Las referencias son direcciones de memoria que apuntan a un objeto en la memoria.

  • ¿Qué sucede al modificar un objeto referenciado?

    Si se modifica un objeto a través de una referencia, el cambio se refleja en todas las referencias que apuntan a ese objeto.

  • ¿Cómo se crean referencias en código?

    Se puede crear una referencia asignando una variable a otra que ya apunta a un objeto existente.

  • ¿Qué es la memoria RAM en este contexto?

    La memoria RAM es donde se almacena la información y los objetos en programación.

  • ¿Por qué es importante entender las referencias?

    Entender las referencias es crucial para evitar errores al modificar datos que son compartidos entre diferentes partes del código.

查看更多视频摘要

即时访问由人工智能支持的免费 YouTube 视频摘要！
字幕
es
自动滚动:
  • 00:00:01
    Hola en esta ocasión aprenderemos sobre
  • 00:00:04
    las referencias las cuales surgen del
  • 00:00:07
    acceso a los datos Pues bien si
  • 00:00:10
    recordamos en los videos anteriores
  • 00:00:12
    creamos un elevador
  • 00:00:14
    chico que alude a un lado del cúmulo
  • 00:00:17
    parte de la memoria RAM donde se halla
  • 00:00:19
    toda la información ahí encontramos que
  • 00:00:22
    su peso máximo es de 400 y su capacidad
  • 00:00:25
    máxima es de cinco
  • 00:00:27
    personas como habíamos visto en el
  • 00:00:30
    contenido el elevador chico la
  • 00:00:32
    definición el alias o referencia están
  • 00:00:35
    en la
  • 00:00:37
    pila parte pequeña donde solo se asignan
  • 00:00:40
    direcciones de memoria que apuntan hacia
  • 00:00:43
    el verdadero objeto que se encuentra en
  • 00:00:45
    el cúmulo hay mucho espacio para crear
  • 00:00:47
    objetos Por consiguiente tiene que haber
  • 00:00:50
    este tipo de referencia yo apunto hacia
  • 00:00:53
    donde está él ahora veámoslo en código
  • 00:00:57
    hasta ahora hemos impreso sus valores
  • 00:00:59
    Pero qué pasa si imprimimos
  • 00:01:02
    elevador para esto primero comentemos
  • 00:01:05
    toda esta
  • 00:01:10
    parte solo dejemos la definición de
  • 00:01:13
    elevador
  • 00:01:15
    chico como vemos solo nos quedó sin
  • 00:01:18
    comentarios esta parte que es la
  • 00:01:20
    instrucción que crea un
  • 00:01:23
    elevador por lo que si la ejecutamos no
  • 00:01:26
    ocurre nada porque simplemente creé más
  • 00:01:29
    no imprimí sus elementos ni se hizo nada
  • 00:01:32
    con el elevador Ahora sí imprimamos el
  • 00:01:37
    elevador System punto out punto
  • 00:01:42
    printline
  • 00:01:46
    paréntesis y aquí copiamos y pegamos
  • 00:01:49
    elevador
  • 00:01:53
    chico
  • 00:01:55
    imprimimos y nos muestra en la primera
  • 00:01:57
    parte que es de tipo elevador la roba
  • 00:02:00
    indica que es una parte de la memoria y
  • 00:02:03
    la memoria nos lo da en
  • 00:02:05
    hexadecimal por lo que no se sabe por la
  • 00:02:08
    estructura de la computadora Dónde está
  • 00:02:10
    almacenado el
  • 00:02:12
    objeto pero sí sabemos que esto no es el
  • 00:02:15
    objeto de lo contrario nos tendría que
  • 00:02:17
    imprimir su información sino solo es una
  • 00:02:21
    referencia al
  • 00:02:23
    objeto ahora veamos un ejemplo de estas
  • 00:02:26
    referencias con otra imagen como vemos
  • 00:02:29
    podemos crear dos referencias que
  • 00:02:31
    apunten hacia el mismo objeto aquí
  • 00:02:33
    tenemos una referencia que se llama
  • 00:02:35
    elevador chico y otra que se llama otro
  • 00:02:42
    elevador pero ambas se dirigen a este
  • 00:02:45
    objeto por lo que si cambio algún dato
  • 00:02:48
    en otro elevador también se va a cambiar
  • 00:02:50
    de este lado por lo tanto cuando el
  • 00:02:52
    sistema quiere acceder a algo del objeto
  • 00:02:55
    este ya estará cambiado veamos expresado
  • 00:02:58
    esto en código creemos otro elevador que
  • 00:03:01
    será de tipo elevador y cuyo nombre será
  • 00:03:04
    otro elevador aquí no vamos a utilizar
  • 00:03:07
    el operador New porque no queremos crear
  • 00:03:09
    otro objeto no queremos reservar otro
  • 00:03:12
    espacio en la memoria sino queremos
  • 00:03:14
    irnos al que ya está
  • 00:03:23
    reservado por lo que aquí otro elevador
  • 00:03:26
    va a ser igual a elevador chico y
  • 00:03:28
    terminamos con punto
  • 00:03:32
    coma Entonces tenemos aquí ya elevador
  • 00:03:36
    chico e imprimimos otro
  • 00:03:38
    elevador ahora ejecutemos si vemos estos
  • 00:03:42
    dos son lo mismo quiere decir que están
  • 00:03:45
    apuntando a la misma dirección de
  • 00:03:46
    memoria y como vemos en la imagen así
  • 00:03:51
    es ahora veamos cómo se comporta
  • 00:03:56
    esto si escribimos System punto out
  • 00:04:00
    punto
  • 00:04:09
    printline peso elevador
  • 00:04:14
    chico y en la parte de abajo imprimimos
  • 00:04:17
    lo de otro
  • 00:04:27
    elevador en ambos vamos a imprimir la
  • 00:04:30
    capacidad máxima de
  • 00:04:36
    personas y pongamos el signo de más para
  • 00:04:40
    concatenar finalmente
  • 00:04:43
    imprimimos si nos damos cuenta el peso
  • 00:04:45
    es de cinco en los dos casos eliminamos
  • 00:04:48
    esto para que no nos muestre la
  • 00:04:49
    dirección ya que no nos interesa Por el
  • 00:04:51
    momento ejecutamos y aparece nuevamente
  • 00:04:54
    el cco ahora bien Si queremos cambiar
  • 00:04:57
    ese cco realizamos lo siguiente
  • 00:05:00
    elevador chico punto capacidad máxima de
  • 00:05:03
    personas igual a y es aquí donde vamos a
  • 00:05:07
    modificarlo lo podemos hacer tal como
  • 00:05:09
    modificamos cualquier
  • 00:05:15
    variable si nos damos cuenta aquí ya
  • 00:05:18
    estamos accediendo directamente a este
  • 00:05:20
    elemento por lo que podemos poner aquí
  • 00:05:22
    igual a 7 sin embargo nosotros no lo
  • 00:05:26
    haremos directamente en la clase por lo
  • 00:05:28
    que la modificación la harem en el
  • 00:05:29
    objeto y ahora sí escribimos igual a
  • 00:05:35
    7 con esto hemos accedido para
  • 00:05:38
    modificarlo por lo que la capacidad
  • 00:05:40
    máxima de personas ya no es cinco sino
  • 00:05:43
    es
  • 00:05:46
    siete imprimamos nuevamente esta
  • 00:05:48
    capacidad máxima del elevador chico
  • 00:05:51
    ejecutemos si vemos antes era cco del
  • 00:05:55
    otro elevador es c y ahora es si Pero
  • 00:05:59
    qué qu pasa con otro elevador Al momento
  • 00:06:01
    de modificar elevador
  • 00:06:02
    chico imprimamos también el otro
  • 00:06:05
    elevador y ejecutemos
  • 00:06:08
    observemos que antes de que se
  • 00:06:10
    modificara el dato valía cinco
  • 00:06:13
    modificamos solo el dato de elevador
  • 00:06:15
    chico por lo que para elevador chico y
  • 00:06:18
    para otro elevador el valor ya es
  • 00:06:27
    siete Por qué ocurrió esto porque como
  • 00:06:30
    explicamos previamente al Modificar el
  • 00:06:32
    cinco por el siete cuando quisimos
  • 00:06:34
    acceder por medio de otro elevador este
  • 00:06:37
    valor ya no era cinco sino
  • 00:06:47
    siete Así es como actúa la referencia
  • 00:06:50
    pues aunque tenemos dos elementos
  • 00:06:52
    diferentes en el alias otro elevador y
  • 00:06:55
    elevador chico ambos están apuntando al
  • 00:06:57
    mismo objeto que es el elevador en la
  • 00:07:00
    memoria por lo que si modificamos aquí
  • 00:07:03
    se va a modificar en cualquier objeto
  • 00:07:05
    que apunte al
  • 00:07:09
    mismo Hemos llegado al final de este
  • 00:07:11
    video en el que se explicó Cómo se
  • 00:07:13
    trabajan las referencias esto debemos
  • 00:07:16
    tenerlo muy claro dado que si
  • 00:07:18
    modificamos una parte de los datos Y no
  • 00:07:20
    contemplamos que tenemos otro objeto que
  • 00:07:22
    apunte a lo mismo puede causarnos
  • 00:07:25
    problemas continuamos con el
  • 00:07:28
    curso y
标签
  • referencias
  • programación
  • memoria
  • elevador
  • código
  • modificación
  • objetos
  • pila
  • cúmulo
  • errores