1
00:00:01,270 --> 00:00:06,430
Vamos a continuar con este ejercicio de clase obvie bien con todo esto ya aclarado de la dirección de

2
00:00:06,430 --> 00:00:07,810
memoria de nuestros objetos.

3
00:00:07,930 --> 00:00:10,800
Vamos a continuar vamos a quitar todo este código

4
00:00:15,300 --> 00:00:20,750
y también quitamos todo Este tag de dependencia que ha agregado

5
00:00:24,470 --> 00:00:28,670
quitamos estos import hacemos un Clin Anvil

6
00:00:32,530 --> 00:00:37,360
y con eso estamos listos para continuar bien hasta aquí lo que hemos hecho entonces es crear dos objetos

7
00:00:37,570 --> 00:00:39,040
con los mismos valores.

8
00:00:39,130 --> 00:00:44,020
Sin embargo con esto ya hemos comprobado con esta línea hemos comprobado que no están en la misma dirección

9
00:00:44,020 --> 00:00:47,200
de memoria aunque regresan el mismo valor de Scott.

10
00:00:47,320 --> 00:00:53,170
Esto puede variar también incluso de plataforma en plataforma pero vamos a ver a continuación cómo vamos

11
00:00:53,170 --> 00:00:56,180
a implementar nosotros estos métodos.

12
00:00:56,190 --> 00:00:59,650
Bien así que ahora vamos a crear un método llamado comparar objetos

13
00:01:03,330 --> 00:01:12,560
iba a recibir los dos objetos que hemos creado empleado 1 y empleado 2 vamos a crear este método.

14
00:01:12,560 --> 00:01:17,290
En esta misma clase va a ser privado de tipo Static no va a regresar nada

15
00:01:20,140 --> 00:01:21,920
y se llama comparar objetos

16
00:01:25,220 --> 00:01:27,050
recibe dos referencias.

17
00:01:27,050 --> 00:01:35,620
En este caso de tipo empleado con los argumentos de M 1 y 2 ahora vamos a empezar a comparar aquí los

18
00:01:35,620 --> 00:01:42,490
objetos vamos a quitar aquí este sistema Out ya que eso ya no lo vamos a utilizar en el método main

19
00:01:43,210 --> 00:01:46,180
sino lo vamos a hacer dentro de este método comparar objetos

20
00:01:50,790 --> 00:01:53,110
imprimimos el empleado 1.

21
00:01:53,220 --> 00:02:00,550
Recordemos que esto manda llamar en automático al método autodestruyen y posteriormente imprimimos el

22
00:02:00,550 --> 00:02:01,740
empleado 2.

23
00:02:01,960 --> 00:02:03,820
Vamos a guardar cambios y ejecutamos

24
00:02:08,560 --> 00:02:15,410
y podemos observar que se está mandando a imprimir el empleado 1 con los valores de Juan y sueldo respectivamente

25
00:02:15,650 --> 00:02:21,650
y el empleado 2 con los mismos valores y debido a que son los mismos valores entonces el código Scott

26
00:02:22,220 --> 00:02:26,900
en este caso en esta plataforma que estamos utilizando nos da el mismo valor pero dependiendo de la

27
00:02:26,900 --> 00:02:32,330
plataforma este valor podría variar ya que al ser dos objetos distintos no necesariamente tienen que

28
00:02:32,330 --> 00:02:33,170
ser iguales.

29
00:02:33,200 --> 00:02:35,140
Estos valores de Jacob.

30
00:02:35,210 --> 00:02:40,550
Jacob recordemos que es un valor único que se asigna a cada uno de los objetos generándose a partir

31
00:02:40,550 --> 00:02:46,570
de los valores asignados a cada uno de los atributos de nuestro objeto ahora vamos a hacer la revisión

32
00:02:48,450 --> 00:02:54,800
por referencia ya lo hemos hecho también anteriormente pero simplemente para comprobar que tengan ya

33
00:02:54,820 --> 00:03:02,310
este código vamos a preguntar si el empleado 1 es igual al empleado 2 pero con eso estamos revisando

34
00:03:02,310 --> 00:03:08,150
las referencias en memoria y en dado caso de que sean iguales los objetos

35
00:03:13,420 --> 00:03:17,850
mandamos a imprimir los objetos tienen la misma dirección en memoria de lo contrario

36
00:03:22,650 --> 00:03:30,090
mandamos a imprimir los objetos tienen distinta

37
00:03:32,790 --> 00:03:36,150
dirección en memoria guardamos cambios y ejecutamos

38
00:03:39,970 --> 00:03:42,130
y Podemos se va que en este caso el resultado es.

39
00:03:42,190 --> 00:03:48,750
Los objetos tienen distinta dirección en memoria como ya lo analizamos en el video anterior esto es

40
00:03:48,750 --> 00:03:53,580
debido a que estamos utilizando la palabra reservada New y cada que utilicemos la palabra reserva Danio.

41
00:03:53,700 --> 00:04:00,900
Entonces con esto nos aseguramos que vamos a crear un objeto en distinta ubicación de memoria bien como

42
00:04:00,910 --> 00:04:07,090
siguiente paso vamos a revisar el método y quals para preguntar si el contenido de los objetos es igual.

43
00:04:08,290 --> 00:04:09,040
Revisión.

44
00:04:11,300 --> 00:04:17,290
Del método y cosas así que a diferencia de la revisión de referencia en memoria para saber si apuntan

45
00:04:17,290 --> 00:04:23,980
a la misma referencia con el método y quals podemos saber si los dos objetos tienen el mismo contenido

46
00:04:24,790 --> 00:04:30,670
ya que muchas veces cuando preguntamos si son iguales no nos referimos a la referencia en memoria sino

47
00:04:30,670 --> 00:04:37,860
al contenido de nuestros objetos por contenido me refiero a los valores de cada uno de los atributos

48
00:04:38,040 --> 00:04:39,330
de nuestros objetos.

49
00:04:39,330 --> 00:04:45,090
Así que en este caso los dos objetos contienen los mismos valores en nombre y sueldo.

50
00:04:45,090 --> 00:04:50,520
Así que con esto preguntamos si los dos objetos son iguales.

51
00:04:52,650 --> 00:04:59,230
Pero en contenido y en dado caso de que sean iguales mandamos a imprimir

52
00:05:06,190 --> 00:05:11,420
los objetos tienen el mismo contenido de lo contrario mandamos imprimir

53
00:05:18,610 --> 00:05:22,930
los objetos no tienen el mismo contenido guardamos cambios y ejecutamos

54
00:05:26,030 --> 00:05:32,300
y Podemos se va la respuesta en este caso los objetos tienen el mismo contenido debido a que podemos

55
00:05:32,300 --> 00:05:37,610
observar que los valores que hemos asignado son exactamente los mismos pero cualquier modificación que

56
00:05:37,610 --> 00:05:39,480
hagamos en el contenido.

57
00:05:39,560 --> 00:05:48,090
Por ejemplo si ponemos la cadena de Juan pero con j minúscula guardamos cambios y ejecutamos podemos

58
00:05:48,090 --> 00:05:53,870
observar que el mensaje que nos muestra los objetos no tienen el mismo contenido así que cualquier variante

59
00:05:54,080 --> 00:06:05,960
en los valores de los atributos entonces los objetos no son iguales en contenido.

60
00:06:06,170 --> 00:06:09,050
Y por último vamos a comprobar los valores de Skout.

61
00:06:09,530 --> 00:06:14,330
Recordemos que lapida IAVA nos indica que si implementamos el método ICAS entonces también debemos de

62
00:06:14,330 --> 00:06:16,020
implementar el método Scout.

63
00:06:16,190 --> 00:06:23,120
El compilador no nos va a marcar error incluso si quitamos dentro de la clase empleado si quitamos esta

64
00:06:23,120 --> 00:06:29,510
implementación podemos ver que no nos marca ningún error debido a que el método Scout tiene una implementación

65
00:06:29,510 --> 00:06:33,890
básica en la clase Object y este método se hereda a esta clase empleado.

66
00:06:33,950 --> 00:06:35,810
Por lo tanto no nos marca ningún error.

67
00:06:35,810 --> 00:06:42,160
Sin embargo la recomendación del JDK es que lo debemos implementar bien así que con esto ya tenemos

68
00:06:42,160 --> 00:06:46,570
completa nuestra clase de empleado y vamos a comprobar ahora el método Jacob

69
00:06:54,000 --> 00:06:54,950
vamos a preguntar

70
00:06:58,710 --> 00:07:06,320
si el valor de Skout del empleado 1 es igual al valor del empleado 2 a su Skout.

71
00:07:06,660 --> 00:07:10,310
Recordemos que es un valor entero que representa al objeto.

72
00:07:10,320 --> 00:07:14,010
En este momento según los valores que contiene cada uno de los atributos

73
00:07:16,970 --> 00:07:18,780
y si son iguales entonces

74
00:07:24,610 --> 00:07:33,300
mandamos a imprimir los objetos tienen el mismo código hojas de lo contrario mandamos a imprimir los

75
00:07:33,300 --> 00:07:41,490
objetos no tienen el mismo código hojas guardamos cambios y ejecutamos

76
00:07:44,510 --> 00:07:46,190
y podemos llevar el mensaje.

77
00:07:46,260 --> 00:07:51,630
Anteriormente vimos que los objetos tienen el mismo contenido y según la especificación de JDK si los

78
00:07:51,630 --> 00:07:56,650
objetos tienen el mismo contenido entonces deben tener el mismo código hojas.

79
00:07:56,760 --> 00:08:02,310
Así que por ello podemos observar que los objetos tienen el mismo código ya que este código se genera

80
00:08:02,340 --> 00:08:08,310
a partir de los valores de los atributos de nuestros objetos y si contienen los mismos valores entonces

81
00:08:08,310 --> 00:08:11,140
debe ser el mismo número para cada uno de los objetos.

82
00:08:11,250 --> 00:08:19,160
El mismo Código hojas y podemos imprimir el valor del código hojas para cada uno de los objetos en dado

83
00:08:19,160 --> 00:08:20,720
caso de que sean los mismos valores

84
00:08:23,510 --> 00:08:28,000
mandamos a imprimir el código hojas del empleado 1

85
00:08:32,370 --> 00:08:35,200
y también mandamos a imprimir el código hojas del empleado 2

86
00:08:37,980 --> 00:08:45,660
guardamos cambios ejecutamos y podemos observar que el número generado a partir de los valores de los

87
00:08:45,660 --> 00:08:52,390
atributos de nuestros objetos es exactamente el mismo para ambos objetos pero cualquier diferencia en

88
00:08:52,390 --> 00:08:56,140
los valores de los atributos del objeto por ejemplo.

89
00:08:56,230 --> 00:09:02,020
De igual manera si ponemos el nombre de Juan con j en el segundo objeto entonces vamos a ejecutar

90
00:09:05,790 --> 00:09:11,310
y podemos ver que los objetos no tienen el mismo contenido según ya habíamos revisado pero también los

91
00:09:11,310 --> 00:09:17,730
objetos no tienen el mismo código hojas ya que este código se genera con los valores de los atributos

92
00:09:18,450 --> 00:09:20,510
según podemos observar en este Código.

93
00:09:20,580 --> 00:09:26,580
Estamos utilizando los atributos de nombre y sueldo para aplicar esta fórmula y generar el código hojas

94
00:09:26,730 --> 00:09:33,490
de nuestro objeto como hemos comentado esta fórmula y este código hojas puede variar de implementación

95
00:09:33,520 --> 00:09:38,850
en implementación pero el objetivo es tratar de generar un número único para cada objeto.

96
00:09:38,890 --> 00:09:42,850
Por lo tanto se realizan estas operaciones pero bien podría ser distinta.

97
00:09:42,850 --> 00:09:47,870
Esta operación no tiene que ser exactamente la misma y en este caso nosotros la generamos a partir de

98
00:09:47,880 --> 00:09:53,920
líder cada uno de los sides puede generar de manera distinta esta fórmula para Decode hojas bien y con

99
00:09:53,920 --> 00:10:01,960
eso hemos analizado entonces los métodos string y quals y Escofet provenientes de la clase obvie en

100
00:10:01,960 --> 00:10:03,250
esta clase Object.

101
00:10:03,310 --> 00:10:09,010
Aquí se encuentran estos métodos y aunque contiene más métodos esta clase obvia que es la clase de padre

102
00:10:09,010 --> 00:10:10,490
de todas las clases en Java.

103
00:10:10,600 --> 00:10:16,030
Con estos métodos es suficiente para empezar a conocer y empezar a aplicar estos conceptos en nuestras

104
00:10:16,030 --> 00:10:22,420
clases conforme vayamos avanzando nos vamos familiarizando con más conceptos de la clase obvien pero

105
00:10:22,420 --> 00:10:27,920
de momento es suficiente para empezar a entender cómo funcionan nuestras clases en Java.

106
00:10:28,000 --> 00:10:30,930
Eso es todo por esta elección y nos vemos en el siguiente vídeo.

107
00:10:30,950 --> 00:10:31,540
Saludos.
