Java: ¿Cuándo es útil un bloque de inicialización estático?

Un uso típico:

private final static Set<String> SET = new HashSet<String>();

static {
    SET.add("value1");
    SET.add("value2");
    SET.add("value3");
}

Cómo lo harías sin inicializador estático?

El manejo de excepciones durante la inicialización es otra razón. Por ejemplo:

static URL url;
static {
    try {
        url = new URL("https://blahblah.com");
    }
    catch (MalformedURLException mue) {
        //log exception or handle otherwise
    }
}

Esto es útil para los constructores que lanzan excepciones verificadas de manera molesta, como en el caso anterior, o bien una lógica de inicialización más compleja que podría ser propensa a excepciones.

En su ejemplo, no hay diferencia; pero a menudo el valor inicial es más complejo de lo que se expresa cómodamente en una sola expresión (por ejemplo, es un List<String> cuyo contenido se expresa mejor mediante un bucle for; o es un Method que podría no existir, por lo que se necesitan manejadores de excepciones), y/o los campos estáticos deben establecerse en un orden específico.

A veces desea hacer algo más que asignar valores a variables estáticas. Dado que no puede poner sentencias arbitrarias en el cuerpo de la clase, podría usar un bloque inicializador estático.

static el bloque se puede usar para inicializar instancia de singleton, para evitar el uso de sincronizado getInstance() método.

Técnicamente, podrías salirte con la tuya sin ella. Algunos prefieren el código de inicialización multilínea para entrar en un método estático. Estoy bastante contento con el uso de un inicializador estático para la inicialización multistatement relativamente simple.

Por supuesto, casi siempre haría mi estática final y señalaría un objeto inmodificable.

La palabra clave estática (ya sea una variable o un bloque) pertenece a la clase. Así que cuando se llama a la clase, estas variables o bloques se ejecutan. Así que la mayor parte de la inicialización se hará con la ayuda de la palabra clave estática. Como pertenece a la clase en sí, la clase puede acceder directamente a ella, sin crear una instancia de la clase.

Tomemos un ejemplo, hay una clase de zapatos en la que hay varias variables como color, tamaño, marca, etc... Y aquí si el zapato la compañía de fabricación tiene solo una marca de la que deberíamos inicializarla como una variable estática. Por lo tanto, cuando se llama a la clase de zapatos y diferentes tipos de zapatos se fabrican (mediante la creación de una instancia de la clase) en ese tiempo, el color y la talla ocuparán la memoria cada vez que se creado pero aquí la marca es una propiedad común para todos los zapatos, por lo que será ocupar la memoria por una vez no importa cuántos zapatos se fabrican.

Ejemplo:

    class Shoe {
    int size;
    String colour;
    static String brand = "Nike";

    public Shoe(int size, String colour) {
        super();
        this.size = size;
        this.colour = colour;
    }

    void displayShoe() {
        System.out.printf("%-2d %-8s %s %n",size,colour, brand);
    }

    public static void main(String args[]) {
        Shoe s1 = new Shoe(7, "Blue");
        Shoe s2 = new Shoe(8, "White");

        System.out.println("=================");
        s1.displayShoe();
        s2.displayShoe();
        System.out.println("=================");
    }
}

Puedes usar el bloque try/catch dentro de static{} como abajo:

MyCode{

    static Scanner input = new Scanner(System.in);
    static boolean flag = true;
    static int B = input.nextInt();
    static int H = input.nextInt();

    static{
        try{
            if(B <= 0 || H <= 0){
                flag = false;
                throw new Exception("Breadth and height must be positive");
            }
        }catch(Exception e){
            System.out.println(e);
        }

    }
}

PS: Referido de este!

El bloque de código estático permite inicializar los campos con más de instuction, inicializar campos en un orden diferente de las declaraciones y también podría usarse para inicialización condicional.

Más específicamente,

static final String ab = a+b;
static final String a = "Hello,";
static final String b = ", world";

No funcionará porque a y b se declaran después de ab.

Sin embargo, podría usar un init estático. bloquear para superar esto.

static final String ab;
static final String a;
static final String b;

static {
  b = ", world";
  a = "Hello";
  ab = a + b;
}

static final String ab;
static final String a;
static final String b;

static {
  b = (...) ? ", world" : ", universe";
  a = "Hello";
  ab = a + b;
}

Un bloque de inicialización estática es útil si se desea inicializar tipos estáticos de clase especificados, antes del primer uso de clase. El uso posterior, no invocará ningún bloque de inicialización estático. Es el opuesto directo de inicializadores de instancia, que inicializan miembros de instancia,

Usamos constructores para inicializar nuestras variables de instancia(variables no estáticas, variables que pertenecen a objetos, no a la clase).

Si desea inicializar variables de clase(variables estáticas) y desea hacerlo sin crear un objeto(los constructores solo se pueden llamar al crear un objeto), entonces necesita bloques estáticos.

static Scanner input = new Scanner(System.in);
static int widht;
static int height;

static
{
    widht = input.nextInt();
    input.nextLine();
    height = input.nextInt();
    input.close();

    if ((widht < 0) || (height < 0))
    {
        System.out.println("java.lang.Exception: Width and height must be positive");
    }
    else
    {
        System.out.println("widht * height");
    }
}