Понимание порядка инициализации полей и блоков — база для предсказания поведения сложных объектов.
В каком порядке выведутся цифры?

class Parent {
    static { System.out.print("1"); }
    { System.out.print("2"); }
    Parent() { System.out.print("3"); }
}
class Child extends Parent {
    static { System.out.print("4"); }
    { System.out.print("5"); }
    Child() { System.out.print("6"); }
}
public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

🔍 Ответ на задачу про порядок инициализации: Кто первый — блок или конструктор? 🏗
Правило:
1. Сначала статические блоки родителя, потом ребенка (при первой загрузке класса).
2. Затем нестатические блоки родителя и его конструктор.
3. Только после этого нестатические блоки ребенка и его конструктор.

Вывод:
Сначала статика: 1, 4. Затем родитель: 2, 3. Затем ребенок: 5, 6. Итого: 142356.

⚡️ Не перепутайте:
Статика выполняется только один раз при загрузке класса, а обычные блоки — при каждом создании объекта перед конструктором.

#java #initialization #static #constructor #oop #интервью #java_interview_tasks

Механизм try-with-resources (Java 7+) сильно упростил жизнь, но у него есть нюанс с "подавленными" (suppressed) исключениями.
Что напечатает программа, если и close(), и тело try кидают исключения?

class Door implements AutoCloseable {
    public void close() { throw new RuntimeException("Close Error"); }
}
try (Door d = new Door()) {
    throw new RuntimeException("Try Error");
} catch (Exception e) {
    System.out.println(e.getMessage());
}

🔍 Ответ на задачу про try-with-resources: Куда делось исключение? 🛡
В try-with-resources основным считается исключение, возникшее в блоке try. Если при автоматическом закрытии ресурсов тоже возникнет исключение, оно не затрет основное, а будет добавлено в список "подавленных" (доступно через e.getSuppressed()).

Вывод:
Метод getMessage() вернет только основное исключение — "Try Error".

⚡️ Не перепутайте:
В старом стиле (через finally) исключение из finally могло "проглотить" исключение из try. Try-with-resources решает эту проблему.

#java #exceptions #trywithresources #suppressed #clean_code #интервью #java_interview_tasks

Есть ли тут ЛОГИЧЕСКИЙ баг?

🔍 Ответ на задачу про SQL: LEFT JOIN + WHERE — скрытый баг 🐛
LEFT JOIN гарантирует, что все строки из левой таблицы (customers) попадут в результат, даже если в правой таблице (products) нет совпадений — в этом случае столбцы правой таблицы заполняются NULL.

Однако условие WHERE p.status = 'SHIPPED' отфильтровывает все строки, где p.status IS NULL. Это означает, что клиенты без заказов будут исключены из результата, и LEFT JOIN фактически превратится в INNER JOIN.

Вывод:
WHERE по правой таблице превращает LEFT JOIN в INNER JOIN.
Чтобы сохранить поведение LEFT JOIN, условие фильтрации нужно перенести в ON:

SELECT   c.NAME,
         p.product_id
FROM     customers c
         LEFT JOIN products p
              ON c.id = p.customer_id
              AND p.status = 'SHIPPED';

#sql #leftjoin #where #bug #database #интервью #java_interview_tasks

Оператор instanceof кажется простым, но его поведение с null иногда застает врасплох.
Что выведет код?

String s = null;
System.out.println(s instanceof String);
System.out.println(s instanceof Object);

🔍 Ответ на задачу про instanceof: А если там null? 🧐
Согласно спецификации Java, оператор instanceof всегда возвращает false, если левый операнд равен null. При этом никакой ошибки (NPE) не возникает.

Вывод:
Оба сравнения вернут false. null не является экземпляром ни одного класса, даже Object.

⚡️ Не перепутайте:
Вам не нужно проверять s != null перед использованием instanceof. Сам оператор уже делает эту проверку за вас.

#java #instanceof #null #basics #интервью #java_interview_tasks

Асинхронное программирование — мощная концепция, но важно понимать разницу в цепочках методов.
Что вернет метод thenRun(), если предыдущий этап вернул строку "Success"?

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Success");
CompletableFuture<Void> result = future.thenRun(() -> System.out.println("Done"));

🔍 Ответ на задачу про CompletableFuture: thenRun, thenAccept или thenApply? 🚀
- thenApply(Function) — принимает результат, возвращает новый результат (меняет тип).
- thenAccept(Consumer) — принимает результат, ничего не возвращает (CompletableFuture<Void>).
- thenRun(Runnable) — не принимает результат и ничего не возвращает (CompletableFuture<Void>). Используется просто для запуска кода после завершения этапа.

Вывод:
thenRun всегда возвращает CompletableFuture<Void>, игнорируя результат предыдущего шага.

⚡️ Не перепутайте:
Выбирайте метод в зависимости от того, нужны ли вам входные данные от предыдущего шага и хотите ли вы что-то передать дальше.

#java #concurrency #completablefuture #async #multithreading #интервью #java_interview_tasks

Метод computeIfAbsent в Map очень удобен, но внутри лямбды скрыта ловушка.
Что произойдет, если внутри computeIfAbsent попытаться изменить эту же мапу?

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.computeIfAbsent("B", key -> {
    map.put("C", 3); 
    return 2;
});

🔍 Ответ на задачу про computeIfAbsent: Осторожно с модификациями! ⚠️

Документация HashMap (и большинства других реализаций) прямо запрещает модификацию структуры мапы (добавление/удаление) внутри методов вычисления (compute, merge, computeIfAbsent). Это может привести к повреждению внутренней структуры данных или выбросу ConcurrentModificationException.

Вывод:
В данном случае в HashMap будет выброшен ConcurrentModificationException.

⚡️ Не перепутайте:
Никогда не меняйте коллекцию внутри методов, которые итерируются по ней или вычисляют ее значения.

#java #collections #hashmap #bug #concurrency #интервью #java_interview_tasks

Когда у вас есть два метода с одинаковым именем, но разными типами аргументов, какой из них выберет Java для null?
Какой метод вызовется?

public class Test {
    public static void print(Object o) { System.out.println("Object"); }
    public static void print(String s) { System.out.println("String"); }
    public static void main(String[] args) {
        print(null);
    }
}

🔍 Ответ на задачу про перегрузку методов: null и неоднозначность ⚖️

Java при перегрузке (overloading) всегда выбирает наиболее специфичный (most specific) тип. Так как String является наследником Object, он считается более специфичным. Компилятор отдаст предпочтение ему.

Вывод:
Напечатается "String". Если бы мы добавили еще метод print(Integer i), возникла бы ошибка компиляции, так как String и Integer не связаны иерархией, и Java не смогла бы выбрать.

⚡️ Не перепутайте:
Если нужно вызвать именно версию для Object, сделайте явное приведение: print((Object) null).

#java #overloading #basics #polymorphism #интервью #java_interview_tasks

Что произойдет, если при формировании Map попадутся два одинаковых ключа?

List<String> list = Arrays.asList("apple12", "banana", "apricot");
Map<Integer, String> map = list.stream()
    .collect(Collectors.toMap(s -> s.length(), s -> s));