❓ Что такое ООП ?
Спросят с вероятностью 81%

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

Основные принципы:

1️⃣ Инкапсуляция — это сокрытие внутренних деталей реализации объекта от внешнего мира. Только сам объект управляет своим состоянием, внешние объекты взаимодействуют с ним через методы. Это позволяет упростить интерфейсы взаимодействия между компонентами и улучшить модульность.

2️⃣ Наследование — механизм, с помощью которого один класс (дочерний класс) может наследовать свойства и методы другого класса (родительского класса), потенциально переопределяя некоторые из них. Это способствует повторному использованию кода и иерархической организации классов.

3️⃣ Полиморфизм — способность объектов с одинаковым интерфейсом предоставлять различную реализацию. Это позволяет одному и тому же коду работать с объектами разных типов.

4️⃣ Абстракция — процесс выделения существенных характеристик объекта, исключая несущественные. Это помогает сосредоточиться на том, что объект делает, а не на том, как он это делает.

Пример:

class Животное {
    void есть() {
        System.out.println("Животное ест");
    }
}

class Кот extends Животное {
    void есть() {
        System.out.println("Кот ест рыбу");
    }
}

public class Main {
    public static void main(String[] args) {
        Животное моеЖивотное = new Кот();
        моеЖивотное.есть(); // Выведет "Кот ест рыбу", демонстрируя полиморфизм
    }
}

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

Объектно-ориентированное программирование — это подход к разработке программ, который использует "объекты" — сущности с данными и методами для моделирования реального или абстрактного мира. Это помогает сделать код более модульным, легко расширяемым и поддерживаемым.

➡Примеры ответов
➡ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

❓В чем разница между checked и unchecked исключениями ?
Спросят с вероятностью 75%

Исключения (exceptions) важная часть обработки ошибок. Есть две основные категории: проверяемые (checked) и непроверяемые (unchecked).

Проверяемые исключения (Checked Exceptions):
✅ Должны быть явно обработаны в коде с помощью блока try-catch или должны быть указаны в сигнатуре метода с помощью ключевого слова throws.
✅ Они представляют ошибки, которые могут возникнуть во время выполнения программы и которые во многих случаях программист может предвидеть и обработать. Например, ошибка чтения файла, когда файл не существует.
✅ Примеры классов проверяемых исключений включают IOException, FileNotFoundException, ClassNotFoundException и другие.

Пример:

try {
    FileInputStream file = new FileInputStream("non_existent_file.txt");
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

В этом примере FileNotFoundException является проверяемым исключением, и его необходимо обрабатывать в блоке try-catch.

Непроверяемые исключения (Unchecked Exceptions):
✅ Не требуют обязательной обработки в коде. Они обычно возникают из-за ошибок программирования, таких как деление на ноль или доступ к элементу за пределами массива.
✅ К ним относятся ошибки времени выполнения (RuntimeException) и ошибки (Error).
✅ Примеры включают NullPointerException, IndexOutOfBoundsException, ArithmeticException и другие.

Пример:

int result = 10 / 0; // Приводит к ArithmeticException

Здесь ArithmeticException является непроверяемым исключением, вызванным делением на ноль.

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

➡ Примеры ответов
➡ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

❓ Какие методы в классе Object есть ?
Спросят с вероятностью 69%

Object - суперкласс для всех классов. Все объекты, включая массивы, наследуют методы этого класса. Они предоставляют функции, которые доступны для любого объекта. Вот основные методы:

1️⃣ clone() - создает и возвращает копию объекта. Метод защищенный, поэтому его можно вызвать только внутри класса объекта или в классах потомках.

2️⃣ equals(Object obj) - определяет равенство между двумя объектами. По умолчанию, этот метод сравнивает ссылки на объекты.

3️⃣ finalize() - вызывается перед удалением объекта сборщиком мусора. Метод устарел.

4️⃣ getClass() - возвращает Class, который представляет класс данного объекта. Можно использовать для получения имени во время выполнения.

5️⃣ hashCode() - возвращает хеш-код, который используется для оптимизации хранения в структурах данных.

6️⃣ notify() - пробуждает один поток, который ожидает на объекте (вызвавший wait()). Этот метод должен вызываться в синхронизированном контексте.

7️⃣ notifyAll() - пробуждает все ожидающие потоки. Должен вызываться в синхронизированном контексте.

8️⃣ toString() - возвращает строковое представление. По умолчанию, возвращает класс и хеш-код, но часто переопределяется для предоставления более информативного представления.

9️⃣ wait() - заставляет текущий поток ожидать, пока другой поток не вызовет notify() или notifyAll(). Существуют перегруженные версии wait(long timeout) и wait(long timeout, int nanos), позволяющие указать максимальное время ожидания.

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

➡ Примеры ответов
➡ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

❓ Что известно про иерархию исключений ?
Спросят с вероятностью 69%

Иерархия исключений организована в виде дерева наследования, где все классы исключений являются потомками класса Throwable. Он делится на два основных подкласса: Error и Exception.

1️⃣ Throwable
От него напрямую наследуются классы Error и Exception. Этот класс содержит методы для получения сообщения об ошибке, локализованного сообщения, причины исключения и стека вызовов, а также методы для подавления исключений и работы со стеком вызовов.

2️⃣ Error
Error описывает серьёзные ошибки, возникающие на уровне виртуальной машины и библиотеки языка, из-за которых приложение обычно не может восстановиться. Примеры включают OutOfMemoryError и StackOverflowError. Ошибки этого типа обычно не предназначены для обработки приложением.

3️⃣ Exception
Этот класс и подклассы описывают исключения, с которыми приложение может и должно справиться. Делится на две большие категории: проверяемые(checked exceptions) и непроверяемые исключения (unchecked exceptions).

✅ Проверяемые исключения
Требуют обязательной обработки в блоке try-catch или должны быть объявлены в сигнатуре метода с помощью throws. Они бозначают условия, с которыми приложение может предвидеть и справиться. Примеры включают IOException, FileNotFoundException и ClassNotFoundException.

✅ Непроверяемые исключения
Являются непроверяемыми исключениями. Они обозначают ошибки, такие как неверное приведение типов (ClassCastException), обращение по нулевой ссылке (NullPointerException) и выход за пределы массива (ArrayIndexOutOfBoundsException). Эти исключения не требуют обязательной обработки в блоке try-catch.

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

➡ Примеры ответов
➡ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое SOLID ?
Спросят с вероятностью 62%

SOLID — это акроним, представляющий пять основных принципов ООП и дизайна, направленных на повышение гибкости, масштабируемости и поддерживаемости ПО. Они помогает избежать проблемы с проектированием, такие как жесткая зависимость между компонентами программы и сложности в внесении изменений или добавлении новых функций.

1️⃣ Принцип единственной ответственности (SRP): Подчеркивает важность разделения функциональности, чтобы каждый класс выполнял только одну задачу.

class UserSettings {
       void changeEmail(User user) {
           if(checkAccess(user)) {
               // Изменение email пользователя
           }
       }

       boolean checkAccess(User user) {
           // Проверка прав доступа
           return true;
       }
   }

Здесь класс UserSettings нарушает SRP, если бы в нем также были методы для управления пользователями. Лучше вынести метод checkAccess в отдельный класс.

2️⃣ Принцип открытости/закрытости (OCP): Можно добавлять новую функциональность, не изменяя существующий код.

3️⃣ Принцип подстановки Лисков (LSP): Классы-наследники должны дополнять, а не изменять поведение базовых классов.

4️⃣ Принцип разделения интерфейса (ISP): Этот принцип ведет к созданию узкоспециализированных интерфейсов, вместо одного "толстого" интерфейса.

5️⃣ Принцип инверсии зависимостей (DIP): Оба типа модулей должны зависеть от абстракций. Абстракции не должны зависеть от деталей, а детали должны зависеть от абстракций. Этот принцип направлен на уменьшение зависимостей между модулями программы.

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

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что делает принцип happens before в рамках многопоточности ?
Спросят с вероятностью 12%

Принцип "happens-before" в контексте многопоточности определяет правила, при которых одно действие (операция чтения или записи переменной) считается предшествующим другому действию в исполнении программы. Это ключевой механизм для обеспечения видимости изменений, сделанных одним потоком, другими потоками, а также для гарантии корректной синхронизации между потоками без возникновения гонок данных (race conditions).

Этот принцип устанавливает порядок действий таким образом, что если действие A happens-before действия B, то все изменения, сделанные в A, будут видны в B (и не наоборот). Это не обязательно означает, что A физически выполняется до B, но с точки зрения видимости изменений и порядка операций, JVM и аппаратное обеспечение гарантируют, что B увидит результаты, произведённые A.

Ключевые правила:

1️⃣Правило программного порядка: Операции внутри одного потока выполняются в порядке их программирования. Операции, выполненные ранее в потоке, happens-before операций, выполненных позже.

2️⃣Правило блокировки монитора: Освобождение монитора (выход из синхронизированного блока) happens-before последующего захвата этого же монитора другим потоком.

3️⃣Правило volatile переменных: Запись в volatile переменную happens-before любых последующих чтений этой же переменной другими потоками.

4️⃣Правило передачи по ссылке: Если поток A копирует переменную doSomething в threadB.start(), и threadB видит значение doSomething при запуске, то все действия в A до копирования happens-before действий в threadB.

5️⃣Правило начала потока: Все действия в потоке happens-before любого действия в другом потоке, которое видит, что первый поток был запущен.

6️⃣Правило завершения потока: Все действия в потоке happens-before того, как другой поток успешно возвращает результат из Thread.join() на завершившемся потоке.

Значение принципа:

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

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Как организована HashMap ?
Спросят с вероятностью 56%

HashMap — это структура данных, которая использует хеш-таблицу для хранения пар "ключ-значение". Gозволяет выполнять операции вставки, удаления и поиска элементов с почти постоянным временем выполнения, что делает её очень эффективной для определённых задач. Вот как она организована:

Внутреннее устройство

1️⃣ Хеш-функция: Ключи хранятся с использованием хеш-функции, которая преобразует ключ в индекс массива. Этот индекс используется для хранения значения в массиве. Она должна равномерно распределять ключи по индексам массива, чтобы минимизировать коллизии.

2️⃣ Массив бакетов (корзин): Внутри, она состоит из массива бакетов, где каждый бакет представляет собой "корзину", которая может хранить одну или более пар "ключ-значение". При добавлении новой пары "ключ-значение", хеш-функция вычисляет индекс бакета для хранения значения на основе хеш-кода ключа.

3️⃣ Связный список или дерево: В случае коллизии, когда два разных ключа имеют одинаковый хеш-код и попадают в один и тот же бакет, HashMap использует структуру данных в виде связного списка или дерева для хранения и разрешения коллизий. После определённого порога коллизий, список преобразуется в дерево для улучшения производительности поиска в этом бакете.

Работа

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

- Поиск: Поиск значения по ключу также начинается с вычисления хеш-кода ключа, определения индекса бакета и последующего поиска в связном списке или дереве этого бакета.

- Удаление: Удаление пары "ключ-значение" происходит аналогично поиску: сначала находится бакет, затем в нём ищется и удаляется элемент.

Расширение

Когда фактор заполнения HashMap превышает определённый порог, происходит автоматическое расширение массива бакетов и перехеширование всех элементов для равномерного распределения по новому массиву бакетов. Это обеспечивает высокую производительность HashMap даже при большом количестве элементов.

HashMap — это мощная и эффективная структура данных для хранения и быстрого доступа к данным через ключи. Благодаря использованию хеш-таблиц, HashMap обеспечивает быстрые операции вставки, поиска и удаления. Разрешение коллизий с помощью связных списков или деревьев и автоматическое расширение помогают поддерживать производительность на высоком уровне.

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое Dispatcher Servlet ?
Спросят с вероятностью 12%

DispatcherServlet является ключевым компонентом, который работает как фронтальный контроллер (front controller) в паттерне проектирования MVC (Model-View-Controller) для веб-приложений. Он управляет всем процессом маршрутизации входящих HTTP запросов к соответствующим обработчикам (контроллерам), а также управляет дальнейшим процессом отображения результатов работы этих обработчиков.

Как он работает:

1️⃣Прием запроса: Принимает все входящие HTTP запросы к приложению.

2️⃣Определение обработчика: Он определяет, какой контроллер должен обработать запрос, на основе конфигурации маршрутов (URL mappings).

3️⃣Делегирование запроса: Затем он делегирует запрос выбранному контроллеру.

4️⃣Обработка запроса: Контроллер обрабатывает запрос и возвращает модель (данные) и имя представления (view) назад к DispatcherServlet.

5️⃣Отображение представления: Передает модель в представление (view), которое генерирует финальный HTML (или другой формат) для клиента.

6️⃣Отправка ответа: Наконец, он отправляет ответ клиенту.

Преимущества использования:

✅Централизованное управление: Предоставляет единую точку входа для всех запросов к приложению, что упрощает конфигурацию и управление маршрутизацией.

✅Гибкая маршрутизация: Позволяет легко определить маршруты, параметры URL и другие аспекты маршрутизации с помощью аннотаций или XML конфигурации.

✅Поддержка различных типов ответов: Поддерживает генерацию различных типов ответов — от HTML страниц до JSON или XML данных для REST API.

✅Обработка исключений: Обеспечивает централизованную обработку исключений, что позволяет удобно управлять ошибками на уровне приложения.

✅Интеграция с другими компонентами Spring: Легко интегрируется с другими компонентами и сервисами Spring, такими как Spring Security, Spring Data и т.д.

В традиционном веб-приложении на базе Spring DispatcherServlet обычно конфигурируется в файле web.xml или через Java-конфигурацию в приложениях на Spring Boot, где DispatcherServlet автоматически настраивается без необходимости явного определения.

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое иерархия коллекций ?
Спросят с вероятностью 62%

Иерархия коллекций — это набор интерфейсов и классов, которые предоставляют общие структуры данных, такие как списки, множества и карты. Находится в пакете java.util и разработана для работы с группами объектов.

Основные интерфейсы:

- Collection Interface: Корневой интерфейс иерархии коллекций. Определяет методы, такие как add(), remove(), size(), isEmpty() и iterator(), которые должны быть реализованы всеми коллекциями.

- List Interface: Представляет упорядоченную коллекцию. Элементы в списке могут быть доступны по индексам. Допускает дублирование элементов. Реализации включают ArrayList, LinkedList и Vector.

- Set Interface: Набор уникальных элементов. Не допускает дублирования элементов. Реализации включают HashSet, LinkedHashSet и TreeSet.

- Queue Interface: Для работы с коллекциями, используемыми для хранения элементов перед обработкой. Поддерживает операции вставки, извлечения и инспекции. LinkedList реализует как List, так и Queue. Также есть PriorityQueue для элементов, которые должны обрабатываться в порядке приоритета.

- Map Interface: Не наследуется от Collection интерфейса. Описывает структуру для хранения пар ключ/значение. Ключи уникальны, а значения могут дублироваться. Реализации включают HashMap, LinkedHashMap, TreeMap и Hashtable.

Особенности классов:

- ArrayList: Динамический массив для хранения элементов, который автоматически расширяется. Предлагает быстрый доступ к элементам по индексу.

- LinkedList: Двусвязный список, который обеспечивает эффективное добавление/удаление элементов. Может использоваться как список и очередь.

- HashSet: Использует хеш-таблицу для хранения уникальных элементов. Не гарантирует порядок элементов.

- LinkedHashSet: Расширяет HashSet, сохраняя порядок вставки элементов.

- TreeSet: Хранит элементы в отсортированном и восходящем порядке. Использует красно-черное дерево.

- HashMap: Хеш-таблица для хранения пар ключ/значение. Не поддерживает упорядоченность ключей или значений.

- LinkedHashMap: Расширяет HashMap, сохраняя порядок вставки ключей.

- TreeMap: Реализует красно-черное дерево, сохраняет ключи в отсортированном порядке.

- PriorityQueue: Элементы добавляются согласно их приоритету, определенному компаратором.

Суть иерархии коллекций

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

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Как "под капотом" работает аннотация transactional ?
Спросят с вероятностью 12%

Аннотация @Transactional предоставляет мощный и гибкий способ управления транзакциями приложениях. Используя эту аннотацию, разработчики могут декларативно управлять границами транзакций на уровне классов или методов, не заботясь о низкоуровневых операциях управления транзакциями. Вот как он работает:

1️⃣ Прокси

При старте приложения он сканирует компоненты на предмет наличия аннотации @Transactional и создаёт для них прокси-объекты. Эти прокси используются для перехвата вызовов к методам, отмеченным аннотацией. В зависимости от настроек, прокси может быть основан на JDK динамических прокси (для интерфейсов) или на CGLIB прокси (для классов).

2️⃣ Перехват вызовов

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

3️⃣ Управление транзакцией

Делегирует управление транзакцией менеджеру транзакций (PlatformTransactionManager), специфичному для используемой технологии доступа к данным (JPA, JDBC, Hibernate и т.д.). Менеджер транзакций отвечает за начало, коммит и откат транзакции.

4️⃣ Исполнение бизнес-логики

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

5️⃣ Атрибуты аннотации

Аннотация @Transactional позволяет настраивать различные аспекты управления транзакцией, включая:
- propagation — правила распространения транзакций;
- isolation — уровень изоляции транзакции;
- readOnly — указывает, является ли транзакция только для чтения;
- timeout — максимальное время выполнения транзакции;
- rollbackFor и noRollbackFor — классы исключений, при которых транзакция должна быть откачена или не откачена.

Аннотация @Transactional упрощает управление транзакциями, позволяя разработчикам фокусироваться на бизнес-логике, в то время как Spring заботится о транзакционной границе и корректном управлении транзакциями "под капотом". Важно правильно настраивать атрибуты аннотации и понимать механизмы работы транзакций, чтобы обеспечить надёжность и производительность приложения.

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое Parallel Stream ?
Спросят с вероятностью 12%

Parallel Stream является частью Java Stream API, который представлен. Это мощное средство для выполнения параллельной обработки данных, позволяя разработчикам легко писать многопоточный код. Он использует ForkJoinPool, который по умолчанию создаёт столько рабочих потоков, сколько у вас ядер процессора, для разделения задачи на подзадачи и их параллельной обработки, а затем объединения результатов. Это позволяет значительно ускорить выполнение операций с большими объёмами данных за счёт распараллеливания вычислений.

Как он работает

Когда вы вызываете метод parallelStream() на коллекции или используете метод parallel() на потоке данных, Java автоматически старается распараллелить выполнение операций над этим потоком данных. Однако степень ускорения, которую можно получить, сильно зависит от количества данных, типа выполняемых операций и доступных системных ресурсов.

Пример:

List<String> strings = Arrays.asList("one", "two", "three", "four");
List<String> result = strings.parallelStream()
                             .map(String::toUpperCase)
                             .collect(Collectors.toList());

В этом примере parallelStream() используется для создания параллельного потока из списка строк, каждая строка преобразуется в верхний регистр с помощью метода map, а результат собирается обратно в список.

Важные моменты:

✅ Не всегда быстрее: Параллельная обработка не всегда быстрее последовательной из-за накладных расходов на разделение данных на части и их последующее слияние. Для небольших объёмов данных или операций с низкой вычислительной сложностью использование параллельных потоков может даже ухудшить производительность.

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

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

Parallel Stream — это мощный инструмент для ускорения обработки больших объёмов данных за счёт параллельного выполнения операций. Однако его эффективность зависит от множества факторов, и его использование требует понимания особенностей параллельной обработки данных.

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Какие знаешь варианты dependency injectio ?
Спросят с вероятностью 12%

Внедрение зависимостей (Dependency Injection, DI) — это ключевой принцип в разработке ПО, позволяющий уменьшить связность между компонентами программы и упростить их тестирование. DI может быть реализовано различными способами, в зависимости от используемых технологий и фреймворков. Существуют следующие основные способы внедрения зависимостей:

1️⃣Внедрение через конструктор (Constructor Injection)

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

@Component
public class MyService {
    private final Dependency dependency;

    @Autowired
    public MyService(Dependency dependency) {
        this.dependency = dependency;
    }
}

2️⃣Внедрение через сеттер (Setter Injection)

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

@Component
public class MyService {
    private Dependency dependency;

    @Autowired
    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }
}

3️⃣Внедрение через поля (Field Injection)

Непосредственно в поля класса без использования сеттеров или конструктора. Хотя это удобно и уменьшает количество кода, такой подход может затруднить тестирование и не гарантирует завершённость состояния объекта после его создания.

@Component
public class MyService {
    @Autowired
    private Dependency dependency;
}

4️⃣Внедрение через методы (Method Injection)

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

@Component
public class MyService {
    private Dependency dependency;

    @Autowired
    public void initialize(Dependency dependency) {
        this.dependency = dependency;
    }
}

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

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые