Автор статьи: Сергей Прощаев @sproshchaev
Руководитель направления Java‑разработки в FinTech

Kotlin, современный язык программирования от JetBrains, уже давно зарекомендовал себя не только в Android‑разработке, но и как мощная альтернатива Java для бэкенд‑разработки. Kotlin полностью совместим с Java, работает на JVM и предлагает более лаконичный, безопасный и выразительный синтаксис.

Kotlin — это синтез лучших практик из Java, Scala, C#, Groovy, Swift и других языков, с акцентом на:

• Совместимость с Java,

• Null‑безопасность,

• Поддержку функционального и объектно‑ориентированного программирования,

• Лаконичность и читаемость кода,

• Безопасность и производительность.

В этой статье мы рассмотрим, на примерах — почему Kotlin становится все более привлекательным выбором для бэкенд‑разработчиков.

Почему Kotlin лучше для бэкенда?

1. Читаемость кода: Kotlin позволяет писать значительно меньше шаблонного кода. Функции, такие как data classes, автоматически генерируют getters, setters, equals, hashCode и toString. Выражения when, расширения функций и лямбды делают код более читаемым и логичным.

2. Безопасность: безопасность от NullPointerException (Null‑safety) встроена в систему типов, что снижает количество ошибок на этапе компиляции. Система типов Kotlin различает nullable и non‑nullable типы, что практически исключает NullPointerException. Иммутабельность по умолчанию (val вместо var) способствует написанию более предсказуемого и потокобезопасного кода.

3. Интероперабельность с Java: Kotlin работает на той же JVM, что и Java, и полностью совместим с существующим Java‑кодом. Это означает, что вы можете постепенно переносить проект, используя существующие библиотеки и фреймворки (Spring, Hibernate и т. д.) без переписывания всего с нуля.

4. Современные возможности языка: Kotlin предлагает такие функции, как корутины (coroutines) для асинхронного программирования, делегированные свойства, объекты‑компаньоны и многое другое, что упрощает разработку.

5. Поддержка сообщества и инструментов: JetBrains активно развивает Kotlin, обеспечивая отличную поддержку в IDE (IntelliJ IDEA). Фреймворки, такие как Ktor и Spring (с официальной поддержкой Kotlin), предоставляют мощные инструменты для бэкенд‑разработки.

Читаемость кода или про то, "как это пишется в Java и как это можно сократить в Kotlin"

Чтобы не погрязнуть в теории — давайте на примерах рассмотрим базовые конструкции и посмотрим как это пишется в Java и как это можно сократить в Kotlin. Давайте остановимся на data classes, when и расширениях функций

Что такое data classes и с чем их едят в Kotlin?

Kotlin позволяет писать значительно меньше шаблонного кода. Например такие конструкции, как data classes, автоматически генерируют: getters, setters, equals, hashCode и toString.

Так в Java при создании простых классов‑контейнеров (например, для хранения данных), приходилось писать много повторяющегося кода. Давайте создадим класс Person с двумя полями: имя и возраст.

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    @Override
    public boolean equals(Object o) { /* много строк */ }
    @Override
    public int hashCode() { /* ещё больше строк */ }
    @Override
    public String toString() { /* и снова... */ }
}

Это пример типичного шаблонного кода — он почти всегда одинаков, но при этом занимает много места и отвлекает от сути. А ведь в нем всего лишь два поля, а что будет с размером класса, если полей будет с десяток или даже два?

В Kotlin для таких случаев есть специальный класс — data class. Он автоматически генерирует все необходимые методы и вот как будет выглядеть выглядеть наш Person:

data class Person(val name: String, val age: Int)

Всего‑лишь одна строчка кода!

Что такое when и чем он лучше switch?

Выражение when в Kotlin — это мощная и гибкая конструкция, которая заменяет собой традиционный switch из Java и даже больше.

В Java оператор switch имеет много ограничений:

switch (day) {
    case 1:
        System.out.println("Понедельник");
        break;
    case 2:
        System.out.println("Вторник");
        break;
    // ... много case'ов
    default:
        System.out.println("Неверный день");
}

В switch нужно не забывать писать break, иначе будет fall‑through, в самой конструкции мы можем использовать только ограниченные типы данных (int, char, enum, String с Java 7+), нельзя использовать сложные условия и не возвращаются значение напрямую.

В Kotlin when — это выражение, а не просто оператор. Это значит, что оно может возвращать значение:

val dayName = when (day) {
    1 -> "Понедельник"
    2 -> "Вторник"
    3 -> "Среда"
    4 -> "Четверг"
    5 -> "Пятница"
    6 -> "Суббота"
    7 -> "Воскресенье"
    else -> "Неверный день"
}

Преимущества when на лицо: нет необходимости в break, поддерживает любые типы и может возвращать значение!

Но это еще не все — если нужны множественные значения в одном case, то можно написать так:

when (x) {
    1, 2, 3 -> println("x равен 1, 2 или 3")
    in 4..10 -> println("x между 4 и 10")
    !in 10..20 -> println("x не в диапазоне 10-20")
    else -> println("другое значение")
}

Мы можем тут же проверять типы:

when (obj) {
    is String -> println("Длина строки: ${obj.length}")
    is Int -> println("Квадрат числа: ${obj * obj}")
    is List<*> -> println("Размер списка: ${obj.size}")
    else -> println("Неизвестный тип")
}

Или добавить условия:

when {
    x > 0 -> println("Положительное число")
    x < 0 -> println("Отрицательное число")
    else -> println("Ноль")
}

И, наконец возвращать значения:

val result = when (grade) {
    "A" -> "Отлично"
    "B" -> "Хорошо"
    "C" -> "Удовлетворительно"
   else -> "Неизвестная оценка"
}

Но это еще не все when можно рассматривать как замену трудно читаемой if‑else цепочки, например так мы напишем на Java:

if (x.isOdd()) {
    println("x нечетное")
} else if (x.isEven()) {
    println("x четное")
} else if (x > 100) {
    println("x больше 100")
} else {
    println("другое условие")
}

Выглядит как «многобукаф» и вообще не понятно, что имелось ввиду. А вот как это можно написать на Kotlin:

when {
    x.isOdd() -> println("x нечетное")
    x.isEven() -> println("x четное")
    x > 100 -> println("x больше 100")
    else -> println("другое условие")
}

Курто! Не правда ли?

А вот как можно обрабатывать значения из enum‑класса:

enum class Status { ACTIVE, INACTIVE, PENDING }

fun handleStatus(status: Status) = when (status) {
    Status.ACTIVE -> "Пользователь активен"
    Status.INACTIVE -> "Пользователь неактивен"
    Status.PENDING -> "Ожидает подтверждения"
}

Расширения функций в Kotlin

Расширения функций (extension functions) — это одна из самых удобных фич Kotlin, которой нет в Java. Расширения функций позволяют добавлять новые функции к существующим классам, не изменяя их исходный код и не используя наследование.

Давайте решим практическую задачку — добавим метод к классу String, который считает количество слов в строке.

В Java нельзя добавлять методы к существующим классам напрямую. Приходится использовать либо утилитарные классы (helper classes), либо наследование (если класс не final) или wrapper классы. Давайте используем первый подход через утилитарный класс:

// Утилитарный класс
public class StringUtils {
    public static int wordCount(String str) {
        if (str == null || str.isEmpty()) {
            return 0;
        }
        return str.trim().split("\\s+").length;
    }
}

// Использование:
public class Main {
    public static void main(String[] args) {
        String text = "Привет мир Kotlin";
        int count = StringUtils.wordCount(text);
        System.out.println("Количество слов: " + count);
    }
}

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

Что предлагает Kotlin для решение этой же задачи через расширение функций:

// Расширение для String
fun String.wordCount(): Int {
    return if (this.isBlank()) 0 else this.trim().split("\\s+".toRegex()).size
}

// Использование:
fun main() {
    val text = "Привет мир Kotlin"
    val count = text.wordCount()
    println("Количество слов: $count")
}

Расширенная функция wordCount() вызывается как обычный метод строки! Интуитивно все понятно и нет необходимости создавать дополнительные классы при этом код стал читабельнее.

Заключение

Надеюсь, что из этих примеров уже стало понятно о тех преимуществах, которые несет в себе Kotlin в бэкенд‑разработке. Kotlin позволяет значительно сократить объем кода, повысить его читаемость и уменьшить количество ошибок благодаря таким возможностям, как null‑безопасность, расширения функций и мощные конструкции типа when. В отличие от Java, Kotlin предлагает более современный и выразительный синтаксис, что делает разработку быстрее и приятнее. Эти особенности делают Kotlin отличным выбором для создания надежных и поддерживаемых серверных приложений.

В заключение приглашаем вас на два открытых урока, где разберем ключевые аспекты Kotlin для бэкенд‑разработки.

12 августа в 20:00 — «Почему все переходят на Kotlin? Секреты успешной миграции с Java для бэкенд‑разработчиков». На занятии рассмотрим, как Kotlin помогает сократить объем кода за счет data‑классов, расширений функций и выражения when.

19 августа в 20:00 — «Нововведения Kotlin 1.9–2.2 для JVM». Уделим внимание последним обновлениям языка, которые полезны для серверной разработки. Обсудим изменения в работе корутин, новые возможности стандартной библиотеки и оптимизации производительности.

Кроме того, пройдите вступительное тестирование, чтобы оценить свой уровень и узнать, подойдет ли вам программа курса «Kotlin Backend Developer. Professional».