it-swarm.com.de

Initialisieren Sie ein statisches abschließendes Feld im Konstruktor

public class A 
{    
    private static final int x;

    public A() 
    {
        x = 5;
    }
}
  • final bedeutet, dass die Variable nur einmal (im Konstruktor) zugewiesen werden kann.
  • static bedeutet, dass es sich um eine Klasseninstanz handelt.

Ich kann nicht verstehen, warum dies verboten ist. Wo stören sich diese Keywords?

79
Yaron Levi

Ein Konstruktor wird jedes Mal aufgerufen, wenn eine Instanz der Klasse erstellt wird. Daher bedeutet der obige Code, dass der Wert von x jedes Mal, wenn eine Instanz erstellt wird, neu initialisiert wird. Da die Variable jedoch als final (und statisch) deklariert ist, können Sie dies nur tun

class A {    
    private static final int x;

    static {
        x = 5;
    }
}

Wenn Sie jedoch statisch entfernen, können Sie Folgendes tun:

class A {    
    private final int x;

    public A() {
        x = 5;
    }
}

Oder dieses:

class A {    
    private final int x;

    {
        x = 5;
    }
}
169
adarshr

statische letzte Variablen werden beim Laden der Klasse initialisiert. Der Konstruktor kann später oder gar nicht aufgerufen werden. Außerdem wird der Konstruktor mehrmals aufgerufen (mit jedem neuen Objekt), sodass das Feld nicht mehr als endgültig definiert werden kann.

Wenn Sie eine benutzerdefinierte Logik zum Initialisieren Ihres statischen letzten Felds benötigen, setzen Sie diese in einen statischen Block

16

Denken Sie darüber nach, was passiert, wenn Sie ein Objekt zum zweiten Mal instanziieren. Es wird versucht, es WIEDER festzulegen, was ausdrücklich verboten ist, weil es ein statisches Finale ist. Es kann nur einmal für die gesamte Klasse festgelegt werden, nicht für die Instanz.

Sie sollten den Wert bei der Deklaration festlegen

private static final x=5;

Wenn Sie zusätzliche Logik oder eine komplexere Instanziierung benötigen, können Sie dies in einem statischen Initialisierungsblock tun.

6
rfeak

static bedeutet, dass die Variable in der Anwendung eindeutig ist .final bedeutet, dass sie nur einmal gesetzt werden sollte.

Wenn Sie es in Ihrem Konstruktor festlegen, können Sie die Variable mehrmals festlegen.

Daher sollten Sie es direkt initialisieren oder eine statische Methode zur Initialisierung vorschlagen.

5
ap2cu

Final bedeutet nicht, dass dies im Konstruktor initialisiert werden muss. Im Allgemeinen wird Folgendes getan: 

 private static final int x = 5;

static bedeutet stattdessen, dass die Variable von mehreren Instanzen der Klasse gemeinsam genutzt wird. Zum Beispiel : 

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
3
i.am.michiel

Denk darüber nach. Sie könnten dies mit Ihrem Code tun:

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

Die richtigen Methoden zum Initialisieren von x sind:

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

oder

public class A 
{    
    private static final int x;

    static
    {
        x = 5;
    }
}
2
Lukas Eder
    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
  }
}
0
Kush