Valores predeterminados e inicialización en Java

Según mi referencia , los tipos primitivos tienen valores predeterminados y los Objetos son nulos. Probé una pieza de código.

public class Main { public static void main(String[] args) { int a; System.out.println(a); } } 

La línea System.out.println(a); será un error que apunta a la variable a que dice que la variable a might not have been initialized mientras que en la referencia dada, integer tendrá 0 como valor predeterminado. Sin embargo, con el código dado a continuación, realmente imprimirá 0 .

 public class Main { static int a; public static void main(String[] args) { System.out.println(a); } } 

¿Qué podría salir mal con el primer código? ¿La variable de instancia de clase se comporta diferente de las variables locales?

En la primera muestra de código, a es una variable local de método main . Las variables locales del método deben inicializarse antes de usarlas.

En el segundo ejemplo de código, a es a variable de miembro de clase, por lo tanto, se inicializará al valor predeterminado.

Lea más detenidamente su referencia :

Valores predeterminados

No siempre es necesario asignar un valor cuando se declara un campo . Los campos declarados pero no inicializados se establecerán en un valor razonable predeterminado por el comstackdor. En general, este valor predeterminado será cero o nulo, según el tipo de datos. Sin embargo, confiar en dichos valores predeterminados generalmente se considera un mal estilo de progtwigción.

El siguiente cuadro resume los valores predeterminados para los tipos de datos anteriores.

. . .

Las variables locales son ligeramente diferentes; el comstackdor nunca asigna un valor predeterminado a una variable local no inicializada. Si no puede inicializar su variable local donde está declarada, asegúrese de asignarle un valor antes de intentar usarla. El acceso a una variable local no inicializada dará como resultado un error en tiempo de comstackción.

Estos son los principales factores involucrados:

  1. variable miembro (por defecto OK)
  2. variable estática (por defecto OK)
  3. variable miembro final (no inicializada, debe establecerse en el constructor)
  4. variable estática final (no inicializada, debe establecerse en un bloque estático {})
  5. variable local (no inicializada)

Nota 1: ¡debe inicializar las variables de miembros finales en TODOS los constructores implementados!

Nota 2: debe inicializar las variables miembro finales dentro del bloque del propio constructor, sin llamar a otro método que las inicialice. Por ejemplo, esto NO es válido:

 private final int memberVar; public Foo() { //invalid initialization of a final member init(); } private void init() { memberVar = 10; } 

Nota 3: las matrices son objetos en Java, incluso si almacenan primitivas.

Nota 4: cuando inicializa una matriz, todos sus elementos están configurados de manera predeterminada, independientemente de ser un miembro o una matriz local.

Adjunto un ejemplo de código, presentando los casos antes mencionados:

 public class Foo { //static and member variables are initialized to default values //primitives private int a; //default 0 private static int b; //default 0 //objects private Object c; //default NULL private static Object d; //default NULL //arrays (Note: they are objects too, even if they store primitives) private int[] e; //default NULL private static int[] f; //default NULL //what if declared as final? //primitives private final int g; //not initialized, MUST set in constructor private final static int h; //not initialized, MUST set in a static {} //objects private final Object i; //not initialized, MUST set in constructor private final static Object j; //not initialized, MUST set in a static {} //arrays private final int[] k; //not initialized, MUST set in constructor private final static int[] l; //not initialized, MUST set in a static {} //initialize final statics static { h = 5; j = new Object(); l = new int[5]; //elements of l are initialized to 0 } //initialize final member variables public Foo() { g = 10; i = new Object(); k = new int[10]; //elements of k are initialized to 0 } //A second example constructor //you have to initialize final member variables to every constructor! public Foo(boolean aBoolean) { g = 15; i = new Object(); k = new int[15]; //elements of k are initialized to 0 } public static void main(String[] args) { //local variables are not initialized int m; //not initialized Object n; //not initialized int[] o; //not initialized //we must initialize them before usage m = 20; n = new Object(); o = new int[20]; //elements of o are initialized to 0 } } 

Hay algunas cosas a tener en cuenta al declarar valores de tipo primitivos.

Son:

  1. Los valores declarados dentro de un método no se asignarán a un valor predeterminado.
  2. Los valores declarados como variable instanciada o una variable estática tendrán valores predeterminados asignados que es 0.

Entonces en tu código:

 public class Main { int instanceVariable; static int staticVariable; public static void main(String[] args) { Main mainInstance = new Main() int localVariable; int localVariableTwo = 2; System.out.println(mainInstance.instanceVariable); System.out.println(staticVariable); // System.out.println(localVariable); //will throw comstacktion error System.out.println(localVariableTwo); } } 

sí, la variable de instancia se inicializará al valor predeterminado, para la variable local que necesita inicializar antes de usar

 public class Main { int instaceVariable; // Instance variable will be initalized to default value public static void main(String[] args) { int localVariable = 0; // Local Variable Need to initalize before use } } 

Las variables locales no obtienen valores predeterminados. Sus valores iniciales no están definidos sin asignar valores por algún medio. Antes de poder usar variables locales, deben inicializarse.

Hay una gran diferencia cuando declaras una variable a nivel de clase (como miembro, es decir, como un campo) y a nivel de método.

Si declaras un campo en el nivel de clase, obtienen valores predeterminados de acuerdo con su tipo. Si declara una variable a nivel de método o como un bloque (significa cualquier código dentro de {}) no obtiene ningún valor y permanece indefinido hasta que de alguna manera obtiene algunos valores iniciales, es decir, algunos valores asignados a ellos.

Todas las variables miembro tienen que cargarse en el montón, por lo que deben inicializarse con los valores predeterminados cuando se crea una instancia de clase. En el caso de las variables locales, no se cargan en el montón, se almacenan en la stack hasta que se utilicen antes de Java 7, por lo que debemos inicializarlas explícitamente.

En Java, la inicialización predeterminada es aplicable solo a la variable de instancia del miembro de la clase, no es aplicable a las variables locales.