Статические блоки инициализации

Насколько я понял, «статический блок инициализации» используется для установки значений статического поля, если это невозможно сделать в одной строке.

Но я не понимаю, зачем нам для этого нужен специальный блок. Например, мы объявляем поле как статическое (без присвоения значения). А затем напишите несколько строк кода, которые генерируют и присваивают значение объявленному выше статическому полю.

Зачем нам нужны эти строки в специальном блоке вроде static {...}:?

Нестатический блок:

{
    // Do Something...
}

Вызывается каждый раз, когда создается экземпляр класса. Статический блок только вызывается один раз , когда сам класс инициализируется, независимо от того , сколько объектов этого типа вы создаете.

Пример:

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();
    }
}

Это печатает:

Static
Non-static block
Non-static block

Если бы они не были в статическом блоке инициализации, где бы они были? Как бы вы объявили переменную, которая должна была быть только локальной для целей инициализации, и отличали бы ее от поля? Например, как бы вы хотели написать:

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;
    }
}

Если бы firstи secondне было в блоке, они бы выглядели как поля. Если бы они находились в блоке без staticнего, это считалось бы блоком инициализации экземпляра, а не статическим блоком инициализации, поэтому он будет выполняться один раз для каждого созданного экземпляра, а не один раз в общей сложности.

Теперь в этом конкретном случае вы можете использовать вместо этого статический метод:

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;
    }
}

... но это не работает, когда есть несколько переменных, которые вы хотите назначить в одном блоке, или ни одной (например, если вы просто хотите что-то записать - или, может быть, инициализировать нативную библиотеку).

Вот пример:

  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");
  }

Код в «статических» разделах будет выполняться во время загрузки класса до того, как будут созданы какие-либо экземпляры класса (и до того, как какие-либо статические методы будут вызваны из других источников). Таким образом, вы можете быть уверены, что все ресурсы класса готовы к использованию.

Также возможно иметь нестатические блоки инициализатора. Они действуют как расширения для набора методов конструктора, определенных для класса. Они выглядят так же, как статические блоки инициализатора, за исключением того, что ключевое слово «static» не указано.

Это также полезно, когда вы на самом деле не хотите присваивать значение чему-либо, например, загружать некоторый класс только один раз во время выполнения.

Например

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

Эй, есть еще одно преимущество, вы можете использовать его для обработки исключений. Представьте, что getStuff()здесь выдается объект, Exceptionкоторый действительно принадлежит блоку catch:

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

тогда здесь можно использовать staticинициализатор. Вы можете обработать исключение там.

Другой пример - сделать что-то потом, чего нельзя сделать во время присваивания:

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);
    }
}

Чтобы вернуться к примеру с драйвером JDBC, любой приличный драйвер JDBC сам также использует staticинициализатор для регистрации себя в DriverManager. Также посмотрите этот и этот ответ.

Я бы сказал, static blockэто просто синтаксический сахар. Вы ничего не можете сделать с staticблоком, и не с чем-либо еще.

Чтобы повторно использовать некоторые примеры, размещенные здесь.

Этот кусок кода может быть переписан без использования staticинициализатора.

Способ № 1: с static

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

Способ № 2: без 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;
}

Есть несколько фактических причин, по которым он необходим:

1. инициализирующие static finalчлены, инициализация которых может вызвать исключение
2. инициализация static finalчленов с вычисленными значениями

Люди склонны использовать static {}блоки в качестве удобного способа инициализации вещей, от которых зависит класс, также во время выполнения, таких как обеспечение загрузки определенного класса (например, драйверов JDBC). Это может быть сделано другими способами; однако две вещи, которые я упомянул выше, могут быть выполнены только с помощью конструкции, подобной static {}блоку.

Вы можете выполнить биты кода один раз для класса, прежде чем объект будет создан в статических блоках.

Например

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());
  }
}

Распространено заблуждение, что статический блок имеет доступ только к статическим полям. Для этого я хотел бы показать ниже фрагмент кода, который я довольно часто использую в реальных проектах (частично скопированный из другого ответа в несколько ином контексте):

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); 
  } 
} 

Здесь инициализатор используется для поддержки index ( ALIAS_MAP), чтобы отобразить набор псевдонимов обратно в исходный тип перечисления. Он предназначен как расширение встроенного метода valueOf, предоставляемого самим Enumсобой.

Как видите, статический инициализатор получает доступ даже к privateполю aliases. Важно понимать, что staticблок уже имеет доступ к Enumэкземплярам значений (например ENGLISH). Это потому, что порядок инициализации и выполнения в случае Enumтипов так же, как если бы static privateполя были инициализированы с экземплярами до staticвызова блоков:

1. Эти Enumконстанты , которые являются неявными полями статических. Это требует, чтобы конструктор Enum и блоки экземпляра, а также инициализация экземпляра выполнялись первыми.
2. static блок и инициализация статических полей в порядке появления.

Эта нестандартная инициализация (конструктор перед staticблоком) очень важна. Это также происходит, когда мы инициализируем статические поля с экземплярами, аналогичными Singleton (сделаны упрощения):

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();
  }
}

То, что мы видим, это следующий вывод:

Static Block 1
Constructor
Static Block 2
In Main
Constructor

Понятно, что статическая инициализация на самом деле может происходить до конструктора и даже после:

Простой доступ к Foo в методе main приводит к загрузке класса и запуску статической инициализации. Но как часть статической инициализации мы снова вызываем конструкторы для статических полей, после чего она возобновляет статическую инициализацию и завершает конструктор, вызываемый из основного метода. Довольно сложная ситуация, для которой я надеюсь, что при нормальном кодировании нам не пришлось бы иметь дело с.

Подробнее об этом см. Книгу « Эффективная Java ».

Если ваши статические переменные должны быть установлены во время выполнения, static {...}блок очень полезен.

Например, если вам нужно установить для статического члена значение, которое хранится в файле конфигурации или базе данных.

Также полезно, когда вы хотите добавить значения к статическому Mapчлену, поскольку вы не можете добавить эти значения в первоначальном объявлении члена.

Таким образом, у вас есть статическое поле (оно также называется «переменная класса», потому что оно принадлежит классу, а не экземпляру класса; другими словами, оно связано с классом, а не с каким-либо объектом), и вы хотите его инициализировать. Поэтому, если вы НЕ хотите создавать экземпляр этого класса и хотите манипулировать этим статическим полем, вы можете сделать это тремя способами:

1- Просто инициализируйте его, когда объявляете переменную:

static int x = 3;

2- иметь статический блок инициализации:

static int x;

static {
 x=3;
}

3. Иметь метод класса (статический метод), который обращается к переменной класса и инициализирует ее: это альтернатива вышеуказанному статическому блоку; Вы можете написать приватный статический метод:

public static int x=initializeX();

private static int initializeX(){
 return 3;
}

Теперь, почему бы вам использовать статический блок инициализации вместо статических методов?

Это действительно зависит от того, что вам нужно в вашей программе. Но вы должны знать, что статический инициализирующий блок вызывается один раз, и единственное преимущество метода класса заключается в том, что они могут быть повторно использованы позже, если вам нужно повторно инициализировать переменную класса.

скажем, у вас есть сложный массив в вашей программе. Вы инициализировать его (используя для цикла, например) , а затем значения в этом массиве будет меняться в течение всей программы , но потом в какой - то момент вы хотите реинициализировать (вернуться к исходному значению). В этом случае вы можете вызвать закрытый статический метод. Если в вашей программе не требуется повторная инициализация значений, вы можете просто использовать статический блок и не нуждаться в статическом методе, так как вы не собираетесь использовать его позже в программе.

Примечание: статические блоки вызываются в порядке их появления в коде.

Пример 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
 }

}

Пример 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
 }

}

В качестве дополнительного, как сказал @Pointy

Код в «статических» разделах будет выполняться во время загрузки класса до того, как будут созданы какие-либо экземпляры класса (и до того, как какие-либо статические методы будут вызваны из других источников).

Предполагается добавить System.loadLibrary("I_am_native_library")в статический блок.

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

Это гарантирует, что ни один нативный метод не будет вызван до загрузки соответствующей библиотеки в память.

Согласно loadLibrary от оракула :

Если этот метод вызывается более одного раза с одним и тем же именем библиотеки, второй и последующие вызовы игнорируются.

Так что совершенно неожиданно размещение System.loadLibrary не используется, чтобы избежать многократной загрузки библиотеки.

Сначала вы должны понять, что сами классы вашего приложения создаются для java.class.Classобъектов во время выполнения. Это когда ваши статические блоки запускаются. Таким образом, вы можете сделать это:

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) {
    }

}

и это выведет «myInt is 1» на консоль. Обратите внимание, что я не создал ни одного класса.

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");
    } 
}

Статический блок используется для любой технологии для динамической инициализации члена статических данных, или мы можем сказать, что для динамической инициализации статического члена данных используется статический блок. Потому что для инициализации не статического члена данных у нас есть конструктор, но у нас нет любое место, где мы можем динамически инициализировать статический член данных

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);
        }
        }

Теперь мой static int x будет динамически инициализироваться ..Bcoz, когда компилятор перейдет в Solution.x, он загрузит класс решения и загрузку статического блока во время загрузки класса .. Так что мы можем динамически инициализировать этот статический член данных ..

}