Hola y bienvenidos a esta elección.
A continuación vamos a revisar el tema de alcance de variables en Java están listos.
Vamos bien vamos a seguir trabajando con nuestro proyecto de aritmética y vamos a analizar ahora los
siguientes cambios vamos a nuestra clase aritmética y ahora lo que vamos a hacer es seguir utilizando
nuestros atributos de la clase tenemos los constructores respectivos.
Vamos a quitar estas líneas y vamos a agregar algunos otros métodos.
En este caso vamos a llegar algunas mejoras por ejemplo en el caso del método sumar vamos a hacer un
retorno directo de la suma de los atributos de la clase así que escribimos Huitrón además de ya que
podemos regresar directamente el resultado de la suma y ahora vamos a agregar algunos otros métodos
para poner en práctica el concepto de alcance de variables.
Podemos observar que en este caso al momento de definir atributos de la clase estamos a nivel de toda
nuestra clase y en cualquiera de los métodos estamos pudiendo acceder al valor de los atributos de nuestra
clase así que podemos definir otro método llamado restar y podemos utilizar los mismos atributos de
nuestra clase para realizar la resta utilizando los mismos atributos de nuestra clase.
Posteriormente definimos el método de multiplicar y de igual manera vamos a utilizar los mismos atributos
de nuestra clase A por de y finalmente la división
y el método se llama dividir
y vamos a hacer la división de A entre así que podemos observar que en todos los casos estamos utilizando
los mismos atributos de nuestra clase así que una vez que definimos atributos en nuestra clase entonces
podemos acceder los a lo largo de nuestra clase en cada uno de los métodos que utilicemos.
Bien vamos a modificar ahora nuestra prueba aritmética vamos a quitar este código para comenzar desde
cero como estamos en el tema de alcance de variables vamos a definir ahora dos variables locales.
A diferencia de los atributos de una clase estas variables como hemos visto cuando creamos un objeto
se asocian al objeto y únicamente se van a destruir hasta el momento en que se quite ese objeto de la
memoria.
Así que vamos a poder utilizarlas como hemos visto en diferentes métodos y durante todo el tiempo que
el objeto de esta clase que se ha creado esté disponible en memoria.
En cambio si definimos variables locales y son locales debido a que estamos dentro de un método si estamos
dentro de un método entonces cualquier variable que definamos es una variable local ya sea los argumentos
que estamos recibiendo así como las variables que definamos dentro de estos métodos.
Definimos la variable operando a con el valor de seis y definimos también la variable operando con el
valor de dos y estas variables únicamente se van a poder acceder dentro de este método no se van a poder
acceder fuera de este método.
Por ejemplo si definimos un método
llamado otro método y queremos imprimir por ejemplo el valor de la variable operando a
Podemos observar que esto no es posible nos indica que el símbolo no se reconoce y esto es debido a
que la variable operando a únicamente va a estar disponible dentro del bloque de código en el cual fue
definida y como éste ya es otro bloque de código.
Entonces esta variable no puede ser accedida desde otro bloque de código.
Por lo tanto no nos reconoce esta variable pero si definimos una variable a nivel de la clase entonces
la variable que definamos fuera de los métodos se va a poder acceder durante toda la clase que es precisamente
lo que estamos haciendo en esta clase aritmética.
Podemos observar que estos atributos se están definiendo fuera de cualquier método incluyendo los constructores
por lo tanto estas variables se pueden acceder durante todo este bloque de código que corresponde a
la clase.
Pero recordemos que para poder utilizar estos atributos debemos de crear un objeto así que realmente
lo que vamos a poder acceder son estas variables.
Pero una vez que hemos creado nuestro objeto y las vamos a poder acceder durante todo el tiempo de vida
que el objeto esté disponible en memoria y el único que puede quitar el objeto de la memoria es el recolector
de basura.
Una vez que no tenemos ninguna variable apuntando al objeto es la única forma en que un objeto se va
a eliminar de la memoria.
Esto lo vamos a ver a detalle más adelante pero nosotros no vamos a controlar directamente en qué momento
se quita un objeto de la memoria.
Por lo tanto vamos a poder acceder a estos atributos durante todo el tiempo que un objeto de la clase
aritmética esté disponible en memoria bien vamos a continuar vamos a poner entre comentarios este método
bien ahora lo que vamos a hacer es crear un objeto de la clase aritmética enviando los argumentos operando
AIB.
Así describimos lo siguiente
creamos un objeto de la clase de ética enviando los argumentos respectivos
creamos la variable llamada objeto uno de tipo aritmética y vamos a crear un nuevo objeto
utilizando la palabra reservada niu.
Posteriormente mandamos a llamar el constructor de dos argumentos Podemos se va que tenemos disponible
tanto el constructor sin argumentos como el constructor con dos argumentos así que vamos a utilizar
el constructor con dos argumentos
y vamos a enviar como valores el operando a las variables locales operando a y operando.
Entonces en resumen estas variables se conoce como variables locales debido a que únicamente se pueden
utilizar dentro del método donde han sido definidas como hemos visto ya no se pueden utilizar fuera
de otros métodos y en este momento como estamos dentro del método todavía entonces podemos seguir utilizando
las variables operando a y operando.
Y con esto ya estamos creando nuestro objeto aritmética se manda llamar el constructor de dos argumentos
y aparte estamos inicializar los atributos de nuestra clase y estos atributos como están definidos a
nivel de la clase entonces los vamos a poder acceder a lo largo de toda la clase en todos los métodos
que definamos así que con esto ya tenemos creado nuestro objeto aritmética y ahora vamos a imprimir
los valores de los operandos
mandamos a imprimir el valor del operando a
posteriormente el valor del operando de
guardamos cambios y ejecutamos
y podemos llevar ejecutando constructor con dos argumentos y posteriormente los valores de operando
a igual a 6 y operando ve igualados bien así que hasta el momento estamos utilizando nuestras variables
locales para inicializar nuestro objeto aritmética.
Posteriormente el objeto aritmética con los valores de las variables locales recibidas iniciales en
los atributos de la clase y una vez que hemos inicializar los atributos de El objeto aritmética.
Entonces podemos empezar a mandar a llamar.
Los métodos como sumar restar etc. Y también podemos observar que podemos imprimir y acceder a las variables
locales sin ningún problema si estamos dentro del mismo método donde se han definido estas variables
bien así que vamos a hacer lo siguiente mandamos el mensaje imprimimos el resultado de la suma
y ejecutamos lo siguiente.
Agregamos un salto de línea
resultado de la suma y utilizando la variable objeto uno que apunta al objeto aritmética que hemos creado
mandamos a llamar el método sumar guardamos cambios y ejecutamos y podemos observar resultado de la
suma seis más +2 que son los valores de los operandos es igual a 8.
Esto quiere decir que estamos pudiendo acceder sin ningún problema a los atributos de nuestra clase
a los valores que sean inicializar no al momento de mandar a llamar.
Este constructor y eso fue el momento de crear nuestro objeto aritmética.
Aquí simplemente estamos comprobando que podemos acceder a los valores de los atributos de nuestra clase
desde otros métodos así que podemos acceder a estos valores sin ningún problema debido a que estas variables
están definidas a nivel de la clase y ahora simplemente comprobamos las demás operaciones
imprimimos el resultado de la resta
y se van a utilizar los mismos valores de los atributos
pero se va a realizar diferente operación esta es la operación que se va a mandar a llamar la resta
pero vamos a utilizar los mismos atributos de nuestra clase guardamos cambios y ejecutamos
y podemos observar que habrá seis menos dos que son los valores de nuestros operandos el resultado de
la resta es igual a cuatro así que con eso estamos demostrando que podemos acceder a los atributos de
nuestra clase sin ningún problema.
A lo largo de toda la clase ahora imprimimos
el resultado de la multiplicación
usamos nuestra variable objeto 1 y mandamos a llamar el método multiplicar esta variable objeto 1.
También es una variable local ya que se ha definido dentro de este método main y por lo tanto no se
puede utilizar en otro método.
Sin embargo esta variable podríamos también definirla fuera del método main para que pudiera ser utilizada
en otros métodos.
De momento no lo vamos a hacer pero solamente los dejamos como comentario podrían hacer esta prueba.
Definir esta variable fuera del método main para poder ser accedida desde otros métodos bien guardamos
cambios y ejecutamos para ver el resultado de la multiplicación y vemos que el resultado de la multiplicación
de ejecutar 6 por 2 es igual a 12 así que estamos utilizando los atributos de la clase sin ningún problema
y finalmente imprimimos el resultado de la división
usamos la variable local objeto 1 y mandamos a llamar el método dividir
ejecutamos y podemos observar que 6 entre dos el resultado de la División 3 bien así que con eso hemos
puesto en práctica la definición de alcance de variables.
Hemos visto la diferencia entre variables locales y variables que son atributos de una clase.
Por último vamos a hacer un cambio una mejora a nuestra clase aritmética lo que vamos a hacer es utilizar
el concepto de operador dis el operador dis básicamente se puede utilizar dentro de una clase ya que
cuando creamos un objeto en este caso de la clase aritmética en esta línea cuando se crea este objeto
entonces también en automático el compilador de java crea una variable llamada VIS y esta variable lo
que hace es apuntar al objeto que se está creando.
El operador dis nos va a servir para poder acceder a los atributos y métodos de nuestra clase en el
momento en que se está realizando la ejecución de código de nuestra clase.
Por lo tanto por ejemplo en este caso el constructor podemos utilizar 10 punto y acceder al atributo
de nuestra clase.
Ahora podemos observar que esto realmente no es necesario ya que sin utilizar el operador dis pudimos
modificar y acceder al atributo de nuestra clase.
Sin embargo qué pasa si los argumentos de nuestro conductor ahora queremos llamarlos a IB
Por lo tanto estas variables deben de cambiar a IB.
Podemos observar que en este caso el argumento que estamos recibiendo en lugar de asignar el valor hacia
el atributo de nuestra clase se está utilizando el mismo argumento que estamos recibiendo para asignar
el valor a sí mismo.
Esto provoca una ambigüedad y para romper esta ambigüedad entonces tenemos que utilizar nuestro operador
dis para indicar que éste es el argumento que estamos recibiendo en el método y esto es el atributo
de nuestra clase así que por medio del operador dis vamos a hacer una diferencia y vamos a romper la
ambigüedad entre cual es el atributo de nuestra clase y cuál es el argumento o parámetro que estamos
recibiendo en este constructor y hacemos lo mismo con nuestra variable que ponemos dis punto
y entonces los valores que estamos recibiendo como argumentos en nuestro constructor se toma el valor
la variable que estamos recibiendo y se asigna al atributo de nuestra clase y por medio del operador
dis estamos indicando que este es el atributo de nuestra clase A y entonces el valor que recibimos se
asigna al atributo a y de igual manera el valor que recibimos en el argumento se asigna a nuestra variable
disputo que es el atributo de nuestra clase el atributo que incluso podemos observar que cambia el color
cuando es una variable local como en este caso un argumento del constructor el color podemos observar
que está en blanco pero cuando estamos utilizando el atributo de nuestra clase podemos observar que
el color está en morado y de igual manera en estos métodos cada una de estas variables está en morado.
Esto quiere decir que estas variables son los atributos de nuestra clase y no son variables locales
sino son variables que son atributos de nuestra clase y por lo tanto se pueden acceder a lo largo de
toda nuestra clase y como en este caso no tenemos ambigüedad de valores es opcional utilizar dis.
Así que en este caso simplemente por buena práctica podríamos utilizar dis la buena práctica viene del
hecho de que si observamos disputo algo en automático sabemos que estamos utilizando un atributo o método
de nuestra clase.
En cambio como podemos observar en este caso como no estamos utilizando DIS en automático sabemos que
es una variable local que puede ser un argumento recibido en este método o una variable definida.
Dentro de este método obviamente aquí parece que es irrelevante pero podemos tener métodos con muchas
líneas de código y entonces revisar constantemente en qué momento se definieron las variables podría
llegar a ser muy tedioso por lo tanto es buena práctica utilizar dis punto y posteriormente el nombre
del atributo de nuestra clase o el método de nuestra clase y de esta manera sabemos automáticamente
que si vemos dis punto algo entonces significa que es un atributo o método de nuestra clase y así rápidamente
hacer diferencia entre qué variables son atributos de una clase y qué variables son locales.
Como hemos comentado incluso élide hace estas diferencias al momento de utilizar colores pero también
para leer este código más rápido podemos utilizar dis así que vamos a agregar esta mejora en el uso
de cada una de nuestras variables que corresponden a atributos de nuestra clase
ahora esto es importante porque esto lo vamos a encontrar en todas las clases en todos los proyectos
Java en los que trabajemos así que es importante que tengamos claro el uso del operador dis así que
ya tenemos nuestros cambios en nuestra clase aritmética guardamos cambios y ejecutamos y podemos observar
que el resultado es exactamente el mismo.
Definimos los operandos OIV que son variables locales al método Mayne y posteriormente ejecutamos cada
una de las operaciones bien.
Por último vamos a ejecutar paso a paso esta clase ponemos un punto de ruptura en la línea de código
donde estamos creando nuestro objeto.
Aritmética damos el derecho de Buffy al podemos ver que ya se definieron las variables operando a y
operando.
Y vamos a entrar al detalle de la creación del objeto aritmética.
Para esto presionamos F7 o into y podemos observar que en automático el compilador ha creado esta variable
llamada dis ya que como hemos comentado a través de esta variable que se ha creado es que podemos hacer
referencia al objeto aritmética que se ha creado también en esta dirección de memoria.
Así que este operador dis hace referencia al objeto que se ha creado y que se está ejecutando en este
momento y como estamos dentro de la clase aritmética se ha creado este objeto en memoria y por lo tanto
apunta al objeto que se ha creado en esta dirección de memoria.
Una vez que salimos de la ejecución de esta clase entonces el operador dis cambia y apunta a otra clase.
Posteriormente vamos a ver un ejercicio de esto para que quede más claro pero básicamente en este momento
como se está creando un objeto de tipo aritmética entonces el operador dis apunta también a este objeto
que se está creando y podemos observar que esta variable que está creando el operador DIS es de tipo
aritmética ya que está apuntando a un objeto de tipo aritmética.
Vamos a abrir el detalle de esta variable y podemos observar que este operador dis puede acceder a los
atributos de esta clase A y ver respectivamente así que es precisamente lo que estamos haciendo a través
del operador dis estamos indicando dis punto a corresponde al atributo de esta clase y posteriormente
10 puntos.
Entonces hace referencia al atributo de nuestra clase.
En cambio estos valores son los que se están recibiendo como argumentos en este constructor y esta es
la variable que se está utilizando como argumento y posteriormente se utiliza para asignar el valor
al atributo de la clase tanto al valor de A como el valor de.
Así que si ejecutamos de nueva cuenta esta línea presionamos F8 vamos a observar cómo cambian los valores
por un lado podemos observar que diz hace referencia a los atributos de nuestra clase y contiene los
valores de cero ya que es el valor inicial de los atributos de nuestra clase pero por otro lado tenemos
los argumentos a y b que son los que estamos recibiendo en esta parte del código y aquí ya estamos recibiendo
los valores de 6 y 2 así que lo que vamos a hacer es asignar el valor de 6 al atributo de nuestra clase
A y el valor de que es el valor de 2 lo vamos a asignar al atributo.
Esto es lo que estamos haciendo con estas líneas de código bien así que vamos a comprobarlo presionamos
F8 y podemos ver que ya cambió el valor del atributo a ya cambió a 6 ya que este valor se asignó a la
tributo a y si presionamos de nueva cuenta F8 entonces ahora también ya se cambió el valor del atributo.
Así que de esta manera es como podemos utilizar el operador dis para rápidamente saber que estamos haciendo
referencia a atributos o métodos de nuestra clase y así si observamos el código en cada una de estas
operaciones entonces aunque no es necesario podemos saber que estas variables que estamos utilizando
en automático son atributos de nuestra clase debido a que estamos utilizando disputo y posteriormente
el atributo de nuestra clase bien terminamos de ejecutar esto presionamos F8 vemos en la consola y ya
tenemos el mensaje ejecutando constructor con dos argumentos presionamos F8 y aquí podemos continuar
ejecutando nuestro programa simplemente vamos a continuar ejecutando con F8 hasta terminar la ejecución
de nuestro programa ya que únicamente queremos mostrarles cómo es que se está creando este objeto y
el uso del operador dice y con esto estamos accediendo entonces a cada uno de los valores de los atributos
de nuestra clase en cada uno de los métodos que estamos ejecutando bien así que en esta elección hemos
visto varios temas como es el alcance de variables y también el uso del operador dice esto lo vamos
a seguir poniendo en práctica en las siguientes lecciones así que vamos a ver todavía más ejercicios
de cada uno de estos temas nos vemos en los siguientes videos.
Saludos.