1
00:00:00,880 --> 00:00:06,820
Bien vamos a continuar con esta elección de clase Object ahora lo que vamos a hacer es crear una nueva

2
00:00:06,820 --> 00:00:09,590
clase sobre los packages.

3
00:00:09,600 --> 00:00:18,100
Vamos a dar clic derecho neo Java class el nombre de la clase va a ser clase Object y la depositamos

4
00:00:18,220 --> 00:00:24,290
en el paquete de test y damos siguen finalizar quitamos estos comentarios con controlé

5
00:00:27,250 --> 00:00:33,490
ampliamos esta clase y vamos a crear un método main public void main tabulador y ahora vamos a crear

6
00:00:33,550 --> 00:00:39,370
dos objetos de tipo empleado los cuales vamos a comparar utilizando un método que vamos a crear comparar

7
00:00:39,370 --> 00:00:44,490
objetos así que vamos a crear dos variables empleado 1

8
00:00:49,470 --> 00:00:56,210
le asignamos el valor de Juan y el sueldo de 10000

9
00:00:58,950 --> 00:01:03,370
importamos esta clase y ahora

10
00:01:06,550 --> 00:01:16,600
creamos otra variable llamada empleado 2 en 2 y de momento vamos a asignarle los mismos valores

11
00:01:20,340 --> 00:01:23,870
pero debido a que estamos utilizando dos veces la palabra reservada Anneo.

12
00:01:23,890 --> 00:01:29,230
Esto quiere decir que estos objetos se encuentran en diferente posición en memoria.

13
00:01:29,230 --> 00:01:33,120
Vamos a comparar esto vamos a mandar a imprimir cada una de estas variables

14
00:01:38,860 --> 00:01:44,320
así que mandamos imprimir el empleado 1 y el empleado 2 bien así que guardamos cambios y ejecutamos

15
00:01:54,450 --> 00:01:59,690
y podemos observar qué nos está imprimiendo el empleado 1 y el empleado 2.

16
00:01:59,740 --> 00:02:05,740
Sin embargo en este caso como los valores de los dos objetos contienen los mismos elementos es decir

17
00:02:05,740 --> 00:02:10,750
el nombre de Juan y el suelo de 10 000 podemos observar que el valor de Skout se genera a partir de

18
00:02:10,750 --> 00:02:16,240
los valores que contiene cada uno de los atributos del objeto en este caso del objeto empleado.

19
00:02:16,240 --> 00:02:22,540
Por lo tanto el valor de Ascot es igual en ambos objetos.

20
00:02:22,540 --> 00:02:27,580
Sin embargo en este punto cabe mencionar que esto no significa que sea la misma dirección de memoria.

21
00:02:27,670 --> 00:02:31,410
Estos objetos son distintos cómo podemos comprobar esto.

22
00:02:31,510 --> 00:02:36,540
Podemos comprobarlo de varias maneras la primera y más simple

23
00:02:40,980 --> 00:02:44,030
es preguntando por la referencia de los objetos.

24
00:02:44,370 --> 00:02:53,180
Vamos a preguntar si la variable 1 tiene la misma ubicación de memoria que el objeto 2 recordemos que

25
00:02:53,180 --> 00:02:58,970
si estas variables apuntan a un objeto entonces el operador igual igual va a preguntar por la referencia

26
00:02:59,150 --> 00:03:04,940
de estos objetos no por el contenido de los objetos así que guardamos cambios ejecutamos

27
00:03:07,550 --> 00:03:11,780
y podemos observar que esta comprobación nos regresa falso.

28
00:03:12,090 --> 00:03:14,840
Así que de esta manera podemos saber que no son iguales.

29
00:03:14,850 --> 00:03:22,370
Estos objetos apuntan a diferentes referencias en memoria otra forma de saber si están apuntando a la

30
00:03:22,370 --> 00:03:29,760
misma referencia ponemos un punto de ruptura damos clic derecho damos clic en Facebook File

31
00:03:33,920 --> 00:03:42,140
presionamos F8 para que se cree este objeto el objeto 1 y entonces la variable en 1 apunta al objeto

32
00:03:42,170 --> 00:03:48,350
en memoria podemos observar que en este caso el élide nos da el valor de 128 así que ese es el valor

33
00:03:48,350 --> 00:03:50,010
que nos proporciona el líder.

34
00:03:50,030 --> 00:03:54,770
Simplemente es una simplificación del valor de la referencia en memoria.

35
00:03:54,770 --> 00:04:01,630
Ahora si creamos el segundo objeto presionamos F8 podemos observar que está apuntando a un diferente

36
00:04:01,630 --> 00:04:02,970
lugar en memoria.

37
00:04:03,100 --> 00:04:09,430
En este caso está apuntando al número 295 y por lo tanto cuando preguntamos si estos objetos apuntan

38
00:04:09,460 --> 00:04:15,310
a la misma referencia en memoria podemos observar que eso nos va a regresar falso ya que los objetos

39
00:04:15,340 --> 00:04:21,400
están apuntando a diferentes lugares memoria así que esa es otra forma de saber si tenemos la misma

40
00:04:21,400 --> 00:04:25,520
referencia en memoria de un objeto o no y hay una tercera manera.

41
00:04:25,610 --> 00:04:30,790
Esa tercer manera lo voy a agregar en este video pero no es necesario que ustedes lo realicen únicamente

42
00:04:30,820 --> 00:04:35,330
para que puedan observar la referencia en memoria real de cada uno de los objetos.

43
00:04:35,350 --> 00:04:41,080
Sin embargo esto podría ser diferente entre cada plataforma e incluso podría no funcionar así que solamente

44
00:04:41,080 --> 00:04:46,600
voy a mostrar cómo hacerlo pero no es necesario que ustedes realicen estos pasos bien para saber la

45
00:04:46,600 --> 00:04:48,520
referencia en memoria de un objeto.

46
00:04:48,520 --> 00:04:53,210
Podemos utilizar una librería así que abrimos nuestro archivo de XML.

47
00:04:53,230 --> 00:05:00,950
Vamos a agregar una librería más a nuestro proyecto para esto vamos a agregar el tag de dependencias

48
00:05:02,190 --> 00:05:04,210
contra el espacio.

49
00:05:04,340 --> 00:05:09,410
Para completar este Tag y posteriormente vamos a agregar una dependencia

50
00:05:12,380 --> 00:05:14,930
el espacio para completar este tag de dependencia

51
00:05:17,880 --> 00:05:28,510
vamos a agregar una etiqueta de GRUB Heydi y el nombre del proyecto se llama ORF Open JDK punto J O

52
00:05:28,600 --> 00:05:29,870
L.

53
00:05:29,870 --> 00:05:36,360
Ese es el nombre del proyecto que permite averiguar cuál es la referencia en memoria de un objeto.

54
00:05:36,520 --> 00:05:45,320
Posteriormente agregamos el artefacto J O L en medio Kor y finalmente agregamos la versión en este caso

55
00:05:45,330 --> 00:05:52,710
la versión más reciente es la 0.9 así que seleccionamos esta versión y para descargar esta librería

56
00:05:53,250 --> 00:06:00,010
damos clic derecho sobre nuestro proyecto y hacemos clic cambio no debería haber ningún software que

57
00:06:00,010 --> 00:06:02,410
detenga la descarga de este tipo de archivos.

58
00:06:02,500 --> 00:06:07,060
De lo contrario primero hay que deshabilitar el software de seguridad y posteriormente hacer esta descarga

59
00:06:07,060 --> 00:06:08,060
de esta librería.

60
00:06:08,230 --> 00:06:13,630
Pero como les comento este paso es opcional ustedes no tienen que hacerlo solamente para que vean cuál

61
00:06:13,630 --> 00:06:16,470
es la dirección en memoria de estos objetos.

62
00:06:16,600 --> 00:06:24,580
Una vez que ya hemos importado esa librería entonces podemos agregar el siguiente código vamos a imprimir

63
00:06:27,920 --> 00:06:34,130
la dirección de memoria del empleado 1 y para ello vamos a utilizar algunas clases del paquete que acabamos

64
00:06:34,130 --> 00:06:35,120
de importar.

65
00:06:35,120 --> 00:06:42,370
Utilizamos la clase B.M. de Virtual Machine posteriormente mandamos a llamar al método current podemos

66
00:06:42,370 --> 00:06:49,310
observar que ya se importó en automático esta clase y posteriormente del método current.

67
00:06:49,310 --> 00:06:51,740
Mandamos a llamar al método address of

68
00:06:55,180 --> 00:07:01,120
y lo que recibe como parámetro es un objeto y nos regresa la referencia en memoria de este objeto así

69
00:07:01,120 --> 00:07:03,070
que guardamos cambios ejecutamos

70
00:07:08,690 --> 00:07:13,520
aunque nos marca este Guarne y vamos a ignorarlo ya que únicamente nos interesa el número de referencia

71
00:07:13,520 --> 00:07:19,010
de este objeto y podemos observar que nos muestra el número de referencia que estamos observando con

72
00:07:19,010 --> 00:07:20,360
terminación 32

73
00:07:22,990 --> 00:07:26,070
y vamos a ser esto mismo para el objeto empleado dos

74
00:07:37,810 --> 00:07:39,760
así que guardamos cambios y ejecutamos.

75
00:07:39,820 --> 00:07:44,350
Ya estamos solicitando a la dirección de memoria del empleado 1 y la dirección de memoria del objeto

76
00:07:44,350 --> 00:07:48,310
que está apuntando la variable empleado 2 guardamos cambios ejecutamos

77
00:07:52,570 --> 00:07:54,860
y podemos observar la referencia en memoria.

78
00:07:54,860 --> 00:08:02,120
En este caso y a cambio termina en 40 y en el segundo caso en el empleado 2 termina en 24 así que son

79
00:08:02,120 --> 00:08:05,590
diferentes posiciones en memoria de cada uno de estos objetos.

80
00:08:05,690 --> 00:08:11,960
Así que con esto podemos observar que el Método Scout que estábamos imprimiendo y que comentábamos anteriormente

81
00:08:12,100 --> 00:08:18,440
que era la referencia en memoria realmente es el valor Skout generado para este objeto a partir de los

82
00:08:18,440 --> 00:08:20,660
valores que contiene cada uno de sus atributos.

83
00:08:20,660 --> 00:08:26,120
Por ello ahora podemos aclarar que este número es únicamente una referencia del objeto pero si contiene

84
00:08:26,120 --> 00:08:31,640
los mismos valores que otro objeto entonces estos números de Jacob van a ser idénticos.

85
00:08:31,640 --> 00:08:35,750
Por lo tanto tenemos que averiguar de otras maneras si realmente queremos saber cuál es la referencia

86
00:08:35,780 --> 00:08:41,180
en memoria y así saber si están apuntando a la misma referencia en memoria pero siempre que utilicemos

87
00:08:41,180 --> 00:08:45,060
la palabra reservada Niu entonces va a crear un nuevo objeto en memoria.

88
00:08:45,140 --> 00:08:50,930
Por lo tanto esta simple comprobación para preguntar si los objetos apuntan a la misma referencia en

89
00:08:50,930 --> 00:08:52,980
memoria puede sacarnos de duda.

90
00:08:53,090 --> 00:08:58,160
No es necesario agregar este código ni tampoco la librería que utilizamos pero en este caso se lo segregamos

91
00:08:58,160 --> 00:09:01,940
para que estén seguros de lo que está sucediendo con el compilador.

92
00:09:01,940 --> 00:09:07,190
Ahora con esta librería es posible saber incluso más detalle acerca de cada uno de los elementos de

93
00:09:07,190 --> 00:09:08,290
nuestro objeto.

94
00:09:08,330 --> 00:09:09,670
Para ello vamos a hacer lo siguiente

95
00:09:13,840 --> 00:09:23,990
Vamos a imprimir detalle del empleado 1 y para ello vamos a utilizar la clase Graph Layout mandamos

96
00:09:23,990 --> 00:09:32,620
al método int y podemos ver que se importa en automático la clase Graph Layout del paquete que acabamos

97
00:09:32,620 --> 00:09:35,810
de agregar a nuestro archivo post or open JDK.

98
00:09:35,920 --> 00:09:43,750
J O L info le pasamos la referencia del objeto que queremos analizar y posteriormente mandamos a llamar.

99
00:09:43,750 --> 00:09:50,050
El método Divol para que podamos observar el detalle de este objeto guardamos cambios y ejecutamos

100
00:09:55,450 --> 00:10:01,910
y podemos observar el detalle del empleado 1 podemos ver que tenemos el nombre completamente calificado

101
00:10:01,910 --> 00:10:06,230
de nuestra clase el nombre del paquete y el nombre de la clase.

102
00:10:06,290 --> 00:10:12,230
Posteriormente el valor de Jacob y posteriormente nos muestra el detalle de cada uno de los elementos

103
00:10:12,290 --> 00:10:18,850
internos de nuestra clase así que podemos observar la referencia en memoria del objeto empleado.

104
00:10:18,890 --> 00:10:20,450
Esta es la referencia de memoria.

105
00:10:20,510 --> 00:10:26,540
Posteriormente la referencia en memoria de nuestra variable string es decir el valor de nombre es la

106
00:10:26,540 --> 00:10:32,930
referencia en memoria y finalmente el valor del atributo de sueldo y esa es la referencia en memoria

107
00:10:33,230 --> 00:10:34,030
de este valor

108
00:10:38,490 --> 00:10:40,680
ahora podemos hacer lo mismo para el empleado 2

109
00:10:44,790 --> 00:10:50,000
imprimimos el detalle del empleado 2 y lo mandamos a imprimir.

110
00:10:50,000 --> 00:10:51,530
Guardamos cambios y ejecutamos

111
00:11:04,520 --> 00:11:10,050
y podemos elevar varias cosas interesantes por ejemplo en este caso estamos apuntando el objeto empleado

112
00:11:10,080 --> 00:11:16,740
tienen esta dirección de memoria la cual es distinta a esta dirección en memoria del empleado 2.

113
00:11:16,890 --> 00:11:22,410
Posteriormente el objeto string el atributo de string de nombre podemos observar que contiene exactamente

114
00:11:22,410 --> 00:11:27,630
la misma referencia que la variable también de nombre Juan que hemos agregado en el empleado 2.

115
00:11:27,660 --> 00:11:35,100
Esto se debe a que las cadenas debido a que no estamos utilizando la palabra reservada Nioh para asignar

116
00:11:35,190 --> 00:11:41,490
un valor al atributo de nombre entonces se utiliza el concepto de string pull es decir que estas cadenas

117
00:11:41,640 --> 00:11:44,110
se depositan en algún lugar de la memoria.

118
00:11:44,220 --> 00:11:49,800
Es un lugar especial y una vez que encuentra esta misma cadena entonces reutiliza la misma dirección

119
00:11:49,830 --> 00:11:53,250
en memoria siempre y cuando no se utilice la palabra reservada.

120
00:11:53,280 --> 00:11:57,780
De lo contrario se van a utilizar diferentes direcciones de memoria pero como en este caso no estamos

121
00:11:57,780 --> 00:12:03,360
utilizando la palabra reservada Niu entonces la dirección en memoria de este string va a ser el mismo

122
00:12:03,360 --> 00:12:08,320
que este valor ya que contienen los mismos caracteres y lo mismo sucede con los tipos.

123
00:12:08,320 --> 00:12:14,250
Integrar también se va a reutilizar los valores de estos objetos así que se encuentra el mismo valor

124
00:12:14,310 --> 00:12:20,070
entero entonces se reserva un espacio en memoria para este valor y también se va a reutilizar siempre

125
00:12:20,070 --> 00:12:25,560
y cuando no utilicemos la palabra reservada New para crear este valor de tipo entero que sería utilizando

126
00:12:25,560 --> 00:12:27,370
realmente la clase integral.

127
00:12:27,690 --> 00:12:33,270
Pero como ninguno de estos casos estamos utilizando internamente la palabra Niu entonces estas referencias

128
00:12:33,270 --> 00:12:34,190
son las mismas.

129
00:12:34,230 --> 00:12:40,890
Por lo tanto esta cadena de string Juan y esta cadena de 5 an apuntan a la misma referencia en memoria.

130
00:12:40,890 --> 00:12:49,730
Vamos a comprobar esto y podemos observar que este atributo de nombre apunta a la referencia en memoria

131
00:12:49,740 --> 00:12:58,450
6 2:45 22 F40 y este mismo atributo de nombre apunta exactamente a la misma dirección en memoria 62

132
00:12:58,450 --> 00:13:03,280
45 22 F 40 y lo mismo sucede con el atributo de sueldo.

133
00:13:03,280 --> 00:13:13,000
Podemos observar la dirección de memoria 62 45 22 F 58 y aquí tenemos exactamente el mismo valor para

134
00:13:13,000 --> 00:13:14,480
el atributo de sueldo.

135
00:13:14,690 --> 00:13:18,990
Así que con esto ya hemos comentado varias cosas de cómo se comportan realmente los objetos.

136
00:13:19,090 --> 00:13:24,070
Una vez que podemos analizar la dirección en memoria de cada uno de estos objetos bien vamos a dejar

137
00:13:24,070 --> 00:13:29,140
hasta aquí este vídeo y en el siguiente vídeo vamos a continuar analizando los métodos de la clase obvie

138
00:13:29,590 --> 00:13:30,920
nos vemos en el siguiente vídeo.

139
00:13:30,940 --> 00:13:31,510
Saludos.
