⌨️ API (Application Programming Interface, интерфейс программирования приложения) — программный интерфейс, то есть описание способов взаимодействия одной компьютерной программы с другими. (В противоположность пользовательскому интерфейсу, используемому для взаимодействия конечного пользователя с программой.) Обычно входит в описание какого-либо интернет-протокола, программного каркаса (фреймворка) или стандарта вызовов функций операционной системы. Часто реализуется отдельной программной библиотекой или сервисом операционной системы. Используется программистами при написании всевозможных приложений.

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

Если программу (модуль, библиотеку) рассматривать как чёрный ящик, то API — это набор «ручек», которые доступны пользователю данного ящика и которые он может вертеть и переключать.

Примеры API: Windows API, DirectX (DirectDraw/Direct3D), Vulkan.

⌨️ Как сравнивать элементы enum: equals() или == ?

Можно и так и так. Если посмотреть реализацию equals() в Enum, то мы там увидим сравнение через ==

public final boolean equals(Object other) {
    return this==other;
}

При сравнении через ==, мы застрахуем себя от NullPointerException.

⌨️ Чем абстрактный класс отличается от интерфейса? В каких случаях следует использовать абстрактный класс, а в каких интерфейс?

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

1️⃣ Абстрактный класс (Abstract Class):

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

abstract class Animal {
    String name;

    abstract void makeSound();

    void eat() {
        System.out.println(name + " is eating.");
    }
}

2️⃣ Интерфейс (Interface):

👉 Содержит только абстрактные методы (в Java 8 и выше может содержать методы с реализацией, помеченные ключевым словом default).
👉 Не может иметь переменных экземпляра, кроме переменных, объявленных как static final.
👉 Не содержит конструкторов.
👉 Поддерживает множественное наследование: класс может реализовывать несколько интерфейсов.

interface Animal {
    void makeSound();
    void eat();
}

Когда использовать:

👉 Используйте абстрактные классы, когда у вас есть общая реализация для нескольких классов и вы хотите предоставить базовый функционал.

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

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

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

import java.lang.annotation.*;

// Создание аннотации
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MethodInfo {
    String author() default "unknown";
    String date();
    int revision() default 1;
    String comments();
}

public class Example {
    // Использование аннотации
    @MethodInfo(author = "John Doe", date = "2022-08-15", comments = "Example method")
    public void performAction() {
        // Реализация метода
    }
}

В этом примере создается аннотация MethodInfo с параметрами author, date, revision и comments. Затем аннотация применяется к методу performAction. Таким образом, аннотации могут использоваться для предоставления дополнительной информации о вашем коде, что может быть полезно при разработке, тестировании и поддержке проекта.

⌨️ Фишка: Создание итератора для пользовательского класса.

Код:

import java.util.Iterator;

public class CustomClass implements Iterable<String> {
    private String[] elements;

    public CustomClass(String[] elements) {
        this.elements = elements;
    }

    @Override
    public Iterator<String> iterator() {
        return new CustomIterator();
    }

    private class CustomIterator implements Iterator<String> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < elements.length;
        }

        @Override
        public String next() {
            if (this.hasNext()) {
                return elements[index++];
            } else {
                throw new NoSuchElementException();
            }
        }
    }

    public static void main(String[] args) {
        String[] arr = {"one", "two", "three"};
        CustomClass customClass = new CustomClass(arr);
        
        for (String element : customClass) {
            System.out.println(element);
        }
    }
}

💁‍♂️ Этот код позволяет создать итератор для пользовательского класса CustomClass. Итератор позволяет перебирать элементы массива elements и использовать их в цикле for-each.

⌨️ Использование интерфейсов для множественного наследования

// Создание интерфейсов
interface Printable {
    void print();
}

interface Showable {
    void show();
}

// Реализация интерфейсов в классе
class MyClass implements Printable, Showable {
    public void print() {
        System.out.println("Printing...");
    }

    public void show() {
        System.out.println("Showing...");
    }
}

public class Main {
    public static void main(String[] args) {
        // Создание объекта класса MyClass
        MyClass obj = new MyClass();
        obj.print();
        obj.show();
    }
}

🔎 В данном коде используются интерфейсы для реализации множественного наследования. Класс MyClass реализует два интерфейса Printable и Showable, и поэтому класс может использовать методы, определенные в обоих интерфейсах. Это позволяет создавать гибкие и модульные программы, используя механизм интерфейсов в Java.

⌨️ Использование StringBuilder для эффективной конкатенации строк:

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10; i++) {
            sb.append("строка ").append(i).append("\n");
        }
        String result = sb.toString();
        System.out.println(result);
    }
}

📌 В этом примере используется StringBuilder для объединения 10 строк "строка i" в одну строку. Это более эффективно, чем использование оператора "+" или String.concat(), особенно при большом количестве операций конкатенации строк.

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

⌨️ Параллельное выполнение задач с использованием ExecutorService

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

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        // Создание пула потоков
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // Подача задач на выполнение
        for (int i = 0; i < 10; i++) {
            executor.execute(new Task(i));
        }

        // Остановка пула потоков после выполнения задач
        executor.shutdown();
    }

    static class Task implements Runnable {
        private int taskId;

        public Task(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            System.out.println("Выполнение задачи " + taskId + " в потоке " +
                Thread.currentThread().getName());
        }
    }
}

🧑‍💻Этот код создает пул из 5 потоков и подает на выполнение 10 задач. Каждая задача выводит свой идентификатор и имя потока, в котором она выполняется. После выполнения всех задач пул потоков останавливается.

⌨️ Использование интерфейса Callable вместе с классом Future для выполнения асинхронных задач и получения их результата:

ExecutorService executor = null;
try {
    executor = Executors.newFixedThreadPool(1);
    Future<Integer> futureResult = executor.submit(() -> {
        // Выполнение сложной вычислительной задачи
        int result = 0;
        for (int i = 0; i < 100; i++) {
            result += i;
            Thread.sleep(100);
        }
        return result;
    });

    // Другие действия, выполняемые параллельно

    // Ожидание завершения асинхронной задачи и получение результата
    Integer result = futureResult.get();
    System.out.println("Результат: " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
} finally {
    if (executor != null) executor.shutdown();
}

➡️В данном примере создается пул потоков размером 1, затем создается асинхронная задача с использованием интерфейса Callable, который возвращает результат типа Integer. Задача выполняет сложное вычисление с задержкой в 100 миллисекунд каждую итерацию.

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

Метод get() вызывается для ожидания завершения задачи и получения результата. Если задача еще не завершилась, вызов этого метода блокируется. Возможны исключения, такие как InterruptedException или ExecutionException, которые необходимо обработать.

💁‍♂️ Затем поток пул завершается вызовом shutdown().

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

📌 Вот пример метода для глубокого копирования:

import java.io.*;

public class DeepCopyExample {
    public static void main(String[] args) {
        Person person = new Person("John", 30);
        Person deepCopy = deepCopy(person);
        
        System.out.println("Original: " + person.getName() + ", " + person.getAge());
        System.out.println("Deep copy: " + deepCopy.getName() + ", " + deepCopy.getAge());
    }
    
    public static <T extends Serializable> T deepCopy(T object) {
        try {
            ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteOutputStream);
            objectOutputStream.writeObject(object);
            
            ByteArrayInputStream byteInputStream = new ByteArrayInputStream(byteOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteInputStream);
            T copy = (T) objectInputStream.readObject();
            
            return copy;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

class Person implements Serializable {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}

✅ В этом примере мы создаем класс Person, который реализует интерфейс Serializable, чтобы объекты этого класса можно было сериализовать и десериализовать. Затем мы создаем метод deepCopy, который принимает объект и возвращает его глубокую копию.

Мы используем ByteArrayOutputStream и ObjectOutputStream, чтобы записать объект в байтовый массив, а затем ByteArrayInputStream и ObjectInputStream, чтобы прочитать копию объекта из массива.

В методе main мы создаем объект Person, затем создаем его глубокую копию с помощью метода deepCopy и выводим на экран значения оригинального и скопированного объекта.

⌨️ Использования анонимных классов:

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

public class Main {
    interface Greeting {
        void sayHello();
    }

    public static void main(String[] args) {
        Greeting greeting = new Greeting() {  // объявление и создание анонимного класса
            @Override
            public void sayHello() {
                System.out.println("Привет, мир!");
            }
        };

        greeting.sayHello();  // вызов метода sayHello у анонимного класса
    }
} 

✅В данном примере мы определили интерфейс Greeting, содержащий метод sayHello(). Затем, в методе main(), мы создали анонимный класс, реализующий интерфейс Greeting и переопределивший метод sayHello(). Затем мы вызываем метод sayHello() у объекта анонимного класса.

📝Таким образом, анонимные классы предоставляют удобный способ создания и использования классов "на лету", что может быть полезно, когда требуется определить классы, которые будут использоваться только в одном месте программы.

⌨️ Работа с коллекциями элементарных типов данных благодаря классам-оболочкам (Wrapper Classes)

import java.util.ArrayList;
import java.util.List;

public class WrapperExample {
    public static void main(String[] args) {
        // Создание списка оберток для целых чисел
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // Использование методов класса-оболочки
        int sum = 0;
        for (int i = 0; i < numbers.size(); i++) {
            sum += numbers.get(i);
        }
        System.out.println("Сумма чисел: " + sum);
    }
}



✅ В этом примере создается список оберток numbers для целых чисел типа Integer. Затем мы добавляем в список несколько элементов и используем метод get() для получения элементов из списка. Значения оберток автоматически анбоксируются в примитивные типы данных int, и мы можем выполнять с ними операции, например, суммирование.
Использование классов-оболочек позволяет работать с коллекциями элементарных типов данных и обеспечивает удобство и безопасность при работе с ними.

⌨️ Обработка исключений с помощью Try-With-Resources.

Try-With-Resources - это новая конструкция языка, введенная в Java 7, которая облегчает работу с ресурсами такими как файлы или сокеты и сокращает количество кода, необходимого для обработки исключений.

Вот пример использования Try-With-Resources для чтения содержимого файла:

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

💻В этом примере мы открываем BufferedReader внутри блока try с помощью конструктора FileReader. Затем мы можем безопасно читать файл внутри этого блока без необходимости явно закрывать ресурс.

После завершения блока try автоматически вызывается метод close() объекта reader, который закрывает файл и освобождает связанные с ним ресурсы. Если возникнет исключение в блоке try, его можно будет обработать в блоке catch после завершения работы с ресурсом.