Matices de trabajar con variables

constantes

"Amigo, ¿sabías que en Java no se pueden cambiar todas las variables?"

"¿Cómo es eso, Kim? De hecho, la misma palabra 'variable' habla de cambio".

"No hay duda de eso. Como muchos otros lenguajes de programación, Java tiene constantes , es decir, variables cuyos valores no se pueden cambiar . Y la misma palabra 'constante' habla de constancia".

"¿Y para qué sirven?"

“Por lo general, se usan para algún tipo de cosa fundamental como el número Pio la cantidad de días en los meses del año. Dicho esto, en principio, un programador puede convertir cualquier variable en constante, si él o ella decide que haciendo así es necesario".

"¿Te refieres a un nombre, color de un auto o nombre de un día de la semana?"

"Tienes la idea correcta. Cualquier cosa que no deba cambiarse".

"¿Y cómo se ven estas constantes en Java?"

"Java tiene una palabra clave especial para ellos: final. Crear una variable inmutable tiene el mismo aspecto que crear una normal. La única diferencia es que antes del tipo de variable debe escribir la palabra final, así:

final Type name = value;

"¿Qué sucede si creas una constante y luego intentas asignarle un valor diferente?"

"¡Esa es la pregunta correcta! Y la respuesta correcta es esta: si intenta asignar un valor diferente a una finalvariable, entonces su programa simplemente no compilará".

"¿Qué pasa si declaras una finalvariable pero no le asignas un valor?"

"No tiene sentido hacer esto, por lo que tampoco está permitido en Java. Una finalvariable debe inicializarse cuando se declara, es decir, debe asignarle un valor. Hay una excepción a esta regla: puede mover la inicialización de una variable de clase estática en un constructor, pero lo aprenderá más adelante.

"Dicho esto, no todo lo que es finales una constante. Para reducir la cantidad de palabras clave, los desarrolladores de Java usan la palabra finalpara algo más que declarar constantes. finalTambién se puede aplicar a métodos e incluso clases. Los métodos declarados como finalno se pueden anular, y una clase declarada como finalno heredable”.

"Uh... ¿Anulado? ¿Heredado? ¿Qué idioma estás hablando ahora?"

"El lenguaje de la programación orientada a objetos. Muy pronto llegará a él. Hasta entonces, simplemente disfrute de la hermosa terminología".

"Está bien. Entonces, final¿se puede poner antes de variables, clases y métodos, y esta palabra clave los hace inmutables en algún sentido?"

"Sí. Además, el finalmodificador se puede agregar antes de cualquier variable: variables locales, parámetros de método, campos de clase y variables de clase estática.

"Aquí está lo importante que debe recordar: finalantes, el nombre de una variable es solo una protección contra cualquier cambio en esa variable . Si una variable almacena una referencia a un objeto, entonces el objeto aún se puede cambiar".

"No entiendo muy bien".

"Lo entenderás muy pronto. Aquí hay un ejemplo:

final int[] data = {1, 2, 3, 4, 5, 6};

data = {6, 7, 8, 9};

data[0] = 0;
data[1] = 0;
data[2] = 0;

"Entendido. Eso es complicado".

constantes globales

"¿Qué crees que son las constantes globales?"

"Supongo que las constantes globales son probablemente como variables globales, ¿solo constantes?"

"Exactamente. Si necesita declarar constantes globales en su programa, cree variables de clase estáticas y conviértalas publicen y final. Hay un estilo especial para los nombres de tales variables: están escritos en letras mayúsculas, con un carácter de subrayado que se usa para palabras separadas.

Ejemplos:

class Solution
{
   public static final String SOURCE_ROOT = "c:\\projects\\my\\";
   public static final int DISPLAY_WIDTH = 1024;
   public static final int DISPLAY_HEIGHT = 768;
}

Sombreado variable

"Como dije antes, no puede crear múltiples variables locales con los mismos nombres en un solo método. En diferentes métodos, puede hacerlo".

"¡Yo sé eso!"

"Pero lo que probablemente no sepa es que las variables de una clase y las variables locales de un método pueden tener el mismo nombre.

Ejemplo:

public class Solution
{
   public int count = 0;
   public int sum = 0;

   public void add(int data)
   {
     sum = sum + data;
     int sum = data * 2;
     count++;
   }
}

count, sum
count, sum
count, sum
count, sum
count, sum
count, sum, data
count, sum, data
count, sum, data
count, sum, data
count, sum

"En el addmétodo, declaramos una variable local llamada sum. Hasta el final del método, oculta (o enmascara ) la sumvariable de instancia".

"Hmm... Diría que, en cierto sentido, este es el comportamiento esperado".

"Pero ese no es el final de la historia. Resulta que si una variable de instancia está sombreada por una variable local, todavía hay una manera de referirse a la variable de instancia dentro del método. Hacemos esto escribiendo la palabra clave antes de su thisnombre :

this.name

"Aquí hay un ejemplo donde el conflicto de nombres se resuelve con éxito:

public class Solution
{
   public int count = 0;
   public int sum = 0;

   public void add(int data)
   {
     int sum = data * 2;
     this.sum = this.sum + data;
     count++;
   }
}

this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum, data
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum

Las variables county sumestán disponibles en todas partes con o sin la thispalabra clave. En las líneas donde la sumvariable local sombrea la sumvariable de instancia, sumsolo se puede acceder a la variable de instancia usando la thispalabra clave.

"Obviamente, tendré que practicar esto".

Te las arreglarás.

"¿Qué pasa si una variable de clase estática está sombreada en lugar de solo una variable de instancia (no estática)? ¿No puede acceder a ella a través de this?"

"Tienes razón. Esta palabra clave no funcionará. Debes referirte a ella a través del nombre de la clase:

ClassName.name

Ejemplo:

public class Solution
{
   public static int count = 0;
   public static int sum = 0;

   public void add(int data)
   {
     int sum = data * 2;
     Solution.sum = Solution.sum + data;
     count++;
   }
}

Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum, data
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum

"Presta atención: puedes acceder a las variables estáticas county sumen todas partes con o sin usar el nombre de la clase Solutioncomo prefijo. En aquellas líneas donde la sumvariable local sombrea la sumvariable de instancia, el acceso a la sumvariable de clase solo es posible cuando se usa Solutioncomo prefijo.

Variables dentro de un forbucle

"Y un hecho más pequeño pero interesante. También hay un lugar donde una variable se declara de una manera especial: estoy hablando dentro de un forciclo ". Normalmente, un forbucle tiene una countervariable entre paréntesis. ¿Y cuál será la visibilidad de esta variable? Después de todo, no está en el cuerpo del bucle. ¿Es todo el método? ¿O no?"

"Ya escuché algo sobre esto. Según tengo entendido, una variable declarada en el encabezado de un forciclo es visible solo en el cuerpo del ciclo y en el encabezado del forciclo ".

"Bien hecho, Amigo. Pero aún así, echa un vistazo a un ejemplo para reforzar este material:

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a

"Entonces, ¿está diciendo que en mi código podría escribir varios bucles uno tras otro con una variable de contador con el mismo nombre, y no habría problemas?"

"No habría problemas. Aquí, mira:

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   for (int i = 0; i < 10; i--)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a, i
a, i
a, i
a
a
a