Java | Фишки и трюки

⌨️ Использование методов 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 методы в интерфейсах позволяют определять вспомогательные методы, которые могут быть вызваны без объекта интерфейса, предоставляя большую гибкость и удобство в использовании.

⌨️ Использование аннотаций (Annotations) для улучшения читаемости и обработки кода:

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {
}

Данная аннотация @LogExecutionTime позволяет отмечать методы в Java классах, чтобы измерять время выполнения этих методов. Для использования аннотации, следует применить ее к методу, который необходимо измерить:

public class ExampleClass {

    @LogExecutionTime
    public void performTimeConsumingTask() {
        // Выполняем длительную задачу для измерения времени
    }
}

Теперь, можно создать аспект (Aspect) с использованием библиотеки AspectJ или Spring AOP для обработки методов, помеченных аннотацией @LogExecutionTime, и измерить время их выполнения:

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint;

@Aspect
public class LogExecutionTimeAspect {

    @Pointcut("@annotation(LogExecutionTime)")
    public void logExecutionTime() {
    }

    @Around("logExecutionTime()")
    public Object logTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long executionTime = System.currentTimeMillis() - startTime;
        System.out.println(joinPoint.getSignature() + " выполнен за " + executionTime + "ms");
        return proceed;
    }
}

Aspect LogExecutionTimeAspect создает возможность измерить время выполнения методов, помеченных аннотацией @LogExecutionTime, путем перехвата вызова метода и расчета времени выполнения. Это может быть очень полезным для оптимизации производительности и анализа кода.

⌨️ Использование методов проверки исключений для улучшения обработки исключений в коде. Java позволяет определить собственные исключения и проверять их с использованием методов проверки исключений. Это позволяет улучшить структуру и понятность кода, а также обрабатывать исключения более эффективно. Ниже приведен пример кода, демонстрирующий использование методов проверки исключений:

public class ExampleException extends Exception {
    public ExampleException(String message) {
        super(message);
    }
}

public class ExampleClass {
    public void doSomething(int value) throws ExampleException {
        if (value < 0) {
            throw new ExampleException("Value can't be negative");
        }
        // выполнение кода
    }
}

public class Main {
    public static void main(String[] args) {
        ExampleClass example = new ExampleClass();
        try {
            example.doSomething(-1);
        } catch (ExampleException e) {
            System.out.println(e.getMessage());
        }
    }
}

В данном примере у нас есть класс ExampleException, который расширяет класс Exception и используется для определения собственного исключения. В классе ExampleClass мы определяем метод doSomething, который проверяет значение параметра value и выбрасывает исключение ExampleException, если значение отрицательное. В классе Main мы создаем объект ExampleClass и вызываем метод doSomething с отрицательным значением, а затем обрабатываем выброшенное исключение. Использование методов проверки исключений позволяет нам явно указывать, какие исключения могут возникнуть в методе, и позволяет более точно управлять обработкой исключений в коде. Это становится особенно полезным в больших проектах, где нужно более точно контролировать и обрабатывать исключения.

⌨️ Использование логгирования с помощью фреймворка SLF4J в сочетании с Logback в качестве реализации. SLF4J (Simple Logging Facade for Java) обеспечивает интерфейс для логгирования, который является общим для различных реализаций логгеров (например, Logback или Log4j). Это позволяет вам изменить реализацию логгера без изменения кода. 1️⃣ Для начала установите зависимости в вашем файле pom.xml:

<dependencies>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.32</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.3.0-alpha5</version>
    </dependency>
</dependencies>

2️⃣ Затем создайте класс с помощью следующего кода, чтобы протестировать логгирование:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExampleLogger {
    private static final Logger logger = LoggerFactory.getLogger(ExampleLogger.class);

    public static void main(String[] args) {
        logger.debug("This is a debug message");
        logger.info("This is an info message");
        logger.warn("This is a warning message");
        logger.error("This is an error message");
    }
}

В этом примере мы создаем статическое поле logger с помощью LoggerFactory и инициализируем его с классом, в котором он используется (ExampleLogger). Затем мы можем использовать этот logger, чтобы записывать различные уровни сообщений (debug, info, warn, error). 3️⃣ Чтобы настроить вывод логов, создайте файл logback.xml в ресурсах вашего проекта со следующим содержимым:

<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

Эта конфигурация использует ConsoleAppender для вывода логов на консоль. Он также определяет формат вывода логов с использованием pattern. Уровень логов задан как INFO, что означает, что будут выводиться все сообщения уровней INFO, WARN и ERROR. Теперь при запуске класса ExampleLogger вы увидите сообщения различных уровней вывода в соответствии с вашей конфигурацией логгера.

Учитесь тому, что пригодится в работе и в жизни — бесплатно, с Яндекс Практикумом. Тут на одной странице собраны курсы, которые помогут попробовать себя в разных IT-профессиях и получить практический навык. 17 разных курсов по программированию, аналитике данных, маркетингу, менеджменту и дизайну. Прохождение занимает от 2 до 20 часов. Например, можно разобраться в основах Java, научиться искать и нанимать тестировщиков, задизайнить плакат для фестиваля еды и ещё много чего. Выбирайте курс по душе и пробуйте себя в разных профессиях!

⌨️ Использование аннотации @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 или Kotlin? Каждую пятницу в YABED два программиста делают дайджест самого главного по теме JVM без воды и ненужного спама. Присоединяйся к YABED и успей поучаствовать в розыгрыше двух лицензий JetBrains - подробности в последнем посте!

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

public class VolatileExample {
private volatile boolean flag = false;

public void setFlag(boolean value) {
    flag = value;
}

public boolean getFlag() {
    return flag;
}
}

Когда переменная flag объявлена с модификатором volatile, можно гарантировать, что любые изменения значения flag будут немедленно видны всем потокам, которые обращаются к методу getFlag(). Таким образом, нет необходимости использовать синхронизацию для чтения и записи значения flag в разных потоках. Использование модификатора volatile может помочь предотвратить ошибки синхронизации и упростить код в многопоточных приложениях. Однако необходимо быть осторожным при использовании этого модификатора, так как он не гарантирует атомарность операций и не является заменой для других механизмов синхронизации, таких как блокировки или атомарные классы.

🚀 Добро пожаловать в Telegram-канал JavaSimply Если ты увлеченный программист или просто интересуешься миром программирования на Java, то этот канал для тебя! Мы предлагаем: - Ежедневные обновления о последних трендах в мире Java - Полезные советы и трюки для улучшения навыков программирования на Java - Расширение знаний о новых возможностях Java и применении лучших практик Присоединяйся к нам, чтобы быть в курсе всех современных технологий и идей Java! 🌐 Просто перейди по ссылке и жми "Подписаться"! 👇

⌨️ Использование класса java.util.Timer для выполнения задач по расписанию. Для этого необходимо импортировать соответствующие пакеты:

import java.util.Timer;
import java.util.TimerTask;

Затем можно создать класс, который наследует TimerTask и реализует метод run() для определения задачи:

class ScheduledTask extends TimerTask {
    public void run() {
        // выполняем задачу
        System.out.println("Задача выполняется!");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Timer timer = new Timer();
        
        // создаем экземпляр задачи
        ScheduledTask task = new ScheduledTask();
        
        // задержка перед выполнением задачи (в миллисекундах)
        long delay = 1000;

        // интервал между выполнениями задачи (в миллисекундах)
        long period = 2000;
        
        // запускаем задачу по расписанию
        timer.schedule(task, delay, period);
    }
}

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

⌨️ Использование класса 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() для получения часов, минут и секунд в полученной разнице времени. Наконец, мы выводим результаты на экран. Эта фишка полезна для рассчета временных интервалов, например, для измерения времени выполнения определенной операции или анализа времени работы программы.

🔤 Найден полезный канал по Frontend - разработке! Его ведёт Frontend разработчик с опытом больше 5 лет! 👩‍💻 В канале вы найдете: ▫️ полезные статьи про 👩‍💻 👩‍💻 👩‍💻 👩‍💻 👩‍💻 ▫️ новости из мира Frontend ▫️ ежедневно в канале выходят вопросы и задачи с реальных собеседований с подробными объяснениями Автор этого канала может ответить на любой ваш вопрос про Frontend. В этом канале реально много полезного.

⌨️ Код для реализации уникального идентификатора (UUID):

import java.util.UUID;

public class UniqueIdGenerator {

public static void main(String[] args) {
    // Генерация случайного уникального идентификатора
    UUID uuid = UUID.randomUUID();
    System.out.println("Уникальный идентификатор: " + uuid);
    
    // Преобразование уникального идентификатора в строку без тире
    String uuidString = uuid.toString().replace("-", "");
    System.out.println("Уникальный идентификатор без тире: " + uuidString);
}

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

Присоединяйтесь к нашему бесплатному курсу и начните увлекательное путешествие в мир Java! Изучайте основы, создавайте программы, разбирайтесь с методами и анализируйте ошибки в коде. Практика, упражнения и проверочные тесты помогут вам освоить навыки программирования. 🎓 Чему вы научитесь: — Создавать программы с использованием основных конструкций языка.  — Разделять код на методы для повторного использования.  — Анализировать ошибки в коде с использованием отладочной печати. 💼 Включено в курс: 29 уроков (видео и/или текст), 35 упражнений в тренажере, 95 проверочных тестов + дополнительные материалы. Вы с нами?😉

⌨️ Использование Stream API для работы с коллекциями данных.

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");

        // Фильтрация элементов, начинающихся с буквы "a" и преобразование в верхний регистр
        fruits.stream()
                .filter(fruit -> fruit.startsWith("a"))
                .map(String::toUpperCase)
                .forEach(System.out::println);
        // Выведет "APPLE"
    }
}

📝 В этом примере мы использовали Stream API для фильтрации элементов коллекции, начинающихся с буквы "a", и преобразования их в верхний регистр, а затем вывели результат в консоль. Stream API предоставляет мощный и удобный способ работы с коллекциями данных в Java, позволяя выполнять различные операции, такие как фильтрация, отображение, сортировка, агрегация и многое другое.

⌨️ Использование CompletableFuture для асинхронных операций. Этот класс предоставляет удобный способ работы с асинхронными задачами, такими как параллельные вычисления, обработка событий и т. д.

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // Создание CompletableFuture объекта
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");

        // Добавление операций после выполнения асинхронной задачи
        CompletableFuture<String> result = future.thenApplyAsync(str -> str + " World")
                .thenApply(str -> str + "!");

        try {
            // Ожидание результата
            String message = result.get();
            System.out.println(message);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

🧑‍💻В данном примере мы создаем CompletableFuture объект future, который возвращает строку "Hello". Затем мы добавляем операции thenApplyAsync и thenApply, которые обрабатывают результат асинхронной задачи и добавляют к нему слова "World" и "!", соответственно. 🔎 После этого мы ожидаем результат, вызывая метод get(). Если выполнение асинхронной задачи еще не завершено, данный метод будет блокироваться до получения результата. 💁‍♂️ Таким образом, использование CompletableFuture позволяет нам эффективно работать с асинхронными задачами и упрощает обработку результатов. Это может быть особенно полезно в многопоточном или параллельном программировании.

Статья, которая 100% будет полезна Java разработчикам, планирующим перейти на виртуальные потоки! Говорим о важной фиче — виртуальных потоках Java 21. Именно благодаря ей синхронный код становится эффективным! Как это работает, какие есть подводные камни, и из-за чего ваше приложение может зависнуть: рассказали подробно и с наглядными примерами в материале. Познакомиться с ним можно по ссылке прямо сейчас