Más sobre el alcance de la variable

"El profesor simplemente no puede salir de su rutina. Los viejos maestros que están acostumbrados a dar conferencias siempre son así. No hay nada que pueda decirte que no puedas encontrar en los libros. No aprendes a nadar escuchando" . a conferencias de natación. Las conferencias solo son útiles cuando estás familiarizado con el tema y sabes casi tanto como tu profesor".

"Aún así, sus lecciones son útiles".

"Sí. Quiero decir, esperamos que lo sean. Cuantas más perspectivas sobre el tema escuches, más te acercarás a la verdad. Cuando escuches solo una, todo lo que puedes hacer es creerla o no creerla. volver al negocio".

"Veamos una foto que te he mostrado antes".

┏
┃public class Variables
┃┏
┃┃{
┃┃   private static String TEXT = "The end.";
┃┃  ┗━━━━━━━━━━━━━━━━━━━┛
┃┃   public static void main (String[] args)
┃┃ ┏                         ┗━━━━━━━┛
┃┃ ┃ {
┃┃ ┃    System.out.println("Hi");
┃┃ ┃    String s = "Hi!";
┃┃ ┃  ┏┗━━━━┛
┃┃ ┃  ┃ System.out.println(s);
┃┃ ┃  ┃ if (args != NULL)
┃┃ ┃  ┃ {
┃┃ ┃  ┃    String s2 = s;
┃┃ ┃  ┃   ┗━━━━┛
┃┃ ┃  ┃  ┏
┃┃ ┃  ┃  ┃ System.out.println(s2);
┃┃ ┃  ┃  ┗
┃┃ ┃  ┃ }
┃┃ ┃  ┃ Variables variables = new Variables();
┃┃ ┃  ┃ System.out.println(variables.instanceVariable);
┃┃ ┃  ┃ System.out.println(TEXT);
┃┃ ┃  ┗
┃┃ ┃ }
┃┃ ┗
┃┃   public String instanceVariable;
┃┃  ┗━━━━━━━━━━━━━━━┛
┃┃   public Variables()
┃┃   {
┃┃      instanceVariable = "Instance variable test.";
┃┃   }
┃┃}
┃┗
┗

1. Una variable declarada en un método existe (es visible) desde el inicio de su declaración hasta el final del método.

2. Una variable declarada en un bloque de código existe hasta el final del bloque de código.

3. Los parámetros de un método existen hasta que el método regresa.

4. Las variables en un objeto existen durante toda la vida útil del objeto que las contiene. Su visibilidad también se rige por modificadores de acceso especiales.

5. Las variables estáticas (de clase) existen todo el tiempo que se ejecuta el programa. Su visibilidad también está definida por modificadores de acceso".

"Cierto. Recuerdo esta foto".

"Genial. Déjame recordarte algunos puntos clave".

"Todas las variables declaradas dentro de los métodos existen (son visibles) desde el punto donde se declaran hasta el final del método (Ejemplo 1)".

"Si una variable se declara en un bloque de código, existe hasta el final del bloque de código (Ejemplo 2)".

"Si una variable es un parámetro de método, existe (es visible) en todo el cuerpo del método (Ejemplo 3)".

"Si una variable es una variable de instancia (Ejemplo 4), está vinculada a un determinado objeto y existe mientras exista el objeto. Si no existe ningún objeto, entonces no hay instancias de la variable. Puede acceder a la variable (es decir, la variable es visible) desde todos los métodos de la clase, independientemente de si se declararon antes o después de ella. Se crea una nueva variable para cada objeto. Es independiente de otros objetos. No puede acceder a una variable de instancia desde métodos estáticos . "

"Si una variable se declara estática, es decir, se marca con la palabra clave static , existe mientras exista su clase. La JVM generalmente carga una clase en la memoria en su primer uso. También es cuando se inicializan las variables estáticas".

"El ejemplo anterior declara la clase Cat, que tiene cuatro variables: a, b, s (variables no estáticas) y count (una variable estática). Si creamos varios objetos de esta clase (digamos, tres), cada uno de ellos ellos contendrán sus propias instancias de las variables no estáticas de la clase. Una variable estática es compartida por todos los objetos de una clase. Técnicamente hablando, ni siquiera está dentro de estos objetos, ya que existía incluso antes de que se crearan los objetos Cat ".

"Esto es lo que sucede si declaramos la variable sestática:"

"Está bien. Creo que lo entiendo".

"¿Puedes declarar variables con el mismo nombre?"

"No dentro de un método. Todas las variables declaradas dentro de un método deben tener nombres únicos. Los argumentos de un método también se consideran variables locales".

"¿Qué pasa con las variables miembro?"

"Las variables miembro también deben ser únicas para cada clase".

"Pero hay una excepción: los nombres de las variables locales y las variables miembro pueden ser idénticos " .

"Si cambiamos tal variable, ¿cuál de las dos variables con nombres idénticos cambiará?"

"Si hay varias variables visibles (accesibles) en nuestro código, por ejemplo, una variable de instancia y una variable local, se accederá a la variable local".

class Main
{
    public int count = 0;     // Declare an instance variable

    public void run()
    {
        count = 15;           // Access the instance variable
        int count = 10;       // Declare a local method variable
        count++;             // Access the method variable
    }
}

"Este código declara dos variables de conteo. La línea 3 declara una variable de instancia y la línea 8, una variable local ".

"Esto es lo que sucede cuando se ejecuta el método de ejecución:"

"En la línea 7, accedemos a la variable de instancia y le asignamos el valor 15"

"En la línea 8, declaramos (creamos) una nueva variable local : count. Enmascara la variable de instancia. La variable local es lo que verá todo el código posterior en el método (acceso)".

"Entiendo."

"La variable local enmascara la variable de instancia. En otras palabras, la variable local es a la que se accede. Sin embargo, también puede acceder a la variable de instancia. Es un poco más complicado hacerlo".

ClassName.variableName

// Here are some examples:
Cat.catsCount

this.variableName

// Here are some examples:
this.catsCount

"¿Qué más puedes decirme sobre métodos estáticos y variables estáticas?"

"Los métodos estáticos y las variables no están vinculados a los objetos de la clase, están vinculados a la clase misma. Si creamos diez objetos Variables (ver el ejemplo al comienzo de este nivel), tendremos diez variables InstanceVariable (una para cada object) y solo una variable compartida (estática) TEXT ".

"Tengo una pregunta."

"¿Cuál es la diferencia entre los métodos estáticos y no estáticos?"

"Veamos cómo funciona un método no estático:"

Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);

Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat,17);
Cat.setChildren(cat, cat1, cat2, cat3);

"Cuando llamas a un método usando <object> dot <method name> , en realidad estás llamando a un método de clase y pasando ese mismo objeto como primer argumento. Dentro del método, el objeto se llama 'this' . Todas las operaciones en el se realizan en este objeto y sus datos".

"¡Guau! ¡Así es como funciona todo!"

"Y así es como funciona un método estático".

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

"Cuando llamas a un método estático, no se le pasa ningún objeto. En otras palabras, 'esto' es igual a nulo . Es por eso que un método estático no puede acceder a variables y métodos no estáticos (ya que no tiene 'esto' para pasar a estos métodos)".

"Hmmm. Creo que lo entiendo. Al menos un poco".

"Y aquí viene el tío Diego... y sus tareas".