➡️ Easy Java | #Викторина

❓ Вопрос с собеса

Что такое ClassLoader в Java и как он работает?

Пример🔽

public class Main {
    public static void main(String[] args) {
        ClassLoader loader = Main.class.getClassLoader();

        System.out.println("ClassLoader: " + loader);
        System.out.println("Parent: " + loader.getParent());
        System.out.println("Grandparent: " + loader.getParent().getParent()); // ➔ null (Bootstrap)
    }
}

Ответ🔽

ClassLoader отвечает за загрузку классов в память JVM. Он превращает байткод (.class файлы) в объекты Class во время выполнения.
Загрузка происходит каскадно — через цепочку загрузчиков:

Bootstrap ClassLoader — загружает базовые классы JDK (java.lang.*, java.util.*)

Platform (или Extension) ClassLoader — загружает расширения из jmods

Application ClassLoader — загружает классы приложения из classpath

📌 Можно создать свой ClassLoader для динамической подгрузки плагинов, изоляции зависимостей или перезапуска модулей без перезапуска JVM

➡️ Easy Java | #Собес

➡️ Easy Java | #Викторина

👩‍💻 Что такое ReentrantReadWriteLock в Java и зачем он нужен?

ReentrantReadWriteLock — это улучшенная альтернатива synchronized, позволяющая одновременно выполнять несколько чтений, но блокировать доступ на запись.

Он состоит из двух независимых замков:
• readLock() — совместимый, позволяет многим потокам читать параллельно
• writeLock() — эксклюзивный, разрешает только одному потоку писать

⚡️ Пример:

import java.util.concurrent.locks.*;

public class Main {
    private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private static int value = 0;

    public static void main(String[] args) {
        Runnable reader = () -> {
            lock.readLock().lock();
            try {
                System.out.println("Чтение: " + value);
            } finally {
                lock.readLock().unlock();
            }
        };

        Runnable writer = () -> {
            lock.writeLock().lock();
            try {
                value++;
                System.out.println("Запись: " + value);
            } finally {
                lock.writeLock().unlock();
            }
        };

        new Thread(reader).start();
        new Thread(writer).start();
    }
}

👀 ReentrantReadWriteLock особенно полезен, когда чтений гораздо больше, чем записей — например, в кэшах, справочниках или аналитических сервисах

➡️ Easy Java | #Теория

➡️ Easy Java | #Викторина

❓ Вопрос с собеса

Что такое Reflection в Java и как он работает?

Пример🔽

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Person.class;

        System.out.println("Поля:");
        for (Field f : clazz.getDeclaredFields())
            System.out.println(" - " + f.getName());

        System.out.println("\nМетоды:");
        for (Method m : clazz.getDeclaredMethods())
            System.out.println(" - " + m.getName());

        Person p = new Person("Alice");
        Method sayHello = clazz.getDeclaredMethod("sayHello");
        sayHello.invoke(p); // вызов приватного метода через Reflection
    }
}

class Person {
    private String name;
    public Person(String name) { this.name = name; }
    private void sayHello() { System.out.println("Привет, " + name); }
}

Ответ🔽

Reflection (рефлексия) позволяет анализировать и изменять поведение классов во время выполнения. С её помощью можно:

— получать информацию о классах, полях и методах
— вызывать методы и изменять поля динамически
— создавать экземпляры классов без new

📌 Минусы:
— снижает производительность,
— нарушает инкапсуляцию,
— может вызывать ошибки безопасности.

Reflection активно используется в фреймворках (Spring, Hibernate, JUnit) для внедрения зависимостей, сериализации и динамического вызова кода

➡️ Easy Java | #Собес

➡️ Easy Java | #Викторина

👩‍💻 Что такое ReentrantLock в Java и зачем он нужен?

ReentrantLock — это продвинутый вариант synchronized, который даёт больше контроля над блокировками. Он позволяет явно захватывать и освобождать замок, а также проверять, свободен ли он.

Главные преимущества:

• можно прервать ожидание блокировки (lockInterruptibly())
• можно попытаться захватить её с таймаутом (tryLock())
• поддерживает справедливость (fair mode) и повторный вход

⚡️ Пример:

import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final ReentrantLock lock = new ReentrantLock();
    private static int count = 0;

    public static void main(String[] args) {
        Runnable task = () -> {
            if (lock.tryLock()) {
                try {
                    count++;
                    System.out.println(Thread.currentThread().getName() + " увеличил count: " + count);
                } finally {
                    lock.unlock();
                }
            } else {
                System.out.println(Thread.currentThread().getName() + " не смог захватить замок");
            }
        };

        new Thread(task).start();
        new Thread(task).start();
    }
}

👀 ReentrantLock особенно полезен, когда нужна гибкость управления блокировками — например, для тайм-аутов, справедливого доступа или реализации сложных синхронизаторов

➡️ Easy Java | #Теория

➡️ Easy Java | #Викторина

❓ Вопрос с собеса

Что такое аннотации в Java и как они работают под капотом?

Пример🔽

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Log {
    String value() default "Вызван метод";
}

public class Main {
    @Log("Запуск метода mainLogic()")
    public void mainLogic() {
        System.out.println("Работа метода...");
    }

    public static void main(String[] args) throws Exception {
        Main obj = new Main();

        for (Method m : obj.getClass().getDeclaredMethods()) {
            if (m.isAnnotationPresent(Log.class)) {
                Log log = m.getAnnotation(Log.class);
                System.out.println(log.value());
                m.invoke(obj);
            }
        }
    }
}

Ответ🔽

Аннотации — это метаданные, которые можно прикреплять к классам, методам, полям и параметрам. Они не влияют напрямую на выполнение программы, но могут использоваться для конфигурации, валидации или генерации кода.

Через Reflection можно считывать аннотации во время выполнения (если RetentionPolicy.RUNTIME) и реагировать на них.

📌 Аннотации активно применяются в Spring, JPA, Lombok, JUnit — для внедрения зависимостей, маппинга, логирования и генерации boilerplate-кода

➡️ Easy Java | #Собес

📖 Ошибки, которые инженеры совершают при код-ревью

Код-ревью стало ключевым этапом в разработке: генерация кода с помощью LLM упростилась, а вот проверка его качества по-прежнему требует инженерной экспертизы.

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

⛓ Читать статью

➡️ Easy Java | #Статья

👩‍💻 Что такое CompletableFuture и зачем он нужен?

CompletableFuture — это мощный класс из пакета java.util.concurrent, представленный в Java 8, который представляет собой усовершенствованную реализацию Future с поддержкой асинхронного программирования, цепочек вызовов и комбинирования результатов.

Преимущества над обычным Future:

— Неблокирующие операции — не требует вызова get() для получения результата
— Цепочки вызовов — позволяет строить сложные асинхронные конвейеры
— Комбинирование — возможность объединять несколько асинхронных операций
— Обработка исключений — встроенные механизмы обработки ошибок
— Ручное завершение — можно явно завершать операции

⚡️ Пример кода:

import java.util.concurrent.*;

public class CompletableFutureDemo {
    public static void main(String[] args) throws Exception {
        // Асинхронное получение пользователя
        CompletableFuture<String> userFuture = CompletableFuture
            .supplyAsync(() -> {
                sleep(1000);
                return "User123";
            });
        
        // Цепочка обработки с преобразованием
        CompletableFuture<String> resultFuture = userFuture
            .thenApply(user -> user + " -> обработан")
            .thenApplyAsync(data -> {
                sleep(500);
                return data.toUpperCase();
            })
            .exceptionally(ex -> "Ошибка: " + ex.getMessage());
        
        // Неблокирующее получение результата
        resultFuture.thenAccept(result -> 
            System.out.println("Результат: " + result)
        );
        
        // Ждем завершения
        Thread.sleep(2000);
    }
    
    private static void sleep(int ms) {
        try { Thread.sleep(ms); } 
        catch (InterruptedException e) {}
    }
}

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

➡️ Easy Java | #Теория