sirve - redimensionar icon java

Inicializar un campo final estático en el constructor

Question

public class A 
{    
    private static final int x;

    public A() 
    {
        x = 5;
    }
}

• final significa que la variable solo se puede asignar una vez (en el constructor).
• static significa que es una instancia de clase.

No puedo ver por qué esto está prohibido. ¿Dónde interfieren esas palabras clave entre sí?

Answer 1

Piénsalo. Puedes hacer esto con tu código:

A a = new A();
A b = new A(); // Wrong... x is already initialised

Las formas correctas de inicializar x son:

public class A 
{    
    private static final int x = 5;
}

o

public class A 
{    
    private static final int x;

    static
    {
        x = 5;
    }
}

Answer 2

Piensa en lo que sucede la segunda vez que instancias un objeto. Intenta volver a establecerlo, lo que está expresamente prohibido por ser un final estático. Solo se puede establecer una vez para toda la clase, no para instancia.

Debes establecer el valor cuando lo declaras

private static final x=5;

Si necesita lógica adicional o instanciación más compleja, esto se puede hacer en un bloque de inicializador estático.

Answer 3

Se llamará a un constructor cada vez que se cree una instancia de la clase. Por lo tanto, el código anterior significa que el valor de x se reinicializará cada vez que se cree una instancia. Pero como la variable se declara final (y estática), solo puedes hacer esto

class A {    
    private static final int x;

    static {
        x = 5;
    }
}

Pero, si elimina la estática, puede hacer esto:

class A {    
    private final int x;

    public A() {
        x = 5;
    }
}

O esto:

class A {    
    private final int x;

    {
        x = 5;
    }
}

Answer 4

las variables finales estáticas se inicializan cuando se carga la clase. El constructor puede llamarse mucho más tarde, o no llamarse en absoluto. Además, el constructor se llamará varias veces (con cada objeto nuevo), por lo que el campo ya no puede ser final.

Si necesita una lógica personalizada para inicializar su campo final estático, póngalo en un bloque estático

Answer 5

static significa que la variable es única en la aplicación. final significa que debe establecerse solo una vez.

Si lo configura en su constructor, permite establecer la variable más de una vez.

Por lo tanto, debe inicializarlo directamente o proponer un método estático para inicializarlo.

Answer 6

Final no significa que deba inicializarse en el constructor. En general, esto es lo que se hace:

 private static final int x = 5;

static significa que la variable se compartirá a través de varias instancias de la clase. Por ejemplo :

public class Car {
   static String name;
   public Car(String name) {
      this.name = name;
   }
}

...

Car a = new Car("Volkswagen");
System.out.println(a.name); // Produces Volkswagen

Car b = new Car("Mercedes");
System.out.println(b.name); // Produces Mercedes
System.out.println(a.name); // Produces Mercedes

Answer 7

    public class StaticFinalExample {
  /*
   * Static final fields should be initialized either in
   * static blocks or at the time of declaration only
   * Reason : They variables are like the utility fields which should be accessible
   * before object creation only once.
   */
  static final int x;

  /*
   * Final variables shuould be initialized either at the time of declaration or
   * in initialization block or constructor only as they are not accessible in static block
   */
  final int y;

  /*
   * Static variables can be initialized either at the time of declaration or
   * in initialization or constructor or static block. Since the default value is given to the
   * static variables by compiler, so it depends on when you need the value
   * depending on that you can initialize the variable appropriately
   * An example of this is shown below in the main method
   */
  static int z;

  static {
    x = 20; // Correct
  }
  {
    y = 40; // Correct
  }
  StaticFinalExample() {
    z = 50; // Correct
  }
  public static void main (String args[]) {
    System.out.println("Before Initialization in Constructor" + z);   // It will print 0
    System.out.println("After Initializtion in Constructor" + new StaticFinalExample().z); // It will print 50
  }
}