Что лежит в основе Spring ?
Спросят с вероятностью 12%

В основе фреймворка Spring лежит концепция инверсии управления (IoC, Inversion of Control) и внедрения зависимостей (DI, Dependency Injection). Эти принципы обеспечивают гибкость, расширяемость и удобство в управлении зависимостями между компонентами приложения, делая код более модульным, тестируемым и поддерживаемым.

Инверсия управления (IoC)

Это парадигма, при которой контроль над выполнением программы частично или полностью передаётся фреймворку или библиотеке. В контексте Spring IoC означает, что сам фреймворк управляет созданием объектов и их жизненным циклом, а не программист напрямую. Это достигается через использование "контейнера IoC", который автоматически создаёт и связывает объекты в соответствии с конфигурацией приложения, заданной в XML-файлах, аннотациях или Java-конфигурации.

Внедрение зависимостей (DI)

Это техника реализации IoC, при которой объектам "внедряются" или "предоставляются" их зависимости извне. Вместо того чтобы компоненты приложения самостоятельно создавали или искали необходимые им объекты (зависимости), Spring контейнер автоматически предоставляет им все необходимые зависимости в момент создания объекта. Это уменьшает связность между компонентами и упрощает управление зависимостями, а также их изменение и тестирование.

Основные компоненты

✅Spring Core Container: Включает в себя IoC и DI, обеспечивая основу для фреймворка.
✅Spring AOP (Aspect-Oriented Programming): Позволяет реализовывать поперечные задачи (например, логирование, транзакции) в виде аспектов, не изменяя основной бизнес-логики.
✅Spring MVC: Фреймворк для создания веб-приложений по модели MVC.
✅Spring Boot: Предоставляет набор инструментов для быстрой разработки и запуска приложений с минимальной конфигурацией.
✅Spring Data: Упрощает доступ к данным, работу с базами данных и операциями CRUD.
✅Spring Security: Предоставляет комплексные средства безопасности для аутентификации и авторизации.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что делает ключевое слово transient ?
Спросят с вероятностью 12%

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

Зачем его использовать:

1️⃣Конфиденциальность данных: Если какие-то данные в объекте являются конфиденциальными или не должны быть сохранены (например, пароли или личная информация), их можно пометить как transient, чтобы предотвратить их сохранение.

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

3️⃣Экономия места: Исключение ненужных данных из процесса сериализации может сократить объём занимаемого места и ускорить процесс сохранения/загрузки.

Пример:

import java.io.*;

public class User implements Serializable {
    private String name;
    private transient String password; // Пароль не будет сериализован

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    // Геттеры и сеттеры
}

public class Main {
    public static void main(String[] args) {
        User user = new User("username", "secretPassword");
        
        // Здесь может быть код для сериализации объекта user
    }
}

В этом примере, если объект User будет сериализован, значение поля password сохранено не будет из-за модификатора transient, тогда как name будет сохранён.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

В чем разница между dependency injection и Inversion of control ?
Спросят с вероятностью 19%

Dependency Injection (DI) и Inversion of Control (IoC) — это два тесно связанных принципа в программировании, особенно в контексте разработки. Хотя эти термины часто используются как взаимозаменяемые, они описывают разные, хотя и взаимосвязанные концепции.

Inversion of Control (IoC)

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

Цель — уменьшить связанность между компонентами программы, делая её более модульной, гибкой и поддерживаемой. IoC достигается различными способами, одним из которых является Dependency Injection.

Dependency Injection (DI)

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

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

Основные различия:

- IoC — это более общий принцип, который описывает подход к дизайну, при котором управление программой инвертировано по сравнению с традиционным подходом. IoC можно реализовать разными способами, включая, но не ограничиваясь, Dependency Injection.
- DI — это метод реализации IoC, который конкретизирует, как зависимости предоставляются объектам. DI является одним из способов достижения принципа IoC.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

В чём разница между final vs. finally vs. finalize ?
Спросят с вероятностью 25%

Ключевые слова final, finally, и finalize имеют совершенно разные цели и контексты использования, хотя на первый взгляд могут показаться похожими из-за схожести их названий.

final

Это модификатор, который может быть использован с переменными, методами и классами.

- Когда он применяется к переменной, это означает, что переменная может быть присвоена только один раз и её значение не может быть изменено после присваивания.
- Когда он используется с методом, это предотвращает переопределение метода в подклассах.
- Когда он применяется к классу, это означает, что класс не может быть наследован.
final int x = 100; // переменная, которую нельзя изменить
public final void myMethod() {} // метод, который нельзя переопределить
public final class MyFinalClass {} // класс, от которого нельзя наследоваться

finally

Это блок кода, который используется вместе с блоками try и catch для обработки исключений. Блок finally выполняется всегда после выполнения блока try/catch, независимо от того, было ли выброшено исключение или нет. Это идеальное место для кода очистки, например, для закрытия файловых потоков или освобождения других ресурсов.
try {
// код, который может вызвать исключение
} catch (Exception e) {
// обработка исключения
} finally {
// код, который выполняется всегда
}

finalize

Это метод класса Object, который вызывается сборщиком мусора перед тем, как объект будет уничтожен. Этот метод можно переопределить в классе для реализации очистки ресурсов или других операций перед уничтожением объекта. Однако его использование не рекомендуется из-за его непредсказуемости и малой эффективности, а также потому, что он может вызвать задержку в сборке мусора.
@Override
protected void finalize() throws Throwable {
try {
// очистка ресурсов
} finally {
super.finalize();
}
}

- final используется для создания констант, предотвращения наследования классов и переопределения методов.
- finally гарантирует выполнение кода после блока try/catch, обычно для очистки ресурсов.
- finalize предназначен для очистки перед уничтожением объекта, но его использование не рекомендуется.

Каждое из этих ключевых слов имеет уникальное применение и важно в контексте разработки.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

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

Future представляет собой абстракцию, которая обеспечивает результат асинхронной операции. Он является интерфейсом, который находится в пакете java.util.concurrent. Он используется для представления результата, который будет получен в будущем, после завершения выполнения асинхронной задачи. Онпредоставляет методы для проверки завершения задачи, получения результата выполнения, отмены задачи и проверки её состояния.

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

✅boolean cancel(boolean mayInterruptIfRunning): Пытается отменить выполнение задачи. Параметр mayInterruptIfRunning указывает, следует ли прерывать выполнение задачи, если она уже запущена.
✅boolean isCancelled(): Возвращает true, если задача была отменена до её нормального завершения.
✅boolean isDone(): Возвращает true, если задача завершилась, была отменена или по каким-либо другим причинам не может быть продолжена.
✅V get(): Ожидает завершения задачи и возвращает её результат. Метод блокируется до тех пор, пока результат не станет доступен.
✅V get(long timeout, TimeUnit unit): Ожидает завершения задачи в течение заданного времени и возвращает её результат, если он доступен. Если результат не доступен в течение указанного времени, выбрасывается исключение TimeoutException.

Применение:

Он часто используется в сочетании с пулом потоков (ExecutorService), который предоставляет методы для асинхронного выполнения задач. Например, метод submit(Callable<T> task) пула потоков возвращает объект Future<T>, который можно использовать для получения результата асинхронной задачи.

Пример:

ExecutorService executor = Executors.newCachedThreadPool();
Callable<Integer> task = () -> {
    // Имитация длительной операции
    TimeUnit.SECONDS.sleep(1);
    return 123;
};

Future<Integer> future = executor.submit(task);

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

try {
    // Получение результата асинхронной задачи
    Integer result = future.get(); // Блокируется до завершения задачи
    System.out.println("Результат: " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

executor.shutdown();

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое race condition ?
Спросят с вероятностью 25%

Race condition (условие гонки) — это ситуация в многопоточной или распределенной системе, когда порядок выполнения операций влияет на результат работы программы, и этот порядок не может быть гарантирован. То есть, результат выполнения программы становится непредсказуемым из-за соревнования между потоками за доступ к общим ресурсам.

Часто возникают в следующих случаях:

1️⃣ Доступ к общим данным: Если два или более потока читают и пишут в одну и ту же переменную без должной синхронизации, конечное значение переменной может зависеть от того, в каком порядке потоки выполняют свои операции.
2️⃣ Зависимость от порядка выполнения: Когда корректность выполнения программы зависит от порядка выполнения операций между потоками, без явного контроля этого порядка.

Пример:
public class Counter {
private int count = 0;

public void increment() {
count++; // Несмотря на кажущуюся атомарность, операция не атомарна и состоит из трех шагов: чтение, инкремент, запись
}

public int getCount() {
return count;
}
}

public class RaceConditionDemo {
public static void main(String[] args) throws InterruptedException {
final Counter counter = new Counter();

Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});

Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});

t1.start();
t2.start();

t1.join();
t2.join();

System.out.println(counter.getCount()); // Ожидаемый результат 2000, но может быть меньше из-за условия гонки
}
}

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

Решение проблемы

Для предотвращения этого используются механизмы синхронизации, такие как блокировки (synchronized блоки в Java), мьютексы, семафоры и другие средства для контроля доступа к общим ресурсам. Эти механизмы гарантируют, что только один поток может выполнять критический участок кода, который взаимодействует с общим ресурсом, в любой момент времени.
public synchronized void increment() {
count++;
}

Добавление synchronized к методу increment() гарантирует, что в каждый момент времени только один поток может выполнить этот метод, что предотвращает условия гонки в данном случае.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

В чем идея многопоточности ?
Спросят с вероятностью 25%

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

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

Основные преимущества:

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

Однако она также вводит сложность в разработку программного обеспечения, поскольку разработчикам необходимо учитывать вопросы синхронизации доступа к общим ресурсам, управления состоянием потоков и потенциальных проблем с безопасностью потоков, таких как гонки за данные (race conditions), взаимные блокировки (deadlocks) и проблемы с последовательностью операций.

Примером многопоточности может служить создание потоков через наследование от класса Thread или реализацию интерфейса Runnable:

class MyThread extends Thread {
    public void run() {
        System.out.println("Поток запущен.");
    }
}

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Поток запущен через Runnable.");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();

        Thread t2 = new Thread(new MyRunnable());
        t2.start();
    }
}

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое нормализация баз данных ?
Спросят с вероятностью 31%

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

Цели:
✅ Избежание избыточности данных: Уменьшение повторяющихся данных в таблицах.
✅ Улучшение целостности данных: Обеспечение точности и надежности данных путем установления правил и ограничений.
✅ Оптимизация запросов: Улучшение производительности базы данных за счет сокращения объема данных, обрабатываемых в запросах.

Она обычно достигается путем применения серии "нормальных форм" — правил, которые должны быть применены к структуре базы данных. Существует несколько нормальных форм, каждая из которых решает определенные проблемы избыточности и зависимости данных. Наиболее часто используются первая (1NF), вторая (2NF), третья (3NF) и иногда четвертая (4NF) и пятая (5NF) нормальные формы.

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

2️⃣ Вторая нормальная форма (2NF): Достигается путем удаления данных, которые зависят только от части первичного ключа в таблицах с составным ключом.

3️⃣ Третья нормальная форма (3NF): Требует, чтобы все данные в таблице были зависимы только от первичного ключа и устраняет транзитивные зависимости (когда одно поле зависит от другого поля, которое не является первичным ключом).

4️⃣ Четвертая нормальная форма (4NF): Дополнительно устраняет многозначные зависимости, когда наличие двух или более независимых отношений в одной таблице вызывает избыточность.

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое полиморфизм ?
Спросят с вероятностью 25%

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

1️⃣ Статический (компиляционный) полиморфизм: Реализуется с помощью перегрузки методов и операторов. При перегрузке методов методы в одном классе имеют одинаковое имя, но различаются количеством и типом параметров. Компилятор определяет, какой метод вызывать, исходя из аргументов вызова метода.
public class Example {
public void display(int a) {
System.out.println("Число: " + a);
}
public void display(String a) {
System.out.println("Строка: " + a);
}
}

2️⃣ Динамический (выполнения) полиморфизм: Реализуется с помощью переопределения методов. В этом случае подклассы имеют методы, которые имеют такое же имя и сигнатуру, как и в суперклассе, но реализация методов может отличаться. Какой метод будет вызван, определяется во время выполнения программы, основываясь на типе объекта.
class Animal {
void sound() {
System.out.println("Животное издает звук");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Собака лает");
}
}

Использование:
Animal myAnimal = new Dog();
myAnimal.sound(); // Выведет: Собака лает

Зачем нужен полиморфизм?

✅ Гибкость и расширяемость кода: Позволяет писать более обобщенный код, который может работать с объектами разных классов. Это упрощает добавление новых классов, которые могут использоваться существующим кодом без его изменения.
✅ Уменьшение связности: Помогает снизить зависимость между компонентами системы, поскольку компоненты могут взаимодействовать друг с другом через общие интерфейсы, не заботясь о конкретной реализации.
✅ Сокрытие реализации: Клиентский код может использовать интерфейс без знания о внутренней реализации объекта, что повышает безопасность и модульность программы.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Сколько существует нормальных форм ?
Спросят с вероятностью 19%

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

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

2️⃣ Вторая нормальная форма (2NF): Достигается, когда таблица находится в 1NF, и все атрибуты (не ключевые поля) полностью зависят от первичного ключа.

3️⃣ Третья нормальная форма (3NF): Таблица должна быть во 2NF, и все её атрибуты должны быть зависимы только от первичного ключа, а не от других не ключевых атрибутов.

4️⃣ Нормальная форма Бойса-Кодда (BCNF): Усиление 3NF, требующее, чтобы каждый детерминант был кандидатом в ключи. Это помогает разрешить некоторые проблемы, которые могут оставаться после применения 3NF.

5️⃣ Четвертая нормальная форма (4NF): Требует, чтобы таблица была в BCNF и не содержала многозначных зависимостей, кроме зависимостей, обусловленных первичным ключом.

6️⃣ Пятая нормальная форма (5NF): Таблица должна быть в 4NF, и все её объединения должны быть без потерь, то есть любые две таблицы, полученные в результате декомпозиции, должны успешно соединяться обратно в исходную таблицу без потери данных.

7️⃣ Доменно-ключевая нормальная форма (DKNF): Достигается, когда таблица имеет только ограничения домена и ключей, исключая любые другие виды логических зависимостей.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Чем singleton отличается от prototype ?
Спросят с вероятностью 25%

Singleton и Prototype относятся к категории порождающих шаблонов проектирования. Они решают разные проблемы и имеют разные применения в разработке программного обеспечения.

Singleton предназначен для обеспечения того, чтобы класс имел только один экземпляр во всем приложении и предоставлял глобальную точку доступа к этому экземпляру. Это достигается за счет того, что конструктор класса делается приватным, а создание экземпляра класса осуществляется через статический метод, который проверяет, существует ли уже экземпляр этого класса, и если нет, то создает его. Часто используется для управления ресурсами, такими как соединение с базой данных, где необходимо использовать только одно соединение на всё приложение.
public class Singleton {
private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

Prototype, напротив, используется для создания новых объектов, копированием существующего объекта-прототипа. Это полезно, когда создание экземпляра класса является ресурсоемким процессом или когда требуется создать копию объекта, сохраняя его состояние. Это часто достигается с помощью реализации интерфейса Cloneable и переопределения метода clone().
public class Prototype implements Cloneable {
private String field;

public Prototype(String field) {
this.field = field;
}

@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

Основные отличия:

✅ Цель использования: Singleton гарантирует, что класс имеет только один экземпляр, в то время как Prototype предназначен для создания новых объектов путем копирования существующего объекта.
✅ Метод создания объекта: В Singleton объект создается через статический метод, контролирующий его экземпляр, в Prototype новый объект создается копированием (клонированием) существующего.
✅ Применение: Singleton часто используется для управления доступом к ресурсам, которые должны быть единственными в приложении, например, соединение с базой данных. Prototype используется, когда нужно избежать затрат на создание объекта с нуля, вместо этого копируя существующий объект.

Основное отличие между Singleton и Prototype заключается в их цели и способе создания объектов: Singleton обеспечивает единственность экземпляра класса, в то время как Prototype фокусируется на создании новых объектов путем копирования.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

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

ACID — это акроним, обозначающий четыре ключевых свойства, которые гарантируют надежную обработку транзакций в базах данных. Эти свойства включают:

1️⃣ Атомарность (Atomicity): Это свойство гарантирует, что каждая транзакция в базе данных рассматривается как единое целое, где либо все операции в транзакции выполняются полностью, либо не выполняются вовсе. Если какая-либо часть транзакции не удается выполнить, вся транзакция откатывается (отменяется), и состояние данных остается таким, как если бы транзакция не выполнялась вовсе.

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

2️⃣ Согласованность (Consistency): Это свойство обеспечивает, что транзакция переводит базу данных из одного согласованного состояния в другое. Она гарантирует, что выполнение транзакции не нарушает никаких ограничений базы данных и что все данные остаются валидными после выполнения транзакции.

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

3️⃣ Изолированность (Isolation): Это свойство обеспечивает, что транзакции выполняются независимо друг от друга и изменения, вносимые одной транзакцией, не видны другим транзакциям до их завершения. Она предотвращает проблемы, такие как "грязное чтение" или "потерянные обновления", которые могут возникнуть при одновременном выполнении нескольких транзакций.

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

4️⃣ Долговечность (Durability): Это свойство гарантирует, что однажды успешно завершенная транзакция будет сохранена постоянно, даже в случае сбоя системы. Данные не теряются после подтверждения транзакции.

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

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

Метод finalize() — это метод, определённый в классе Object, который вызывается сборщиком мусора перед тем, как объект будет уничтожен. Этот метод предоставляется как средство для выполнения любой необходимой финализации, например, освобождения ресурсов (таких как закрытие файлов или соединений с базами данных), которые не управляются сборщиком мусора Java.

Особенности:

✅Не гарантируется вызов: Вызов его не гарантирован. JVM делает попытку вызвать finalize() на объекте перед уничтожением, но время вызова, а иногда и сам факт вызова, может быть неопределённым.
✅Может привести к задержкам: Использование его может существенно снизить производительность сборки мусора, поскольку требует выполнения дополнительных шагов перед уничтожением объекта.
✅Возможность "воскрешения" объекта: В теле метода его можно теоретически "воскресить" объект, сделав его снова достижимым, например, присвоив его ссылку статическому члену. Однако это практика считается крайне нежелательной и может привести к непредсказуемому поведению программы.

Рекомендации:

Из-за указанных выше недостатков и неопределённости использование finalize() не рекомендуется начиная с Java 9. Вместо этого рекомендуется использовать другие механизмы управления ресурсами, такие как:

✅try-with-resources для автоматического закрытия ресурсов, которые реализуют интерфейс AutoCloseable.
✅Определение явных методов очистки ресурсов в классах, что даёт больший контроль над процессом освобождения ресурсов.

Пример:

Ниже представлен пример класса с переопределённым методом finalize(). Однако помните, что это пример для иллюстрации, и использование его на практике не рекомендуется.

public class ExampleClass {
    
    @Override
    protected void finalize() throws Throwable {
        try {
            // Освобождение ресурсов или другая финализация
            System.out.println("Финализация ресурсов объекта");
        } finally {
            super.finalize();
        }
    }
    
    public static void main(String[] args) {
        ExampleClass obj = new ExampleClass();
        obj = null;
        
        // Подсказка JVM выполнить сборку мусора
        System.gc();
        
        System.out.println("Главный метод завершён");
    }
}

Этот код пытается иллюстрировать использование finalize(), но помните, что вызов System.gc() не гарантирует немедленную сборку мусора или вызов finalize().

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Можно ли переопределить статические методы ?
Спросят с вероятностью 12%

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

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

Пример:

class Parent {
    static void test() {
        System.out.println("Метод из Parent");
    }
}

class Child extends Parent {
    static void test() {
        System.out.println("Метод из Child");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent childAsParent = new Child();
        Child child = new Child();

        parent.test(); // Выводит: Метод из Parent
        childAsParent.test(); // Выводит: Метод из Parent, несмотря на то, что объект типа Child
        child.test(); // Выводит: Метод из Child
    }
}

В этом примере, несмотря на то что переменная childAsParent ссылается на объект типа Child, вызывается статический метод класса Parent, потому что тип данной переменной — Parent, и решение о том, какой метод вызвать, принимается во время компиляции на основе типа переменной.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

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

Строка представляет собой последовательность символов и является объектом класса String. Они неизменяемы (immutable), что означает, что однажды созданный объект String не может быть изменён. Если вам нужно изменить строку, на самом деле создаётся новый объект String с изменённым содержимым.

Основные особенности строк:

✅Неизменяемость: Как только она создана, её содержимое не может быть изменено. Любые операции, кажущиеся изменяющими строку, на самом деле создают новый объект String.
✅String Pool: Для экономии памяти использует механизм "пула строк" (String Pool). Это специальная область в куче (Heap), где хранятся все уникальные литералы строк, используемые в программе. Если строка уже существует в пуле, Java использует ту же ссылку, вместо создания нового объекта String.
✅Кодировка: Строки в Java кодируются в UTF-16, где каждый символ (в основном) занимает 2 байта.

Создание строк:

Их можно создавать разными способами, например:

String s1 = "Hello"; // Создание строки через литерал - строка помещается в пул строк
String s2 = new String("Hello"); // Явное создание нового объекта строки - не использует пул строк

Работа со строками:

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

String str = "Java";
String upperStr = str.toUpperCase(); // Преобразует все символы в верхний регистр
boolean startsWithJ = str.startsWith("J"); // Проверяет, начинается ли строка с символа "J"
String combined = str + " Programming"; // Конкатенация строк

Важно помнить:

✅Использование оператора + для многократной конкатенации строк в цикле может быть неэффективным по производительности из-за создания множества временных объектов String. В таких случаях рекомендуется использовать StringBuilder или StringBuffer.
✅Для сравнения строк по содержимому следует использовать метод equals(), а не оператор ==, который сравнивает ссылки на объекты.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что знаешь о методе clone ?
Спросят с вероятностью 12%

Метод clone() используется для создания копии существующего объекта. Он определён в классе Object и может быть переопределён в пользовательских классах для реализации более глубокого или специфического клонирования, в отличие от поверхностного копирования, предоставляемого реализацией по умолчанию.

Особенности метода:

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

✅Класс должен реализовать интерфейс Cloneable: Чтобы объект класса мог быть клонирован с использованием метода clone(), этот класс должен реализовать интерфейс Cloneable. Интерфейс Cloneable не содержит методов и служит маркером, указывающим, что класс разрешает клонирование. Если объект класса, который не реализует Cloneable, пытается использовать метод clone(), будет выброшено исключение CloneNotSupportedException.

✅Переопределение методахностное ко Для реализации глубокого клонирования или специфической логики клонирования метод clone() может быть переопределён. При переопределении рекомендуется вызывать super.clone() для получения объекта, а затем выполнять копирование внутренних объектов или выполнение дополнительных действий.

Пример:

public class Sheep implements Cloneable {
    private String name;

    public Sheep(String name) {
        this.name = name;
    }

    // Геттеры и сеттеры

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class CloneExample {
    public static void main(String[] args) {
        Sheep original = new Sheep("Dolly");
        Sheep copy = null;
        try {
            copy = (Sheep) original.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        System.out.println(original != copy); // Выведет true, так как это разные объекты
        System.out.println(original.getClass() == copy.getClass()); // Выведет true, так как тип один и тот же
        System.out.println(original.equals(copy)); // Результат зависит от реализации метода equals()
    }
}

Метод clone() позволяет создавать копии объектов, но его использование требует осторожности, особенно при работе с объектами, содержащими ссылки на другие объекты (глубокое и поверхностное клонирование). Необходимость реализации интерфейса Cloneable и обработки исключения CloneNotSupportedException делает использование метода clone() менее удобным по сравнению с другими подходами к клонированию, такими как конструкторы копирования или фабричные методы.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

В чём отличие Supplier'а от Consumer'а ?
Спросят с вероятностью 12%

Supplier и Consumer являются функциональными интерфейсами, введёнными в Java 8 в рамках Stream API и пакета java.util.function. Они оба используются в лямбда-выражениях, методах ссылках и потоках данных, но служат разным целям и имеют противоположные действия.

Supplier

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

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

Supplier<String> stringSupplier = () -> "Hello, World!";
System.out.println(stringSupplier.get()); // Выводит "Hello, World!"

Consumer

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

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

Consumer<String> stringConsumer = s -> System.out.println(s);
stringConsumer.accept("Hello, World!"); // Выводит "Hello, World!"

Основное отличие между Supplier и Consumer заключается в их назначении и способе работы:

✅Supplier используется для получения или генерации данных без каких-либо входных параметров. Он «поставляет» данные.
✅Consumer используется для выполнения операций над данными, которые он принимает в качестве параметров, и не возвращает никакого результата. Он «потребляет» данные.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

В чём идея полиморфизма ?
Спросят с вероятностью 12%

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

Виды:

1️⃣Статический (компиляционный) полиморфизм: Реализуется с помощью перегрузки методов в одном классе, когда несколько методов имеют одинаковое имя, но различаются по количеству и/или типу параметров.

2️⃣Динамический (выполнения) полиморфизм: Достигается благодаря переопределению методов. В этом случае, какой именно метод будет вызван, определяется не на этапе компиляции, а во время выполнения программы. Это связано с использованием наследования и возможностью ссылки суперкласса указывать на объект подкласса.

Пример:

class Animal {
    void sound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Woof");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("Meow");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        
        myAnimal.sound();
        myDog.sound();
        myCat.sound();
    }
}

В этом примере, метод sound() переопределен в классах Dog и Cat. Во время выполнения, JVM определяет, какой именно метод sound() вызвать, основываясь на фактическом объекте, на который ссылается переменная. Это демонстрирует динамический полиморфизм, позволяя использовать один и тот же код (myAnimal.sound()) для вызова методов у объектов разных классов.

Значение полиморфизма

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1715 вопроса на Java разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых