Bien vamos a continuar con nuestro ejercicio de ejemplo estático ya tenemos nuestra clase de persona
con los atributos no estáticos es decir los que se asocian con nuestros objetos y su método estático
es decir los que se asocian con la clase.
Ahora vamos a nuestra clase.
Ejemplo estático agregamos un método main
damos formato y vamos a hacer lo siguiente Vamos a crear un primer objeto de tipo persona así que creamos
una primer variable llamada Persona 1 y creamos un primer objeto de tipo Persona y debido a que ya hemos
declarado un constructor diferente de evasión entonces tenemos que proporcionar un valor en este caso
el valor de nombre el valor de Juan ya que el compilador ya no nos va a agregar el constructor vació
Podemos será que nos está marcando un error ya que no encuentra el constructor sin argumentos y requiere
de un tipo string así que eso ya lo debemos de tener claro el uso de constructores bien ahora como siguiente
paso vamos a imprimir el objeto persona lo podemos mandar a imprimir directamente ya que hemos definido
el método string en nuestra clase persona podemos ver que ya se ha definido este método y por lo tanto
cada vez que mandamos a imprimir un objeto persona en método Elene en automático va a mandar a llamar.
El método Tsering para saber el estado del objeto.
Esto quiere decir cada uno de los valores de cada atributo estático o no estático de nuestra clase así
que guardamos cambios y ejecutamos
y podemos observar que en este caso el Eugui persona se le asignó el valor de 1 debido a que podemos
observar que el contador de personas se inicia el hizó con 1.
Esto es debido a que utilizamos primero más más y posteriormente la variable.
Esto quiere decir que es un pre incremento así que primero se incrementa la variable.
Recordemos que su valor por default a ser un tipo entero su valor por default es cero y entonces al
agregar un incremento se incrementa el valor de esta variable pasa a ser 1 así que este valor de 1 se
le asigna al primer objeto que estamos creando.
Por lo tanto Airy persona la primera vez vale 1.
Posteriormente vemos el valor de Juan y finalmente el valor de Contador personas la variable Contador
personas estatica contiene el valor de 1 pero vamos a crear un segundo objeto para saber exactamente
como funciona el contexto estático así que vamos a crear una segunda variable.
Persona 2 creamos un nuevo objeto le pasamos el valor de Carla
y mandamos a imprimir la variable Persona 2 guardamos cambios y ejecutamos
y Podemos se va que en este caso la variable Contador personas ya contiene el valor de 2.
Por lo tanto el Heydi persona del siguiente objeto que se ha creado se le asignó el valor de 2 y podemos
observar entonces que cada uno de los objetos está accediendo al valor Contador persona y este valor
no se está compartiendo por cada objeto.
De lo contario esta variable se estaría reiniciando.
Cómo podemos comprobar esto.
Si en lugar de que esta variable sea estática le quitamos el modificador de acceso estático por lo tanto
también en el método de Contador personas hacemos estos cambios guardamos cambios y ejecutamos.
Entonces podemos observar que esta variable Contador personas se asocia con cada objeto ya que no es
de tipo estático y esto es lo que provoca es que ya no funciona como una variable de tipo Contador sino
que por cada objeto se reinicia el valor de esta variable contador de personas ya que al no ser de tipo
estático entonces su valor inicial siempre va a ser cero y cuando se utiliza más más Contador entonces
simplemente se incrementa en 1 así que todos los objetos que creemos se van a inicializar sus valores
no va a funcionar como esperamos ya no va a contabilizar cuántos objetos se han creado de tipo persona
así que con esto ya nos empieza a quedar más claro el uso de contexto estático ya que estos atributos
o métodos se asocian con la clase y no con los objetos no con las instancias y así si creamos más objetos
de tipo persona
entonces el contador de personas se va a ir incrementando en 1
así que imprimimos el valor del objeto persona 3 y podemos observar que el valor del contador personas
ya va en 3 y por lo tanto el Heydi persona ya contiene el valor de 3.
Y si mandamos a imprimir únicamente el valor del contador personas podemos hacer lo siguiente.
Contador personas pero recordemos que este atributo es estático.
Por lo tanto para acceder no vamos a utilizar alguna de las instancias alguno de los objetos como puede
ser persona 1 2 o 3 sino que vamos a utilizar el nombre de la clase ya que así es como se utilizan los
atributos o métodos estáticos.
Así que vamos a poner el nombre de la clase.
Punto.
El método estático en este caso el único método estático que tenemos es el método GET Contador personas
así que mandamos a llamar el método estático.
Ejecutamos y podemos ver que en este caso el valor de la variable Contador personas va en 3 así que
no se ha reiniciado en ningún momento ya que este valor se asocia con la clase y aunque podemos mandar
a llamar este método utilizando alguna de las variables que apunte alguno de los objetos que hemos creado
esto no es recomendable.
Incluso el IDE nos marca este warning que reemplazamos con la referencia de la clase y si damos clic
nos cambia el nombre de la variable por el nombre de la clase ya que no es recomendable acceder a los
atributos estáticos a través de las instancias de una clase.
En este caso a través de una variable que apunta a una instancia de una clase.
Sin embargo funciona debido a que hemos comentado que el contexto dinámico puede acceder al contexto
estático pero no al revés el contexto estático no puede acceder al contexto dinámico eso también lo
podemos comprobar de la manera siguiente por ejemplo si ponemos el nombre de la clase únicamente podemos
observar todo lo que sea estático.
En este caso lo que es público el método GET Contador personas que es de tipo estático pero no podemos
acceder a los atributos como puede ser G.T nombre en este caso no podemos acceder ya que nos manda el
mensaje que el método nombre es no estático y lo estamos queriendo referenciar desde un contexto estático
es decir desde el nombre de la clase y como hemos comentado el contexto estático no puede acceder al
contexto dinámico ya que desde el nombre de la clase no puede acceder a los objetos así que básicamente
lo que hemos hecho hasta el momento tenemos nuestra clase persona
y aquí estamos en el contexto estático
ahora cuando se carga esta clase de memoria la primera vez que una línea de código y necesita de la
clase persona en este caso la primera vez que ubica esta clase es cuando se carga en memoria.
Así que en ese momento es cuando todo el contexto estático se inicia ya que esta clase se carga en memoria
y todo lo que sea referente al contexto estático se empieza a ejecutar posteriormente.
Una vez que ya empiezan las siguientes líneas de código y empezamos a ejecutar la creación de objetos
entonces
ya tenemos el contexto dinámico
y es cuando estamos empezando a crear estos objetos
y se están creando las variables que apuntan a estos objetos.
La variable por ejemplo Persona 1 que apunta este objeto la variable personados que apunta este objeto
y la variable Persona 3 que apunta a este objeto y cada uno de los objetos va a utilizar el contador
personas pero recordemos que ese es un atributo estático.
Así que la variable Contador personas
se asocia con la clase ya que es un atributo estático y por lo tanto cada vez que modifiquemos este
valor por ejemplo el valor de uno todos los objetos van a ver este mismo valor si se cambia a 2.
Entonces todos los objetos van a ver ese mismo valor etcétera y como hemos visto si no fuera estático
entonces este valor en lugar de asociarse con la clase se asociaría con cada uno de los objetos y por
lo tanto si ponemos el valor de uno entonces este objeto ya no puede ver ese valor ya que cada uno de
los objetos contendría sus propios valores.
Por lo tanto esta variable ya no funcionaría como un contador de personas de objetos de tipo persona
sino que se inicializar ya con cada creación de cada objeto y ya no cumpliría con el objetivo del ejercicio
que estamos creando.
Finalmente vamos a ejecutarlo paso a paso simplemente para que cualquier duda la podamos despejar así
que ponemos un punto de ruptura.
Damos clic derecho y posteriormente de Buffy vamos a presionar F7 para entrar al detalle de la construcción
de la clase y podemos observar que el operador dis hace referencia al contexto dinámico.
Por lo tanto no puede acceder directamente al atributo estático Contador personas pero podemos observar
que tenemos además el contexto estático así que en este caso el contexto estático es el atributo Contador
personas pero directamente no puede hacer uso del contexto estático.
Para ello es que se debe de utilizar el nombre de la clase en este caso como estamos dentro de la clase
simplemente vamos a omitir el uso de Viz ya que no puede acceder a los atributos que sean estáticos
únicamente a los atributos no estáticos así que ejecutamos y observamos entonces que el contador de
personas se va a incrementar en uno.
En este caso vale cero el Heydi persona también todavía contiene el valor de cero ya que su valor por
Defour.
Pero si ejecutamos esta línea entonces el contador de personas ya se incrementó en 1 y se le asignó
este valor al de persona y posteriormente asignamos el nombre que estamos recibiendo de Juan al atributo
de nombre de nuestra clase y podemos observar que la variable estática ya se incrementó en 1 ya vale
1 y 10 puede acceder a los atributos dicha persona con el valor de 1 y el nombre igual a igual presionamos
F8 y mandamos a imprimir.
Podemos observar en consola los valores de dispersión igual a 1 nombre Juan y Contador persona igual
a 1 y vamos a entrar a la creación del segundo objeto para que veamos cómo en la variable Contador personas
no se está reiniciando ya que debido a que se asocia con la clase y no con los objetos entonces su valor
sigue siendo 1.
En cambio el la persona su valor ya se reinició a cero y de igual manera el atributo de nombre que es
de tipo String.
Recordemos que el valor por default es nulo es decir ausencia de valor presionamos f 8 y podemos observar
que en esta línea se va a incrementar de nueva cuenta la variable Contador personas que se estatica
y se le va a asignar el valor a persona así que podemos observar que en este caso ya se incrementó esta
variable estática a 2 y se le asigna este valor a la variable Heydi persona así que de esta manera estamos
simulando con esta variable estática cuántos objetos de tipo Persona se han creado en este momento se
han creado dos objetos de tipo Persona y finalmente asignamos el valor que estamos mandando a este constructor
el valor de carga lo asignamos al atributo de nombre y mandamos a imprimir y podemos observar que ahora
el valor de Heydi persona es igual a 2.
El nombre es Carla y nuestra variable estática Contador personas no se ha reiniciado ya que se asocia
con la clase y contiene el valor de dos y así sucesivamente si volvemos a ejecutar ahora observamos
que nuestra variable Contador personas se continúa incrementando y vale 3 así que ya tenemos 3 objetos
de tipo persona creado.
Por lo tanto también el Heydi persona que se le asigna a este atributo es el valor de 3 con el nombre
de Carlos y finalmente mandamos a imprimir nuestra variable Contador persona vamos a presionar F7 para
entrar al detalle y debido a que estamos dentro del método LN En este caso no nos interesa ejecutar
paso a paso este método para salirnos de este método vamos a presionar este auto y finalmente presionamos
de nueva cuenta F8 para ver el valor del contador persona y podemos observar que en este caso la variable
Contador persona quedó en 3 así que con esto hemos puesto en práctica el concepto de contexto estático
ya lo estamos combinando con el uso de nuestros objetos.
Hemos visto varias de las restricciones que contiene el contexto estático y lo pusimos en práctica con
un ejemplo real para que quede más claro el uso del contexto estático.
Eso es todo por esta elección y nos vemos en el siguiente video.
Saludos.