⌨️ В какой момент происходит статическая инициализация класса?

В Java статическая инициализация класса происходит во время загрузки класса в JVM (Java Virtual Machine), которая происходит перед созданием объектов этого класса или вызовом статических методов или статических полей этого класса.

Статическая инициализация выполняется при помощи статических блоков кода или статических переменных класса.

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

public class MyClass {
    static {
        // Код статической инициализации
        System.out.println("Статическая инициализация MyClass");
    }

    public MyClass() {
        System.out.println("Конструктор MyClass");
    }
}

public class Start {
    public static void main(String[] args) {
        System.out.println("start");
        new MyClass();
        System.out.println("stop");
    }
}

Вывод в консоль:

start
Статическая инициализация MyClass
Конструктор MyClass
stop

☕️Использование библиотеки Mockito

Mockito - это фреймворк для создания и использования динамических мок-объектов (mock objects) в юнит-тестах Java. Он позволяет заменить зависимости вашего класса на мок-объекты, что позволяет вам изолировать код и тестировать его отдельно.

Mockito предоставляет множество методов для создания и использования мок-объектов. Некоторые из наиболее часто используемых методов:

1. mock() - создает мок-объект класса или интерфейса.

List<String> mockedList = Mockito.mock(List.class);

2. when() - определяет поведение мок-объекта при вызове определенного метода.

Mockito.when(mockedList.size()).thenReturn(10);

3. verify() - проверяет, был ли вызван определенный метод мок-объекта.

Mockito.verify(mockedList).add("test");

4. any() - используется для указания любого аргумента при вызове метода.

Mockito.when(mockedList.get(Mockito.anyInt())).thenReturn("element");

5. spy() - создает мок-объект, который делегирует вызовы реальным методам переданного объекта.

List<String> list = new ArrayList<>();
List<String> spyList = Mockito.spy(list);

6. doReturn() - используется для указания возвращаемого значения метода мок-объекта.

Mockito.doReturn("element").when(mockedList).get(0);

🔥Mockito является мощным инструментом для написания эффективных и надежных юнит-тестов в Java. Он помогает программистам создавать изолированные тесты и проверять поведение кода в контролируемой среде.

☕️Использование CountDownLatch

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

Пример кода:

import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int count = 3;
        CountDownLatch latch = new CountDownLatch(count);

        // Потоки, которые будут уменьшать счетчик
        new Thread(new Worker(latch)).start();
        new Thread(new Worker(latch)).start();
        new Thread(new Worker(latch)).start();

        // Ожидание завершения всех потоков
        latch.await();
        System.out.println("Все потоки завершили работу");
    }
}

class Worker implements Runnable {
    private CountDownLatch latch;

    Worker(CountDownLatch latch) {
        this.latch = latch;
    }

    public void run() {
        // Имитация выполнения работы
        try {
            Thread.sleep((long) (Math.random() * 1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Поток завершил работу");
        latch.countDown(); // Уменьшение счетчика
    }
}

📣В этом примере создается объект CountDownLatch с начальным значением 3, и три потока уменьшают его значение перед завершением своей работы. Главный поток ожидает, пока значение счетчика не достигнет 0, после чего выводится сообщение о завершении всех потоков.

☕️Использование метода computeIfAbsent() из интерфейса Map.

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

Пример кода с объяснением:

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> wordLengths = new HashMap<>();
        String word = "apple";

        // Использование computeIfAbsent для вычисления и вставки значения в карту
        wordLengths.computeIfAbsent(word, String::length);

        // Вывод длины слова "apple", которая была вычислена и вставлена в карту
        System.out.println("Длина слова apple: " + wordLengths.get(word));
    }
}

🔒В этом примере мы используем метод computeIfAbsent() для мапы wordLengths, чтобы вычислить и вставить длину слова "apple" в Map, если она отсутствует. Если значение уже присутствует, метод возвращает текущее значение.

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

🔔Использование JShell для быстрой проверки и экспериментов с кодом.

Пример кода:

$ jshell
|  Welcome to JShell -- Version 11.0.12
|  For an introduction type: /help intro

jshell> int result = 10 + 20;
result ==> 30

jshell> String message = "Hello, World!";
message ==> "Hello, World!"

✔️JShell позволяет быстро проводить эксперименты, проверять короткие фрагменты кода, тестировать API и проводить быстрые исследования. Он предоставляет удобную среду для интерактивной работы с Java кодом без необходимости создания и компиляции отдельных файлов.

⌨️ "Фабричный метод" (Factory Method).

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

Пример реализации:

1️⃣Создадим интерфейс продукта, который будет производиться фабричным методом.

interface Product {
    void use();
}

2️⃣Создадим реализации продуктов.

class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

3️⃣Создадим абстрактный класс с фабричным методом.

abstract class Creator {
    public abstract Product factoryMethod();

    public void anOperation() {
        Product product = factoryMethod();
        product.use();
    }
}

4️⃣Реализуем конкретные создатели для каждого типа продукта.

class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

5️⃣Демонстрация использования.

public class FactoryMethodDemo {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        creatorA.anOperation();  // Использует ConcreteProductA

        Creator creatorB = new ConcreteCreatorB();
        creatorB.anOperation();  // Использует ConcreteProductB
    }
}

В этом примере FactoryMethodDemo класс демонстрирует использование фабричного метода. Creator класс содержит фабричный метод factoryMethod(), который переопределяется в подклассах ConcreteCreatorA и ConcreteCreatorB для создания конкретных продуктов ConcreteProductA и ConcreteProductB соответственно.

⌨️ Использование java.util.stream.Collectors для обработки коллекций

Код:

import java.util.List;
import java.util.stream.Collectors;

public class StreamCollectorsExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Примеры использования Collectors
        // Преобразование элементов коллекции в строку
        String numbersAsString = numbers.stream()
                                        .map(Object::toString)
                                        .collect(Collectors.joining(", "));
        System.out.println("Числа в виде строки: " + numbersAsString);
        
        // Получение среднего значения всех элементов коллекции
        double average = numbers.stream()
                                 .collect(Collectors.averagingInt(Integer::intValue));
        System.out.println("Среднее значение: " + average);
        
        // Фильтрация элементов и сборка их в новую коллекцию
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(num -> num % 2 == 0)
                                           .collect(Collectors.toList());
        System.out.println("Четные числа: " + evenNumbers);
        
        // Группировка элементов по условию
        System.out.println("Числа по остатку от деления на 3: " + numbers.stream()
                                                                      .collect(Collectors.groupingBy(num -> num % 3)));
    }
}

⚙️Этот пример демонстрирует использование класса Collectors из пакета java.util.stream для более эффективной обработки коллекций в Java. Методы класса Collectors предоставляют различные операции для сбора (collecting) элементов из потока данных в различные структуры данных или для выполнения агрегатных операций над элементами потока.

⌨️ Использование методов default и static в интерфейсах. Эти методы позволяют добавлять конкретные реализации в интерфейсы, что делает их более гибкими и позволяет избежать некоторых проблем множественного наследования.

Пример с default методом в интерфейсе:

interface Greeter {
    void greet();

    // Default метод в интерфейсе
    default void greetWithExclamation() {
        System.out.println("Привет, мир!");
    }
}

class EnglishGreeter implements Greeter {
    public void greet() {
        System.out.println("Hello, World!");
    }
}

class RussianGreeter implements Greeter {
    public void greet() {
        System.out.println("Привет, мир!");
    }

    // Переопределение default метода 
    @Override
    public void greetWithExclamation() {
        System.out.println("Привет, мир!!!");
    }
}

public class InterfaceDefaultMethodExample {
    public static void main(String[] args) {
        Greeter englishGreeter = new EnglishGreeter();
        englishGreeter.greet(); // Вызовет: Hello, World!
        englishGreeter.greetWithExclamation(); // Вызовет: Привет, мир!

        Greeter russianGreeter = new RussianGreeter();
        russianGreeter.greet(); // Вызовет: Привет, мир!
        russianGreeter.greetWithExclamation(); // Вызовет: Привет, мир!!!
    }
}

Пример со static методом в интерфейсе:

interface Calculator {
    static int add(int a, int b) {
        return a + b;
    }

    static int subtract(int a, int b) {
        return a - b;
    }
}

public class InterfaceStaticMethodExample {
    public static void main(String[] args) {
        // Нет необходимости создавать экземпляр интерфейса
        int sum = Calculator.add(5, 3);  // 8
        int difference = Calculator.subtract(5, 3);  // 2
        System.out.println("Сумма: " + sum + ", Разница: " + difference);
    }
}

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

⌨️ Использование аннотации @FunctionalInterface для определения функциональных интерфейсов.

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

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

Ниже приведен пример кода, демонстрирующий использование аннотации @FunctionalInterface:

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

public class FunctionalInterfaceExample {
    public static void main(String[] args) {
        Calculator addition = (a, b) -> a + b;
        System.out.println("Результат сложения: " + addition.calculate(5, 3));

        Calculator subtraction = (a, b) -> a - b;
        System.out.println("Результат вычитания: " + subtraction.calculate(5, 3));
    }
}

В этом примере мы создаем функциональный интерфейс Calculator, содержащий метод calculate. Затем мы создаем экземпляры интерфейса, используя лямбда-выражения, и вызываем метод calculate для выполнения операций сложения и вычитания.

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

⌨️ Использование класса java.time.Duration для рассчета разницы во времени между двумя моментами.

Код для расчета разницы во времени:

import java.time.Duration;
import java.time.LocalDateTime;

public class TimeDifferenceCalculator {
    public static void main(String[] args) {
        LocalDateTime startTime = LocalDateTime.of(2022, 1, 1, 10, 0, 0);
        LocalDateTime endTime = LocalDateTime.of(2022, 1, 1, 12, 30, 0);

        Duration duration = Duration.between(startTime, endTime);

        long hours = duration.toHours();
        long minutes = duration.toMinutes() % 60;
        long seconds = duration.getSeconds() % 60;

        System.out.println("Time difference: " + hours + " hours, " + minutes + " minutes, " + seconds + " seconds.");
    }
}

В этом примере мы создаем два объекта LocalDateTime - startTime и endTime, представляющие начальное и конечное время соответственно. Затем мы используем метод Duration.between() для расчета разницы во времени между startTime и endTime.

Далее, мы используем методы toHours(), toMinutes() и getSeconds() для получения часов, минут и секунд в полученной разнице времени. Наконец, мы выводим результаты на экран.

Эта фишка полезна для рассчета временных интервалов, например, для измерения времени выполнения определенной операции или анализа времени работы программы.

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

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

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() у объекта анонимного класса.

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

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

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

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 и выводим на экран значения оригинального и скопированного объекта.

⌨️ Параллельное выполнение задач с использованием 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 задач. Каждая задача выводит свой идентификатор и имя потока, в котором она выполняется. После выполнения всех задач пул потоков останавливается.

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

Код:

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.