1
00:00:00,730 --> 00:00:02,410
Hola y bienvenidos a esta elección.

2
00:00:02,410 --> 00:00:07,320
A continuación vamos a revisar el tema de alcance de variables en Java están listos.

3
00:00:07,390 --> 00:00:14,380
Vamos bien vamos a seguir trabajando con nuestro proyecto de aritmética y vamos a analizar ahora los

4
00:00:14,380 --> 00:00:20,620
siguientes cambios vamos a nuestra clase aritmética y ahora lo que vamos a hacer es seguir utilizando

5
00:00:20,620 --> 00:00:25,590
nuestros atributos de la clase tenemos los constructores respectivos.

6
00:00:25,720 --> 00:00:30,740
Vamos a quitar estas líneas y vamos a agregar algunos otros métodos.

7
00:00:30,980 --> 00:00:36,140
En este caso vamos a llegar algunas mejoras por ejemplo en el caso del método sumar vamos a hacer un

8
00:00:36,140 --> 00:00:45,810
retorno directo de la suma de los atributos de la clase así que escribimos Huitrón además de ya que

9
00:00:45,810 --> 00:00:51,930
podemos regresar directamente el resultado de la suma y ahora vamos a agregar algunos otros métodos

10
00:00:52,170 --> 00:00:55,530
para poner en práctica el concepto de alcance de variables.

11
00:00:55,530 --> 00:01:01,950
Podemos observar que en este caso al momento de definir atributos de la clase estamos a nivel de toda

12
00:01:01,950 --> 00:01:08,580
nuestra clase y en cualquiera de los métodos estamos pudiendo acceder al valor de los atributos de nuestra

13
00:01:08,580 --> 00:01:17,190
clase así que podemos definir otro método llamado restar y podemos utilizar los mismos atributos de

14
00:01:17,190 --> 00:01:25,070
nuestra clase para realizar la resta utilizando los mismos atributos de nuestra clase.

15
00:01:25,070 --> 00:01:32,170
Posteriormente definimos el método de multiplicar y de igual manera vamos a utilizar los mismos atributos

16
00:01:32,170 --> 00:01:37,660
de nuestra clase A por de y finalmente la división

17
00:01:40,970 --> 00:01:42,620
y el método se llama dividir

18
00:01:45,870 --> 00:01:52,840
y vamos a hacer la división de A entre así que podemos observar que en todos los casos estamos utilizando

19
00:01:53,080 --> 00:02:00,070
los mismos atributos de nuestra clase así que una vez que definimos atributos en nuestra clase entonces

20
00:02:00,070 --> 00:02:05,710
podemos acceder los a lo largo de nuestra clase en cada uno de los métodos que utilicemos.

21
00:02:06,000 --> 00:02:11,260
Bien vamos a modificar ahora nuestra prueba aritmética vamos a quitar este código para comenzar desde

22
00:02:11,260 --> 00:02:17,490
cero como estamos en el tema de alcance de variables vamos a definir ahora dos variables locales.

23
00:02:17,710 --> 00:02:24,280
A diferencia de los atributos de una clase estas variables como hemos visto cuando creamos un objeto

24
00:02:24,490 --> 00:02:30,190
se asocian al objeto y únicamente se van a destruir hasta el momento en que se quite ese objeto de la

25
00:02:30,190 --> 00:02:31,260
memoria.

26
00:02:31,570 --> 00:02:37,000
Así que vamos a poder utilizarlas como hemos visto en diferentes métodos y durante todo el tiempo que

27
00:02:37,000 --> 00:02:41,480
el objeto de esta clase que se ha creado esté disponible en memoria.

28
00:02:41,500 --> 00:02:47,710
En cambio si definimos variables locales y son locales debido a que estamos dentro de un método si estamos

29
00:02:47,710 --> 00:02:54,880
dentro de un método entonces cualquier variable que definamos es una variable local ya sea los argumentos

30
00:02:54,880 --> 00:03:00,210
que estamos recibiendo así como las variables que definamos dentro de estos métodos.

31
00:03:00,520 --> 00:03:12,030
Definimos la variable operando a con el valor de seis y definimos también la variable operando con el

32
00:03:12,030 --> 00:03:18,510
valor de dos y estas variables únicamente se van a poder acceder dentro de este método no se van a poder

33
00:03:18,510 --> 00:03:20,490
acceder fuera de este método.

34
00:03:20,550 --> 00:03:22,680
Por ejemplo si definimos un método

35
00:03:26,890 --> 00:03:34,000
llamado otro método y queremos imprimir por ejemplo el valor de la variable operando a

36
00:03:37,270 --> 00:03:43,540
Podemos observar que esto no es posible nos indica que el símbolo no se reconoce y esto es debido a

37
00:03:43,540 --> 00:03:49,570
que la variable operando a únicamente va a estar disponible dentro del bloque de código en el cual fue

38
00:03:49,570 --> 00:03:52,970
definida y como éste ya es otro bloque de código.

39
00:03:53,020 --> 00:03:57,360
Entonces esta variable no puede ser accedida desde otro bloque de código.

40
00:03:57,550 --> 00:04:05,200
Por lo tanto no nos reconoce esta variable pero si definimos una variable a nivel de la clase entonces

41
00:04:05,260 --> 00:04:13,010
la variable que definamos fuera de los métodos se va a poder acceder durante toda la clase que es precisamente

42
00:04:13,010 --> 00:04:16,430
lo que estamos haciendo en esta clase aritmética.

43
00:04:16,430 --> 00:04:23,240
Podemos observar que estos atributos se están definiendo fuera de cualquier método incluyendo los constructores

44
00:04:23,600 --> 00:04:30,110
por lo tanto estas variables se pueden acceder durante todo este bloque de código que corresponde a

45
00:04:30,110 --> 00:04:30,670
la clase.

46
00:04:31,010 --> 00:04:36,410
Pero recordemos que para poder utilizar estos atributos debemos de crear un objeto así que realmente

47
00:04:36,410 --> 00:04:39,020
lo que vamos a poder acceder son estas variables.

48
00:04:39,110 --> 00:04:44,630
Pero una vez que hemos creado nuestro objeto y las vamos a poder acceder durante todo el tiempo de vida

49
00:04:44,930 --> 00:04:51,170
que el objeto esté disponible en memoria y el único que puede quitar el objeto de la memoria es el recolector

50
00:04:51,170 --> 00:04:52,020
de basura.

51
00:04:52,190 --> 00:04:57,930
Una vez que no tenemos ninguna variable apuntando al objeto es la única forma en que un objeto se va

52
00:04:57,930 --> 00:04:59,410
a eliminar de la memoria.

53
00:04:59,420 --> 00:05:05,000
Esto lo vamos a ver a detalle más adelante pero nosotros no vamos a controlar directamente en qué momento

54
00:05:05,000 --> 00:05:07,080
se quita un objeto de la memoria.

55
00:05:07,310 --> 00:05:13,040
Por lo tanto vamos a poder acceder a estos atributos durante todo el tiempo que un objeto de la clase

56
00:05:13,100 --> 00:05:20,930
aritmética esté disponible en memoria bien vamos a continuar vamos a poner entre comentarios este método

57
00:05:21,660 --> 00:05:27,710
bien ahora lo que vamos a hacer es crear un objeto de la clase aritmética enviando los argumentos operando

58
00:05:27,750 --> 00:05:29,110
AIB.

59
00:05:29,300 --> 00:05:30,530
Así describimos lo siguiente

60
00:05:34,180 --> 00:05:38,110
creamos un objeto de la clase de ética enviando los argumentos respectivos

61
00:05:43,430 --> 00:05:49,610
creamos la variable llamada objeto uno de tipo aritmética y vamos a crear un nuevo objeto

62
00:05:52,220 --> 00:05:54,530
utilizando la palabra reservada niu.

63
00:05:54,710 --> 00:06:00,380
Posteriormente mandamos a llamar el constructor de dos argumentos Podemos se va que tenemos disponible

64
00:06:00,590 --> 00:06:06,560
tanto el constructor sin argumentos como el constructor con dos argumentos así que vamos a utilizar

65
00:06:06,560 --> 00:06:08,180
el constructor con dos argumentos

66
00:06:10,870 --> 00:06:16,430
y vamos a enviar como valores el operando a las variables locales operando a y operando.

67
00:06:17,550 --> 00:06:23,160
Entonces en resumen estas variables se conoce como variables locales debido a que únicamente se pueden

68
00:06:23,160 --> 00:06:29,880
utilizar dentro del método donde han sido definidas como hemos visto ya no se pueden utilizar fuera

69
00:06:29,880 --> 00:06:36,920
de otros métodos y en este momento como estamos dentro del método todavía entonces podemos seguir utilizando

70
00:06:36,920 --> 00:06:39,740
las variables operando a y operando.

71
00:06:40,190 --> 00:06:46,190
Y con esto ya estamos creando nuestro objeto aritmética se manda llamar el constructor de dos argumentos

72
00:06:46,580 --> 00:06:54,020
y aparte estamos inicializar los atributos de nuestra clase y estos atributos como están definidos a

73
00:06:54,020 --> 00:07:00,290
nivel de la clase entonces los vamos a poder acceder a lo largo de toda la clase en todos los métodos

74
00:07:00,290 --> 00:07:07,440
que definamos así que con esto ya tenemos creado nuestro objeto aritmética y ahora vamos a imprimir

75
00:07:07,440 --> 00:07:08,730
los valores de los operandos

76
00:07:11,820 --> 00:07:14,640
mandamos a imprimir el valor del operando a

77
00:07:21,030 --> 00:07:23,990
posteriormente el valor del operando de

78
00:07:26,710 --> 00:07:28,630
guardamos cambios y ejecutamos

79
00:07:34,970 --> 00:07:40,490
y podemos llevar ejecutando constructor con dos argumentos y posteriormente los valores de operando

80
00:07:40,490 --> 00:07:47,160
a igual a 6 y operando ve igualados bien así que hasta el momento estamos utilizando nuestras variables

81
00:07:47,160 --> 00:07:51,060
locales para inicializar nuestro objeto aritmética.

82
00:07:51,060 --> 00:07:56,280
Posteriormente el objeto aritmética con los valores de las variables locales recibidas iniciales en

83
00:07:56,280 --> 00:08:03,100
los atributos de la clase y una vez que hemos inicializar los atributos de El objeto aritmética.

84
00:08:03,330 --> 00:08:05,490
Entonces podemos empezar a mandar a llamar.

85
00:08:05,580 --> 00:08:12,090
Los métodos como sumar restar etc. Y también podemos observar que podemos imprimir y acceder a las variables

86
00:08:12,090 --> 00:08:17,910
locales sin ningún problema si estamos dentro del mismo método donde se han definido estas variables

87
00:08:21,050 --> 00:08:25,750
bien así que vamos a hacer lo siguiente mandamos el mensaje imprimimos el resultado de la suma

88
00:08:29,740 --> 00:08:31,240
y ejecutamos lo siguiente.

89
00:08:33,290 --> 00:08:34,700
Agregamos un salto de línea

90
00:08:37,190 --> 00:08:45,930
resultado de la suma y utilizando la variable objeto uno que apunta al objeto aritmética que hemos creado

91
00:08:47,180 --> 00:08:56,530
mandamos a llamar el método sumar guardamos cambios y ejecutamos y podemos observar resultado de la

92
00:08:56,530 --> 00:09:02,640
suma seis más +2 que son los valores de los operandos es igual a 8.

93
00:09:02,650 --> 00:09:08,110
Esto quiere decir que estamos pudiendo acceder sin ningún problema a los atributos de nuestra clase

94
00:09:08,770 --> 00:09:12,220
a los valores que sean inicializar no al momento de mandar a llamar.

95
00:09:12,220 --> 00:09:16,470
Este constructor y eso fue el momento de crear nuestro objeto aritmética.

96
00:09:16,900 --> 00:09:22,330
Aquí simplemente estamos comprobando que podemos acceder a los valores de los atributos de nuestra clase

97
00:09:23,950 --> 00:09:32,030
desde otros métodos así que podemos acceder a estos valores sin ningún problema debido a que estas variables

98
00:09:32,270 --> 00:09:37,820
están definidas a nivel de la clase y ahora simplemente comprobamos las demás operaciones

99
00:09:42,360 --> 00:09:44,280
imprimimos el resultado de la resta

100
00:09:50,950 --> 00:09:54,040
y se van a utilizar los mismos valores de los atributos

101
00:09:56,620 --> 00:10:03,310
pero se va a realizar diferente operación esta es la operación que se va a mandar a llamar la resta

102
00:10:03,340 --> 00:10:09,290
pero vamos a utilizar los mismos atributos de nuestra clase guardamos cambios y ejecutamos

103
00:10:12,150 --> 00:10:17,980
y podemos observar que habrá seis menos dos que son los valores de nuestros operandos el resultado de

104
00:10:17,980 --> 00:10:24,670
la resta es igual a cuatro así que con eso estamos demostrando que podemos acceder a los atributos de

105
00:10:24,670 --> 00:10:26,680
nuestra clase sin ningún problema.

106
00:10:26,680 --> 00:10:29,710
A lo largo de toda la clase ahora imprimimos

107
00:10:37,020 --> 00:10:41,550
el resultado de la multiplicación

108
00:10:49,130 --> 00:10:57,790
usamos nuestra variable objeto 1 y mandamos a llamar el método multiplicar esta variable objeto 1.

109
00:10:57,850 --> 00:11:03,970
También es una variable local ya que se ha definido dentro de este método main y por lo tanto no se

110
00:11:03,970 --> 00:11:05,930
puede utilizar en otro método.

111
00:11:05,980 --> 00:11:12,340
Sin embargo esta variable podríamos también definirla fuera del método main para que pudiera ser utilizada

112
00:11:12,370 --> 00:11:14,110
en otros métodos.

113
00:11:14,200 --> 00:11:18,960
De momento no lo vamos a hacer pero solamente los dejamos como comentario podrían hacer esta prueba.

114
00:11:19,030 --> 00:11:25,000
Definir esta variable fuera del método main para poder ser accedida desde otros métodos bien guardamos

115
00:11:25,000 --> 00:11:33,150
cambios y ejecutamos para ver el resultado de la multiplicación y vemos que el resultado de la multiplicación

116
00:11:33,660 --> 00:11:40,950
de ejecutar 6 por 2 es igual a 12 así que estamos utilizando los atributos de la clase sin ningún problema

117
00:11:44,990 --> 00:11:47,390
y finalmente imprimimos el resultado de la división

118
00:11:54,090 --> 00:11:59,850
usamos la variable local objeto 1 y mandamos a llamar el método dividir

119
00:12:03,090 --> 00:12:09,720
ejecutamos y podemos observar que 6 entre dos el resultado de la División 3 bien así que con eso hemos

120
00:12:09,720 --> 00:12:13,520
puesto en práctica la definición de alcance de variables.

121
00:12:13,830 --> 00:12:19,550
Hemos visto la diferencia entre variables locales y variables que son atributos de una clase.

122
00:12:19,560 --> 00:12:25,530
Por último vamos a hacer un cambio una mejora a nuestra clase aritmética lo que vamos a hacer es utilizar

123
00:12:25,830 --> 00:12:33,400
el concepto de operador dis el operador dis básicamente se puede utilizar dentro de una clase ya que

124
00:12:33,400 --> 00:12:39,310
cuando creamos un objeto en este caso de la clase aritmética en esta línea cuando se crea este objeto

125
00:12:39,880 --> 00:12:47,170
entonces también en automático el compilador de java crea una variable llamada VIS y esta variable lo

126
00:12:47,170 --> 00:12:50,780
que hace es apuntar al objeto que se está creando.

127
00:12:50,950 --> 00:12:58,150
El operador dis nos va a servir para poder acceder a los atributos y métodos de nuestra clase en el

128
00:12:58,150 --> 00:13:02,440
momento en que se está realizando la ejecución de código de nuestra clase.

129
00:13:02,590 --> 00:13:11,740
Por lo tanto por ejemplo en este caso el constructor podemos utilizar 10 punto y acceder al atributo

130
00:13:11,740 --> 00:13:13,180
de nuestra clase.

131
00:13:13,360 --> 00:13:19,390
Ahora podemos observar que esto realmente no es necesario ya que sin utilizar el operador dis pudimos

132
00:13:19,390 --> 00:13:22,300
modificar y acceder al atributo de nuestra clase.

133
00:13:22,810 --> 00:13:30,540
Sin embargo qué pasa si los argumentos de nuestro conductor ahora queremos llamarlos a IB

134
00:13:34,830 --> 00:13:38,340
Por lo tanto estas variables deben de cambiar a IB.

135
00:13:38,490 --> 00:13:45,030
Podemos observar que en este caso el argumento que estamos recibiendo en lugar de asignar el valor hacia

136
00:13:45,030 --> 00:13:50,640
el atributo de nuestra clase se está utilizando el mismo argumento que estamos recibiendo para asignar

137
00:13:50,670 --> 00:13:52,550
el valor a sí mismo.

138
00:13:52,560 --> 00:13:58,410
Esto provoca una ambigüedad y para romper esta ambigüedad entonces tenemos que utilizar nuestro operador

139
00:13:58,410 --> 00:14:05,820
dis para indicar que éste es el argumento que estamos recibiendo en el método y esto es el atributo

140
00:14:05,820 --> 00:14:11,220
de nuestra clase así que por medio del operador dis vamos a hacer una diferencia y vamos a romper la

141
00:14:11,220 --> 00:14:16,680
ambigüedad entre cual es el atributo de nuestra clase y cuál es el argumento o parámetro que estamos

142
00:14:16,680 --> 00:14:23,330
recibiendo en este constructor y hacemos lo mismo con nuestra variable que ponemos dis punto

143
00:14:26,620 --> 00:14:32,110
y entonces los valores que estamos recibiendo como argumentos en nuestro constructor se toma el valor

144
00:14:32,140 --> 00:14:37,720
la variable que estamos recibiendo y se asigna al atributo de nuestra clase y por medio del operador

145
00:14:37,720 --> 00:14:43,810
dis estamos indicando que este es el atributo de nuestra clase A y entonces el valor que recibimos se

146
00:14:43,810 --> 00:14:50,950
asigna al atributo a y de igual manera el valor que recibimos en el argumento se asigna a nuestra variable

147
00:14:51,750 --> 00:14:58,870
disputo que es el atributo de nuestra clase el atributo que incluso podemos observar que cambia el color

148
00:14:59,860 --> 00:15:06,070
cuando es una variable local como en este caso un argumento del constructor el color podemos observar

149
00:15:06,070 --> 00:15:11,680
que está en blanco pero cuando estamos utilizando el atributo de nuestra clase podemos observar que

150
00:15:11,680 --> 00:15:19,630
el color está en morado y de igual manera en estos métodos cada una de estas variables está en morado.

151
00:15:19,630 --> 00:15:24,880
Esto quiere decir que estas variables son los atributos de nuestra clase y no son variables locales

152
00:15:25,330 --> 00:15:30,280
sino son variables que son atributos de nuestra clase y por lo tanto se pueden acceder a lo largo de

153
00:15:30,280 --> 00:15:37,620
toda nuestra clase y como en este caso no tenemos ambigüedad de valores es opcional utilizar dis.

154
00:15:37,900 --> 00:15:45,710
Así que en este caso simplemente por buena práctica podríamos utilizar dis la buena práctica viene del

155
00:15:45,710 --> 00:15:53,660
hecho de que si observamos disputo algo en automático sabemos que estamos utilizando un atributo o método

156
00:15:53,660 --> 00:15:55,250
de nuestra clase.

157
00:15:55,300 --> 00:16:01,460
En cambio como podemos observar en este caso como no estamos utilizando DIS en automático sabemos que

158
00:16:01,460 --> 00:16:08,000
es una variable local que puede ser un argumento recibido en este método o una variable definida.

159
00:16:08,000 --> 00:16:14,060
Dentro de este método obviamente aquí parece que es irrelevante pero podemos tener métodos con muchas

160
00:16:14,060 --> 00:16:20,270
líneas de código y entonces revisar constantemente en qué momento se definieron las variables podría

161
00:16:20,270 --> 00:16:27,170
llegar a ser muy tedioso por lo tanto es buena práctica utilizar dis punto y posteriormente el nombre

162
00:16:27,170 --> 00:16:33,290
del atributo de nuestra clase o el método de nuestra clase y de esta manera sabemos automáticamente

163
00:16:33,290 --> 00:16:41,510
que si vemos dis punto algo entonces significa que es un atributo o método de nuestra clase y así rápidamente

164
00:16:41,510 --> 00:16:47,710
hacer diferencia entre qué variables son atributos de una clase y qué variables son locales.

165
00:16:47,720 --> 00:16:53,450
Como hemos comentado incluso élide hace estas diferencias al momento de utilizar colores pero también

166
00:16:53,450 --> 00:17:02,140
para leer este código más rápido podemos utilizar dis así que vamos a agregar esta mejora en el uso

167
00:17:02,140 --> 00:17:06,070
de cada una de nuestras variables que corresponden a atributos de nuestra clase

168
00:17:11,130 --> 00:17:16,470
ahora esto es importante porque esto lo vamos a encontrar en todas las clases en todos los proyectos

169
00:17:16,470 --> 00:17:23,700
Java en los que trabajemos así que es importante que tengamos claro el uso del operador dis así que

170
00:17:23,700 --> 00:17:31,830
ya tenemos nuestros cambios en nuestra clase aritmética guardamos cambios y ejecutamos y podemos observar

171
00:17:31,840 --> 00:17:34,000
que el resultado es exactamente el mismo.

172
00:17:34,030 --> 00:17:41,110
Definimos los operandos OIV que son variables locales al método Mayne y posteriormente ejecutamos cada

173
00:17:41,110 --> 00:17:43,940
una de las operaciones bien.

174
00:17:43,940 --> 00:17:50,270
Por último vamos a ejecutar paso a paso esta clase ponemos un punto de ruptura en la línea de código

175
00:17:50,270 --> 00:17:52,180
donde estamos creando nuestro objeto.

176
00:17:52,190 --> 00:18:00,950
Aritmética damos el derecho de Buffy al podemos ver que ya se definieron las variables operando a y

177
00:18:00,950 --> 00:18:01,700
operando.

178
00:18:02,070 --> 00:18:05,840
Y vamos a entrar al detalle de la creación del objeto aritmética.

179
00:18:05,840 --> 00:18:13,680
Para esto presionamos F7 o into y podemos observar que en automático el compilador ha creado esta variable

180
00:18:13,680 --> 00:18:20,420
llamada dis ya que como hemos comentado a través de esta variable que se ha creado es que podemos hacer

181
00:18:20,420 --> 00:18:26,960
referencia al objeto aritmética que se ha creado también en esta dirección de memoria.

182
00:18:26,960 --> 00:18:32,300
Así que este operador dis hace referencia al objeto que se ha creado y que se está ejecutando en este

183
00:18:32,300 --> 00:18:39,020
momento y como estamos dentro de la clase aritmética se ha creado este objeto en memoria y por lo tanto

184
00:18:39,410 --> 00:18:44,090
apunta al objeto que se ha creado en esta dirección de memoria.

185
00:18:44,180 --> 00:18:50,750
Una vez que salimos de la ejecución de esta clase entonces el operador dis cambia y apunta a otra clase.

186
00:18:50,750 --> 00:18:55,730
Posteriormente vamos a ver un ejercicio de esto para que quede más claro pero básicamente en este momento

187
00:18:55,730 --> 00:19:02,270
como se está creando un objeto de tipo aritmética entonces el operador dis apunta también a este objeto

188
00:19:02,270 --> 00:19:10,460
que se está creando y podemos observar que esta variable que está creando el operador DIS es de tipo

189
00:19:10,460 --> 00:19:14,710
aritmética ya que está apuntando a un objeto de tipo aritmética.

190
00:19:14,870 --> 00:19:22,220
Vamos a abrir el detalle de esta variable y podemos observar que este operador dis puede acceder a los

191
00:19:22,220 --> 00:19:29,450
atributos de esta clase A y ver respectivamente así que es precisamente lo que estamos haciendo a través

192
00:19:29,450 --> 00:19:38,030
del operador dis estamos indicando dis punto a corresponde al atributo de esta clase y posteriormente

193
00:19:38,030 --> 00:19:39,620
10 puntos.

194
00:19:40,070 --> 00:19:43,710
Entonces hace referencia al atributo de nuestra clase.

195
00:19:43,810 --> 00:19:50,270
En cambio estos valores son los que se están recibiendo como argumentos en este constructor y esta es

196
00:19:50,270 --> 00:19:55,880
la variable que se está utilizando como argumento y posteriormente se utiliza para asignar el valor

197
00:19:55,910 --> 00:19:59,430
al atributo de la clase tanto al valor de A como el valor de.

198
00:20:00,140 --> 00:20:05,930
Así que si ejecutamos de nueva cuenta esta línea presionamos F8 vamos a observar cómo cambian los valores

199
00:20:06,230 --> 00:20:12,140
por un lado podemos observar que diz hace referencia a los atributos de nuestra clase y contiene los

200
00:20:12,140 --> 00:20:18,260
valores de cero ya que es el valor inicial de los atributos de nuestra clase pero por otro lado tenemos

201
00:20:18,350 --> 00:20:25,280
los argumentos a y b que son los que estamos recibiendo en esta parte del código y aquí ya estamos recibiendo

202
00:20:25,280 --> 00:20:33,250
los valores de 6 y 2 así que lo que vamos a hacer es asignar el valor de 6 al atributo de nuestra clase

203
00:20:33,310 --> 00:20:40,470
A y el valor de que es el valor de 2 lo vamos a asignar al atributo.

204
00:20:40,690 --> 00:20:45,730
Esto es lo que estamos haciendo con estas líneas de código bien así que vamos a comprobarlo presionamos

205
00:20:45,790 --> 00:20:55,330
F8 y podemos ver que ya cambió el valor del atributo a ya cambió a 6 ya que este valor se asignó a la

206
00:20:55,330 --> 00:21:03,270
tributo a y si presionamos de nueva cuenta F8 entonces ahora también ya se cambió el valor del atributo.

207
00:21:04,030 --> 00:21:09,730
Así que de esta manera es como podemos utilizar el operador dis para rápidamente saber que estamos haciendo

208
00:21:09,730 --> 00:21:16,570
referencia a atributos o métodos de nuestra clase y así si observamos el código en cada una de estas

209
00:21:16,570 --> 00:21:22,510
operaciones entonces aunque no es necesario podemos saber que estas variables que estamos utilizando

210
00:21:22,810 --> 00:21:29,500
en automático son atributos de nuestra clase debido a que estamos utilizando disputo y posteriormente

211
00:21:29,500 --> 00:21:37,600
el atributo de nuestra clase bien terminamos de ejecutar esto presionamos F8 vemos en la consola y ya

212
00:21:37,600 --> 00:21:45,250
tenemos el mensaje ejecutando constructor con dos argumentos presionamos F8 y aquí podemos continuar

213
00:21:45,250 --> 00:21:51,370
ejecutando nuestro programa simplemente vamos a continuar ejecutando con F8 hasta terminar la ejecución

214
00:21:51,370 --> 00:21:57,970
de nuestro programa ya que únicamente queremos mostrarles cómo es que se está creando este objeto y

215
00:21:57,970 --> 00:22:04,430
el uso del operador dice y con esto estamos accediendo entonces a cada uno de los valores de los atributos

216
00:22:04,430 --> 00:22:10,710
de nuestra clase en cada uno de los métodos que estamos ejecutando bien así que en esta elección hemos

217
00:22:10,710 --> 00:22:17,040
visto varios temas como es el alcance de variables y también el uso del operador dice esto lo vamos

218
00:22:17,040 --> 00:22:21,690
a seguir poniendo en práctica en las siguientes lecciones así que vamos a ver todavía más ejercicios

219
00:22:21,930 --> 00:22:25,500
de cada uno de estos temas nos vemos en los siguientes videos.

220
00:22:25,500 --> 00:22:26,100
Saludos.