Bloques de inicialización estática

Según tengo entendido, el "bloque de inicialización estática" se usa para establecer valores de campo estático si no se puede hacer en una línea.

Pero no entiendo por qué necesitamos un bloque especial para eso. Por ejemplo, declaramos un campo como estático (sin una asignación de valor). Y luego escriba varias líneas del código que generan y asignan un valor al campo estático declarado anteriormente.

¿Por qué necesitamos estas líneas en un bloque especial como static {...}:?

El bloque no estático:

{
    // Do Something...
}

Se llama cada vez que se construye una instancia de la clase. El bloque estático solo se llama una vez , cuando se inicializa la clase, sin importar cuántos objetos de ese tipo cree.

Ejemplo:

public class Test {

    static{
        System.out.println("Static");
    }

    {
        System.out.println("Non-static block");
    }

    public static void main(String[] args) {
        Test t = new Test();
        Test t2 = new Test();
    }
}

Esto imprime:

Static
Non-static block
Non-static block

Si no estuvieran en un bloque de inicialización estática, ¿dónde estarían? ¿Cómo declararía una variable que solo debía ser local para los propósitos de inicialización y distinguirla de un campo? Por ejemplo, ¿cómo te gustaría escribir:

public class Foo {
    private static final int widgets;

    static {
        int first = Widgets.getFirstCount();
        int second = Widgets.getSecondCount();
        // Imagine more complex logic here which really used first/second
        widgets = first + second;
    }
}

Si firsty secondno estaban en un bloque, se verían como campos. Si estuvieran en un bloque sin staticdelante, eso contaría como un bloque de inicialización de instancia en lugar de un bloque de inicialización estático, por lo que se ejecutaría una vez por instancia construida en lugar de una vez en total.

Ahora, en este caso particular, podría usar un método estático en su lugar:

public class Foo {
    private static final int widgets = getWidgets();

    static int getWidgets() {
        int first = Widgets.getFirstCount();
        int second = Widgets.getSecondCount();
        // Imagine more complex logic here which really used first/second
        return first + second;
    }
}

... pero eso no funciona cuando hay varias variables que desea asignar dentro del mismo bloque, o ninguna (por ejemplo, si solo desea registrar algo, o tal vez inicializar una biblioteca nativa).

Aquí hay un ejemplo:

  private static final HashMap<String, String> MAP = new HashMap<String, String>();
  static {
    MAP.put("banana", "honey");
    MAP.put("peanut butter", "jelly");
    MAP.put("rice", "beans");
  }

El código en la sección o secciones "estáticas" se ejecutará en el momento de la carga de la clase, antes de que se construyan instancias de la clase (y antes de que se llame a cualquier método estático desde otro lugar). De esa manera, puede asegurarse de que los recursos de la clase estén listos para usar.

También es posible tener bloques de inicializador no estáticos. Esos actúan como extensiones del conjunto de métodos constructores definidos para la clase. Se parecen a los bloques de inicializador estático, excepto que la palabra clave "estática" se omite.

También es útil cuando en realidad no desea asignar el valor a nada, como cargar alguna clase solo una vez durante el tiempo de ejecución.

P.ej

static {
    try {
        Class.forName("com.example.jdbc.Driver");
    } catch (ClassNotFoundException e) {
        throw new ExceptionInInitializerError("Cannot load JDBC driver.", e);
    }
}

Oye, hay otro beneficio, puedes usarlo para manejar excepciones. Imagine que getStuff()aquí arroja un Exceptionque realmente pertenece en un bloque de captura:

private static Object stuff = getStuff(); // Won't compile: unhandled exception.

entonces un staticinicializador es útil aquí. Puedes manejar la excepción allí.

Otro ejemplo es hacer cosas después que no se pueden hacer durante la asignación:

private static Properties config = new Properties();

static {
    try { 
        config.load(Thread.currentThread().getClassLoader().getResourceAsStream("config.properties");
    } catch (IOException e) {
        throw new ExceptionInInitializerError("Cannot load properties file.", e);
    }
}

Para volver al ejemplo del controlador JDBC, cualquier controlador JDBC decente también utiliza el staticinicializador para registrarse en el DriverManager. También vea esto y esta respuesta.

Yo diría que static blockes solo azúcar sintáctico. No hay nada que puedas hacer con el staticbloqueo y no con nada más.

Para reutilizar algunos ejemplos publicados aquí.

Este código podría reescribirse sin usar staticinitialiser.

Método # 1: con static

private static final HashMap<String, String> MAP;
static {
    MAP.put("banana", "honey");
    MAP.put("peanut butter", "jelly");
    MAP.put("rice", "beans");
  }

Método # 2: sin static

private static final HashMap<String, String> MAP = getMap();
private static HashMap<String, String> getMap()
{
    HashMap<String, String> ret = new HashMap<>();
    ret.put("banana", "honey");
    ret.put("peanut butter", "jelly");
    ret.put("rice", "beans");
    return ret;
}

Hay algunas razones reales por las que se requiere que exista:

1. inicializando static final miembros cuya inicialización podría generar una excepción
2. inicializando static finalmiembros con valores calculados

Las personas tienden a usar static {}bloques como una forma conveniente de inicializar cosas de las que depende la clase también en el tiempo de ejecución, como garantizar que se cargue una clase en particular (por ejemplo, controladores JDBC). Eso se puede hacer de otras maneras; sin embargo, las dos cosas que menciono anteriormente solo se pueden hacer con una construcción como el static {}bloque.

Puede ejecutar bits de código una vez para una clase antes de construir un objeto en los bloques estáticos.

P.ej

class A {
  static int var1 = 6;
  static int var2 = 9;
  static int var3;
  static long var4;

  static Date date1;
  static Date date2;

  static {
    date1 = new Date();

    for(int cnt = 0; cnt < var2; cnt++){
      var3 += var1;
    }

    System.out.println("End first static init: " + new Date());
  }
}

Es un error común pensar que un bloque estático solo tiene acceso a campos estáticos. Para esto, me gustaría mostrar a continuación el código que utilizo con bastante frecuencia en proyectos de la vida real (copiado parcialmente de otra respuesta en un contexto ligeramente diferente):

public enum Language { 
  ENGLISH("eng", "en", "en_GB", "en_US"),   
  GERMAN("de", "ge"),   
  CROATIAN("hr", "cro"),   
  RUSSIAN("ru"),
  BELGIAN("be",";-)");

  static final private Map<String,Language> ALIAS_MAP = new HashMap<String,Language>(); 
  static { 
    for (Language l:Language.values()) { 
      // ignoring the case by normalizing to uppercase
      ALIAS_MAP.put(l.name().toUpperCase(),l); 
      for (String alias:l.aliases) ALIAS_MAP.put(alias.toUpperCase(),l); 
    } 
  } 

  static public boolean has(String value) { 
    // ignoring the case by normalizing to uppercase
    return ALIAS_MAP.containsKey(value.toUpper()); 
  } 

  static public Language fromString(String value) { 
    if (value == null) throw new NullPointerException("alias null"); 
    Language l = ALIAS_MAP.get(value); 
    if (l == null) throw new IllegalArgumentException("Not an alias: "+value); 
    return l; 
  } 

  private List<String> aliases; 
  private Language(String... aliases) { 
    this.aliases = Arrays.asList(aliases); 
  } 
} 

Aquí el inicializador se utiliza para mantener un índice ( ALIAS_MAP), para asignar un conjunto de alias al tipo de enumeración original. Está destinado a ser una extensión del método valueOf incorporado proporcionado por el Enummismo.

Como puede ver, el inicializador estático accede incluso al privatecampo aliases. Es importante comprender que el staticbloque ya tiene acceso a las Enuminstancias de valor (p ENGLISH. Ej .). Esto se debe al orden de inicialización y ejecución en el caso de los Enumtipos , como si los static privatecampos se hubieran inicializado con instancias antes de staticque se llamaran los bloques:

1. Las Enumconstantes que son campos estáticos implícitos. Esto requiere que el constructor Enum y los bloques de instancia, y la inicialización de la instancia también ocurran primero.
2. static bloque e inicialización de campos estáticos en el orden de ocurrencia.

Es staticimportante tener en cuenta esta inicialización fuera de orden (constructor antes del bloque). También sucede cuando inicializamos campos estáticos con las instancias de manera similar a un Singleton (simplificaciones hechas):

public class Foo {
  static { System.out.println("Static Block 1"); }
  public static final Foo FOO = new Foo();
  static { System.out.println("Static Block 2"); }
  public Foo() { System.out.println("Constructor"); }
  static public void main(String p[]) {
    System.out.println("In Main");
    new Foo();
  }
}

Lo que vemos es el siguiente resultado:

Static Block 1
Constructor
Static Block 2
In Main
Constructor

Claro es que la inicialización estática en realidad puede ocurrir antes del constructor, e incluso después:

Simplemente acceder a Foo en el método principal hace que se cargue la clase y se inicie la inicialización estática. Pero como parte de la inicialización estática, nuevamente llamamos a los constructores para los campos estáticos, después de lo cual reanuda la inicialización estática y completa el constructor llamado desde el método principal. Situación bastante compleja para la que espero que en la codificación normal no tengamos que lidiar.

Para obtener más información sobre esto, consulte el libro " Java eficaz ".

Si sus variables estáticas necesitan establecerse en tiempo de ejecución, entonces un static {...} bloque es muy útil.

Por ejemplo, si necesita establecer el miembro estático en un valor que se almacena en un archivo de configuración o base de datos.

También es útil cuando desea agregar valores a un Mapmiembro estático , ya que no puede agregar estos valores en la declaración inicial del miembro.

Entonces tiene un campo estático (también se llama "variable de clase" porque pertenece a la clase en lugar de a una instancia de la clase; en otras palabras, está asociado con la clase en lugar de con cualquier objeto) y desea inicializarlo. Entonces, si NO desea crear una instancia de esta clase y desea manipular este campo estático, puede hacerlo de tres maneras:

1- Solo inicialízalo cuando declares la variable:

static int x = 3;

2- Tener un bloque de inicialización estático:

static int x;

static {
 x=3;
}

3- Tenga un método de clase (método estático) que acceda a la variable de clase y la inicialice: esta es la alternativa al bloque estático anterior; puedes escribir un método estático privado:

public static int x=initializeX();

private static int initializeX(){
 return 3;
}

Ahora, ¿por qué usaría un bloque de inicialización estático en lugar de métodos estáticos?

Realmente depende de lo que necesita en su programa. Pero debe saber que el bloque de inicialización estático se llama una vez y la única ventaja del método de clase es que pueden reutilizarse más adelante si necesita reinicializar la variable de clase.

Digamos que tiene una matriz compleja en su programa. Lo inicializa (usando para loop, por ejemplo) y luego los valores de esta matriz cambiarán a lo largo del programa, pero luego, en algún momento, desea reiniciarlo (volver al valor inicial). En este caso, puede llamar al método estático privado. En caso de que no necesite en su programa reiniciar los valores, simplemente puede usar el bloque estático y no necesita un método estático ya que no lo usará más adelante en el programa.

Nota: los bloques estáticos se llaman en el orden en que aparecen en el código.

Ejemplo 1:

class A{
 public static int a =f();

// this is a static method
 private static int f(){
  return 3;
 }

// this is a static block
 static {
  a=5;
 }

 public static void main(String args[]) {
// As I mentioned, you do not need to create an instance of the class to use the class variable
  System.out.print(A.a); // this will print 5
 }

}

Ejemplo 2

class A{
 static {
  a=5;
 }
 public static int a =f();

 private static int f(){
  return 3;
 }

 public static void main(String args[]) {
  System.out.print(A.a); // this will print 3
 }

}

Como complemento, como dijo @Pointy

El código en la sección o secciones "estáticas" se ejecutará en el momento de la carga de la clase, antes de que se construya cualquier instancia de la clase (y antes de que se llame a cualquier método estático desde otro lugar).

Se supone que se agrega System.loadLibrary("I_am_native_library")al bloque estático.

static{
    System.loadLibrary("I_am_a_library");
}

Garantizará que no se llame a ningún método nativo antes de que la biblioteca relacionada se cargue en la memoria.

Según loadLibrary del oráculo :

Si se llama a este método más de una vez con el mismo nombre de biblioteca, se ignoran la segunda y las siguientes llamadas.

Entonces, inesperadamente, poner System.loadLibrary no se usa para evitar que la biblioteca se cargue varias veces.

Primero debe comprender que sus propias clases de aplicación se instancian en java.class.Classobjetos durante el tiempo de ejecución. Esto es cuando se ejecutan sus bloques estáticos. Entonces realmente puedes hacer esto:

public class Main {

    private static int myInt;

    static {
        myInt = 1;
        System.out.println("myInt is 1");
    }

    //  needed only to run this class
    public static void main(String[] args) {
    }

}

e imprimiría "myInt is 1" a la consola. Tenga en cuenta que no he instanciado ninguna clase.

static int B,H;
static boolean flag = true;
static{
    Scanner scan = new Scanner(System.in);
    B = scan.nextInt();
    scan.nextLine();
    H = scan.nextInt();

    if(B < 0 || H < 0){
        flag = false;
        System.out.println("java.lang.Exception: Breadth and height must be positive");
    } 
}

el bloque estático se usa para cualquier tecnología para inicializar el miembro de datos estáticos de forma dinámica, o podemos decir que para la inicialización dinámica del miembro de datos estático se está utilizando el bloque estático ... Debido a la inicialización del miembro de datos no estáticos, tenemos un constructor pero no tenemos cualquier lugar donde podamos inicializar dinámicamente miembros de datos estáticos

Eg:-class Solution{
         // static int x=10;
           static int x;
       static{
        try{
          x=System.out.println();
          }
         catch(Exception e){}
        }
       }

     class Solution1{
      public static void main(String a[]){
      System.out.println(Solution.x);
        }
        }

Ahora mi static x int se inicializará dinámicamente ... porque cuando el compilador irá a Solution.x cargará la clase de solución y la carga de bloque estático en el momento de carga de la clase ... para que podamos inicializar dinámicamente ese miembro de datos estáticos ...

}