⌨️ Зачем нужны и какие бывают блоки инициализации?

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

Существуют статические и нестатические блоки инициализации.

Статический блок инициализации выполняется в момент загрузки класса в JVM загрузчиком классов (Class Loader).

public class StaticInitialization {
    static {
        System.out.println("Статическая инициализация");
    }
}

Нестатический блок инициализации выполняется в момент создания класса (new).

public class NonstaticInitialization {
    {
        System.out.println("Нестатическая инициализация");
    }
}

Несколько блоков инициализации выполняются в порядке следования в коде класса.

Блок инициализации способен генерировать исключения, если их объявления перечислены в throws всех конструкторов класса.

Блок инициализации возможно создать и в анонимном классе.

#java #initialization #block #static

⌨️ Каким образом можно получить доступ к члену класса, объявленному как private?

✅ Внутри класса доступ к приватной переменной открыт без ограничений;

✅ Вложенный класс имеет полный доступ ко всем (в том числе и приватным) членам содержащего его класса;

✅ Доступ к приватным переменным извне может быть организован через отличные от приватных методов, которые предоставлены разработчиком класса (геттеры, сеттеры). Например: getX() и setX().

✅ Через механизм рефлексии (Reflection API):

class Hide { 
    private int field = 42;
}
...
Hide hide = new Hide(); 
Field field = Hide.class.getDeclaredField("field"); 
field.setAccessible(true); 
int fieldValue = (int) field.get(hide);

#java #private #access

⌨️ Каков порядок вызова конструкторов и блоков инициализации с учётом иерархии классов?

Сначала вызываются все статические блоки в очередности от первого статического блока корневого предка и выше по цепочке иерархии до статических блоков самого класса.

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

1️⃣ Parent static block(s) → Child static block(s)

2️⃣ Parent non-static block(s) → Parent constructor
→ Child non-static block(s) → Child constructor

Пример:

public class Alert {
    public Alert(String message) {
        System.out.println(message);
    }
}

public class Parent {
    public static Alert statVar1 = new Alert("Parent: static variable (statVar1)");
    public static Alert statVar2;
    static {
        statVar2 = new Alert("Parent: static initialization block (statVar2)");
    }

    public Alert var1 = new Alert("Parent: variable (var1)");
    public Alert var2;
    {
        var2 = new Alert("Parent: initialization block (var2)");
    }
    public Alert var3 = new Alert("Parent: variable (var3)");

    public static Alert statVar3 = new Alert("Parent: static variable (statVar3)");

    public Alert contructorVar;
    public Parent() {
        contructorVar = new Alert("Parent: constructor (contructorVar)");
    }
}

public class Child extends Parent {
    public static Alert statVar1 = new Alert("Child: static variable (statVar1)");
    public static Alert statVar2;
    static {
        statVar2 = new Alert("Child: static initialization block (statVar2)");
    }

    public Alert var1 = new Alert("Child: variable (var1)");
    public Alert var2;
    {
        var2 = new Alert("Child: initialization block (var2)");
    }
    public Alert var3 = new Alert("Child: variable (var3)");

    public static Alert statVar3 = new Alert("Child: static variable (statVar3)");

    public Alert contructorVar;
    public Child() {
        contructorVar = new Alert("Child: constructor (contructorVar)");
    }
}

public class Test {
    public static void main(String[] args) {
        new Child();
    }
}

Вывод консоли:

Parent: static variable (statVar1)
Parent: static initialization block (statVar2)
Parent: static variable (statVar3)
Child: static variable (statVar1)
Child: static initialization block (statVar2)
Child: static variable (statVar3)
Parent: variable (var1)
Parent: initialization block (var2)
Parent: variable (var3)
Parent: constructor (contructorVar)
Child: variable (var1)
Child: initialization block (var2)
Child: variable (var3)
Child: constructor (contructorVar)

#java #initialization #static #block #constructor

⌨️ Могут ли нестатические методы перегрузить статические?

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

#java #overload #static

⌨️ Способы передачи параметров в методы

Существуют два основных способа передачи параметров в методы: "по значению" (pass-by-value) и "по ссылке" (pass-by-reference). В первом случае метод работает с копией значения параметра, не изменяя исходное значение. Во втором случае метод получает ссылку на объект или переменную, и любые изменения в параметре отражаются на исходном объекте или переменной.

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

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

#java #pass #value #reference

⌨️ К каким конструкциям Java применим модификатор static?

✅полям;
✅методам;
✅вложенным классам;
✅блокам инициализации;
✅членам секции import.

#java #static

⌨️ В Java static import (статический импорт) позволяет импортировать статические члены (методы и поля) из класса, чтобы использовать их напрямую без указания имени класса. Это может сделать код более читабельным и компактным.

// Для импорта конкретного статического члена
import static package.Clazz.member;

// Для импорта всех статических членов класса
import static package.Clazz.*;

Пример:

public class MathUtils {
    public static final double PI = 3.141592653589793;
    public static int add(int a, int b) {
        return a + b;
    }
    public static int subtract(int a, int b) {
        return a - b;
    }
}

import static MathUtils.PI;
import static MathUtils.add;

public class Main {
    public static void main(String[] args) {
        System.out.println("Value of PI: " + PI);
        System.out.println("Addition result: " + add(5, 3));
    }
}

import static MathUtils.*;

public class Main {
    public static void main(String[] args) {
        System.out.println("Value of PI: " + PI);
        System.out.println("Addition result: " + add(5, 3));
        System.out.println("Subtraction result: " + subtract(5, 3));
    }
}

Плюсы: читаемость, компактность кода.

Минусы:
- не очевидно откуда берется поле или метод
- импорт всех статических членов может привести к конфликтам имен, если разные классы содержат статические члены с одинаковыми именами

#java #static #import