Объектно-ориентированное программирование в Groovy

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ

Разработчику Архитектору

Сначала — общие понятия (раздел 4 "Код")

Если ООП для вас новое или вы учите Groovy с нуля, сначала пройдите материалы без привязки к синтаксису: парадигмы и уровни абстракции, затем ООП — о разделе — зачем объекты, введение, абстракция, инкапсуляция, наследование, полиморфизм.

Ниже — как это устроено в Groovy.

Теория и синтаксис Groovy

Groovy компилируется в JVM — модель ООП совпадает с Java (class, interface, extends, implements), плюс динамическая типизация и метапрограммирование.

Понятие ООП	Как выражено в Groovy	Аналог в Java
Класс, АДТ (алгебраический тип данных)	`class`; совместимость с Java-классами	`class`
Объект / экземпляр	`new ClassName()`, map-конструктор	`new ClassName()`
Конструктор	явный или сгенерированный; map-style `new Person(name: "x")`	`ClassName(...)`
Свойство	поле + автогенерация `getX`/`setX`	поле + геттер/сеттер вручную или Lombok
Инкапсуляция	`private`/`protected`/`public`; свойства Groovy	те же модификаторы
Наследование класса	`extends` (один родитель)	`extends`
Реализация контракта	`implements` (несколько интерфейсов)	`implements`
Горизонтальное переиспользование	`trait`, `@Delegate`, категории	интерфейсы + default methods; трейтов нет
Абстракция	`interface`, `abstract class`	то же
Полиморфизм подтипов	`@Override`, ссылка на супертип	`@Override`, виртуальные вызовы
Ad hoc-полиморфизм	перегрузка методов (как в Java)	перегрузка
Duck typing	`def`, динамический вызов без объявления типа	нет (кроме reflection)
Сообщения	вызовы методов; `methodMissing`, MOP	вызовы методов; reflection
Статика	`static` поля и методы	`static`
Иммутабельность	`@Immutable`, `final` поля	`final`, record (Java 16+)

Определения — раздел 4-08-oop; синтаксис JVM — ООП в Java. Обзор Groovy — раздел Groovy.

Кратко для новичка:

Класс — как в Java, плюс опускаемые скобки и свойства вместо геттеров.
new Person(name: 'Анна') — map-конструктор без отдельного вызова сеттеров.
Трейты — примеси методов; категории — расширение чужих классов без наследования.
Всё — объект на JVM, включая числа и замыкания.
Код компилируется в байткод JVM — см. ООП в Java.

Создание экземпляра и присваивание переменным

Оператор `new` и конструкторы

В Groovy, как в Java, объект создаётся через new. Компилятор генерирует конструктор по умолчанию и map-конструктор, если вы не объявили свои:

class Order {
    String id
    BigDecimal total
}

// Позиционный (если есть явный конструктор или @Canonical)
// Map-style — идиома Groovy:
def o1 = new Order(id: 'ORD-1', total: 99.50G)

// Явный конструктор
class OrderV2 {
    final String id
    final BigDecimal total

    OrderV2(String id, BigDecimal total) {
        this.id = id
        this.total = total
    }
}

def o2 = new OrderV2('ORD-2', 120.00G)

Разбор:

new Order(id: ..., total: ...) вызывает сгенерированный конструктор, принимающий Map или именованные аргументы.
Поля без модификатора получают приватное хранение и публичные аксессоры — снаружи пишут o1.id, внутри JVM вызывается getId().
final в Groovy, как в Java, запрещает переназначение ссылки на поле после конструктора.

Присваивание и ссылки

Объекты в JVM — ссылочные типы. Присваивание копирует ссылку, не объект:

def a = new Order(id: 'A', total: 10G)
def b = a          // та же ссылка
b.total = 20G      // изменится и a.total

def c = new Order(id: 'C', total: 10G)  // другой экземпляр

Разбор:

def b = a не создаёт копию заказа — обе переменные указывают на один heap-объект.
Для независимой копии нужен clone(), конструктор копирования или сериализация — как в Java.
Тип переменной def выводится компилятором; для публичного API предпочтительны явные типы: Order order = new Order(...).

Именованные параметры и `@Canonical`

@groovy.transform.Canonical
class Point {
    int x
    int y
}

def p = new Point(3, 4)           // позиционный конструктор
def q = new Point(x: 1, y: 2)     // map-style тоже работает с @Canonical

Разбор:

@Canonical генерирует конструктор по полям, equals, hashCode, toString.
Это аналог record/Lombok @Value в Java, но с сохранением изменяемости полей (если не @Immutable).

Модификаторы доступа

Groovy использует те же модификаторы, что Java:

Модификатор	Класс	Пакет	Наследник	Везде
`private`	да	нет	нет	нет
без модификатора (package-private)	да	да	нет*	нет
`protected`	да	да	да	нет
`public`	да	да	да	да

* В Java protected даёт доступ наследнику из другого пакета; package-private — только внутри пакета.

class Wallet {
    private BigDecimal balance = 0G

    void deposit(BigDecimal amount) {
        if (amount > 0) balance += amount
    }

    BigDecimal getBalance() { balance }
}

def w = new Wallet()
w.deposit(100G)
// w.balance = -1G  // ошибка компиляции: private
println w.balance    // OK: через сгенерированный getBalance()

Разбор:

Прямой доступ w.balance компилируется в вызов геттера — это не нарушение инкапсуляции на уровне байткода, если поле private.
Собственные getBalance() / setBalance() переопределяют автогенерацию для этого свойства.
Для критичных модулей включайте @CompileStatic — тогда опечатки в свойствах ловятся на этапе компиляции.

Четыре столпа ООП в Groovy

Интерактивные схемы — общие принципы (псевдокод). Подробнее: абстракция, инкапсуляция, наследование, полиморфизм.

Play ITЗагрузка интерактивного демо…

Абстракция

Абстракция — выделение существенного контракта и сокрытие деталей. В Groovy:

interface PaymentGateway { void charge(BigDecimal amount) } — чистый контракт без состояния.
abstract class BaseJob { abstract void run(); void execute() { /* шаблон */ run() } } — общая реализация + обязательный шаг в потомке.

interface Notifier {
    void send(String message)
}

abstract class AuditedNotifier implements Notifier {
    abstract protected void doSend(String message)

    void send(String message) {
        log.info "Sending: $message"
        doSend(message)
    }
}

Разбор:

Клиент зависит от Notifier, не от SMTP или консоли.
AuditedNotifier — шаблонный метод: общий каркас в базе, вариативная часть в doSend.

Инкапсуляция

Состояние объекта меняется только через методы с инвариантами. В Groovy удобный синтаксис свойств не отменяет правило: поля private, валидация в сеттерах (см. раздел Инкапсуляция ниже и embed groovy-512-15-002).

Наследование

extends для класса, implements для интерфейсов — как в Java. Отличие: для композиции поведения без иерархии используют трейты и категории (см. ниже).

Полиморфизм

Переменная супертипа указывает на объект подтипа; вызывается фактическая реализация метода. Дополнительно Groovy допускает duck typing: метод с параметром def примет любой объект с нужным методом во время выполнения.

Объектно-ориентированное программирование в Groovy

Groovy — динамический язык на JVM, совместимый с Java. В Groovy всё — объект: числа, строки, true/false, замыкания и даже null принадлежат классам и поддерживают вызовы методов.

Типичные области применения ООП в Groovy — Gradle (сборка), Spock (тесты), Jenkins Pipeline, скрипты автоматизации рядом с Java-кодом.

КЛАСС Кот
  поля: имя, возраст
  метод мяукнуть()
КОНЕЦ

объект barsik := новый Кот(имя="Барсик", возраст=3)
barsik.мяукнуть()

Разбор:

Псевдокод показывает базовую модель ООП: сначала описывается класс, затем создаётся объект.
В блоке поля: имя, возраст перечислено состояние экземпляра.
метод мяукнуть() описывает поведение, которое будет доступно каждому объекту класса.
Строка новый Кот(...) демонстрирует создание экземпляра с инициализацией данных.
Вызов barsik.мяукнуть() показывает отправку сообщения объекту (вызов метода).

Пример класса

Справочно на Groovy

Код ITЗагрузка примера кода…

Разбор:

class Unit — игровая сущность: свойства (характеристики, здоровье, мана, уровень) и методы в одном типе.
getDamage() — вычисляемое значение по статам; отдельного поля damage нет.
attack(Unit target) — типизированный параметр; target.health -= damage меняет состояние цели.
"${name} ..." — GString (строка с подстановкой значений).
def warrior / def mage — тип выводится компилятором; для публичного API лучше явный Unit.
new Unit() создаёт независимые экземпляры; вызовы attack демонстрируют инкапсуляцию.
Запуск: groovy filename.groovy — скрипт выполняется интерпретатором или компилируется в байткод JVM.

Интерактивная схема — класс и объект (псевдокод, подходит для любого ООП-языка). Полный разбор принципов: ООП в разделе "Код и разработка".

Play ITЗагрузка интерактивного демо…

Классы и объекты

В Groovy классы определяют шаблоны для создания объектов. Каждый объект представляет собой экземпляр класса и содержит состояние (поля) и поведение (методы). Объявление класса в Groovy выглядит привычно для разработчиков, знакомых с Java, но с рядом упрощений и расширений.

class Person {
    String name
    int age

    void sayHello() {
        println "Hello, my name is $name"
    }
}

Разбор:

Класс Person задаёт два свойства: name и age.
Метод sayHello() инкапсулирует поведение объекта и использует текущее состояние name.
GString "Hello, my name is $name" автоматически подставляет имя при вызове.
В Groovy свойства обычно получают геттеры/сеттеры автоматически, даже если они не написаны вручную.

Этот код описывает класс Person, содержащий два поля — name типа String и age типа int. Метод sayHello() выводит приветствие, используя значение поля name. В Groovy не требуется явно указывать модификаторы доступа, такие как private или public. По умолчанию все поля объявляются как private, а компилятор автоматически генерирует публичные геттеры и сеттеры. Это позволяет обращаться к полям напрямую, как если бы они были публичными, сохраняя при этом инкапсуляцию на уровне реализации.

Создание объекта происходит через оператор new:

def p = new Person(name: "Alice", age: 30)
p.sayHello()

Разбор:

new Person(name: ..., age: ...) использует именованные параметры для инициализации свойств.
Такой стиль особенно удобен, когда у объекта много полей и важна читаемость.
p.sayHello() вызывает метод экземпляра и использует его внутреннее состояние.
Переменная p объявлена через def, тип выводится как Person.

Здесь используется именованный конструктор, который принимает параметры в виде пар "ключ–значение". Такой подход делает код читаемым и гибким, позволяя задавать только нужные поля без необходимости вызывать несколько сеттеров вручную. После создания объекта можно вызывать его методы, как показано в примере с sayHello().

Интерфейс и реализация

interface Notifier {
    void send(String message)
}

class ConsoleNotifier implements Notifier {
    void send(String message) {
        println "[LOG] $message"
    }
}

def n = new ConsoleNotifier()
n.send('Сервис запущен')

Разбор:

interface Notifier задаёт контракт: любой класс-реализация должен иметь метод send.
implements Notifier связывает класс с интерфейсом на этапе компиляции.
Метод send в классе — конкретная реализация контракта.
Переменная n может иметь тип интерфейса, а вызываться будет реализация ConsoleNotifier (полиморфизм по ссылке).

Сниппет — `@Canonical` вместо шаблонного кода

@groovy.transform.Canonical
class Version {
    int major
    int minor
}

def v = new Version(2, 5)
println v          // Version(2, 5) — сгенерированный toString
assert v == new Version(2, 5)

Разбор:

@Canonical на этапе компиляции генерирует конструктор, equals, hashCode и toString.
new Version(2, 5) использует позиционный конструктор по полям в порядке объявления.
println v выводит читаемое представление без ручного toString().
assert v == new Version(2, 5) работает за счёт сгенерированного equals по значениям полей.

Наследование

Интерактивная схема — наследование (псевдокод). Подробнее: Наследование.

Play ITЗагрузка интерактивного демо…

Наследование — это механизм, позволяющий одному классу заимствовать свойства и поведение другого класса. В Groovy наследование реализуется с помощью ключевого слова extends.

class Student extends Person {
    String school
}

Разбор:

extends Person задаёт наследование: Student становится подтипом Person.
Подкласс автоматически получает унаследованные свойства и методы родителя.
Дополнительное поле school расширяет модель данными, специфичными для студента.
Это типичный способ переиспользовать общую логику без дублирования.

Класс Student наследует все поля и методы класса Person. Это означает, что объект Student может использовать метод sayHello(), не переопределяя его, а также имеет доступ к полям name и age. Дополнительно класс Student вводит новое поле school, специфичное для студентов. Наследование способствует повторному использованию кода и созданию иерархий классов, отражающих реальные отношения между сущностями.

Groovy поддерживает одиночное наследование, как и Java. Это ограничение связано с упрощением модели объектов и предотвращением сложностей, возникающих при множественном наследовании. Однако Groovy предоставляет другие механизмы, такие как примеси (mixins) и трейты (traits), которые позволяют достигать эффектов, аналогичных множественному наследованию, без его недостатков.

Инкапсуляция

Интерактивная схема — инкапсуляция (псевдокод). Подробнее: Инкапсуляция.

Play ITЗагрузка интерактивного демо…

Инкапсуляция — это принцип, согласно которому внутреннее состояние объекта скрывается от внешнего мира, а доступ к нему осуществляется через чётко определённый интерфейс. В Groovy этот принцип реализован элегантно и незаметно для разработчика.

По умолчанию все поля класса являются приватными. Однако компилятор Groovy автоматически создаёт публичные геттеры и сеттеры для каждого поля. Например, для поля name будут созданы методы getName() и setName(String name). Это позволяет обращаться к полю как p.name, и Groovy автоматически преобразует такой вызов в соответствующий геттер или сеттер.

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

Код ITЗагрузка примера кода…

Разбор:

Поле name сделано private, поэтому прямой доступ извне ограничен.
getName() возвращает значение в верхнем регистре, добавляя логику на чтение свойства.
setName(String value) валидирует вход (минимум 3 символа) перед сохранением.
При некорректном значении выбрасывается IllegalArgumentException, что защищает инварианты объекта.
Клиент может продолжать работать через p.name, а Groovy под капотом вызовет эти методы.

В этом случае обращение к p.name будет использовать пользовательские геттер и сеттер, обеспечивая дополнительную логику без изменения клиентского кода.

Полиморфизм

Интерактивная схема — полиморфизм (псевдокод). Подробнее: Полиморфизм.

Play ITЗагрузка интерактивного демо…

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

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

Код ITЗагрузка примера кода…

Разбор:

Определены два класса с методом introduce(): базовый и переопределённый в наследнике.
Аннотация @Override фиксирует намерение заменить реализацию родителя.
Список people содержит объекты разных фактических типов (Person и Student).
each { it.introduce() } вызывает один и тот же метод у каждого элемента.
Во время выполнения выбирается соответствующая реализация для конкретного объекта (полиморфизм).

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

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

Замыкания

Замыкание (closure) — анонимный блок кода, который можно сохранить в переменной, передать в метод или вернуть из метода. Замыкание видит переменные окружающей области видимости.

def greet = { name -> println "Hello, $name" }
greet("Groovy")

Разбор:

greet хранит замыкание, а не строку или число.
name -> ... — параметр замыкания (аналог лямбды в Java).
GString "Hello, $name" подставляет значение параметра.
greet("Groovy") вызывает блок как функцию.
Замыкания — объекты первого класса; ими пользуются коллекции (collect, findAll) и DSL.

Пример использования замыкания с коллекцией:

def numbers = [1, 2, 3, 4, 5]
def doubled = numbers.collect { it * 2 }
println doubled // [2, 4, 6, 8, 10]

Разбор:

numbers — исходная коллекция значений.
collect { it * 2 } применяет преобразование к каждому элементу и возвращает новый список.
В замыкании it — текущий элемент списка.
Исходный список не изменяется, создаётся отдельный результат doubled.
Такой подход делает преобразования данных декларативными и легко тестируемыми.

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

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

Расширенные возможности ООП в Groovy

Помимо четырёх столпов ООП Groovy добавляет метапрограммирование, трейты, @Delegate и замыкания для компактного кода на JVM.

Метапрограммирование

Метапрограммирование — изменение или расширение поведения программы во время выполнения. В Groovy для этого служат metaClass, methodMissing и категории.

MOP (Meta-Object Protocol) — протокол метаобъектов: API для добавления методов и свойств к классам в runtime.

Пример — метод isEven() у Integer без изменения исходного класса Java:

Integer.metaClass.isEven = { -> delegate % 2 == 0 }

println 4.isEven() // true
println 5.isEven() // false

Разбор:

Через metaClass к стандартному классу Integer динамически добавляется новый метод isEven().
delegate внутри замыкания — конкретное число, для которого вызван метод.
Выражение delegate % 2 == 0 проверяет чётность.
После расширения метод доступен всем экземплярам Integer в текущем runtime.
Это демонстрация runtime-метапрограммирования Groovy.

Методы-ловушки methodMissing и propertyMissing вызываются, когда Groovy не находит запрошенный метод или свойство. На них строят DSL и динамические прокси.

class DynamicGreeter {
    def methodMissing(String name, args) {
        return "Hello, ${name.capitalize()}!"
    }
}

def greeter = new DynamicGreeter()
println greeter.alice   // Hello, Alice!
println greeter.bob     // Hello, Bob!

Разбор:

Класс не объявляет методы alice или bob, но содержит обработчик methodMissing.
Когда Groovy не находит метод, он вызывает methodMissing(String name, args).
Параметр name содержит имя вызванного "метода", и оно используется для генерации ответа.
capitalize() приводит первую букву к верхнему регистру.
Такой приём часто применяют в DSL и динамических прокси.

Трейты (Traits)

Трейты — механизм повторного использования кода: как интерфейсы, но с реализацией методов; как наследование, но без ромбовидной неоднозначности при нескольких родителях.

Код ITЗагрузка примера кода…

Разбор:

trait объявляет переиспользуемый блок поведения с готовой реализацией методов.
Класс Duck implements Flyable, Swimmable получает методы обоих трейтов.
Созданный объект duck может вызывать fly() и swim() без ручного дублирования кода.
Трейты решают задачу композиции поведения без множественного наследования классов.

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

Композиция через `@Delegate`

Groovy упрощает композицию — один из ключевых принципов проектирования, согласно которому объекты строятся из других объектов, а не наследуются от них. Аннотация @Delegate автоматически делегирует вызовы методов указанному полю.

class Engine {
    void start() { println "Engine started" }
}

class Car {
    @Delegate Engine engine = new Engine()
}

def car = new Car()
car.start() // Engine started

Разбор:

Engine инкапсулирует конкретную функциональность (start).
В Car поле engine помечено @Delegate, поэтому методы engine "прокидываются" наружу.
car.start() выглядит как собственный метод Car, но фактически делегируется объекту engine.
Это уменьшает шаблонный код обёрток и поддерживает композицию вместо наследования.

Благодаря @Delegate, метод start() вызывается на объекте engine, хотя в клиентском коде он выглядит как метод класса Car. Это позволяет создавать "обёртки" вокруг существующих компонентов без ручного написания делегирующих методов.

Поддержка функционального стиля в рамках ООП

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

Например, методы коллекций в Groovy (each, collect, find, findAll и другие) принимают замыкания в качестве аргументов, что делает обработку данных лаконичной и читаемой:

def people = [
    new Person(name: "Alice", age: 30),
    new Person(name: "Bob", age: 25)
]

def adults = people.findAll { it.age >= 18 }
adults.each { it.sayHello() }

Разбор:

Создаётся список объектов Person через именованные параметры.
findAll { it.age >= 18 } фильтрует только совершеннолетних.
adults получает результат фильтрации как новый список.
each { it.sayHello() } вызывает метод у каждого найденного объекта.
Пример объединяет ООП-модель (Person) и функциональную обработку коллекций.

Здесь findAll фильтрует список по условию, а each применяет действие к каждому элементу. Оба метода используют замыкания, которые работают с объектами Person, сохраняя инкапсуляцию и полиморфизм.

Соглашения и соглашение о конструкторах

Groovy следует принципу "соглашения вместо конфигурации". Например, если в классе объявлены поля без явных геттеров и сеттеров, Groovy автоматически создаёт их. Аналогично, если не определён конструктор, компилятор генерирует конструктор по умолчанию и именованный конструктор, принимающий Map.

Это позволяет писать минимальный код для создания рабочих объектов:

class Book {
    String title
    String author
}

def book = new Book(title: "1984", author: "George Orwell")
println book.title  // 1984

Разбор:

Book объявляет только поля, без явных конструкторов и аксессоров.
Groovy автоматически генерирует базовые механизмы работы со свойствами.
new Book(title: ..., author: ...) инициализирует объект через map-style конструктор.
book.title читает свойство через сгенерированный геттер.
Это типичный минималистичный стиль для DTO/моделей.

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

Совместимость с Java и расширение её возможностей

Groovy тесно интегрирован с Java: любой Java-класс используется в Groovy без обёрток; Groovy-класс с явными типами в сигнатурах вызывается из Java как обычный Java-класс (динамические фичи — только при подключённом рантайме Groovy). При этом Groovy добавляет к Java множество улучшений: безопасная навигация (?.), оператор элвиса (?:), расширенные строковые литералы (GString), упрощённая работа с коллекциями и многое другое.

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

Практическое применение ООП в Groovy — идиомы и паттерны

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

Инициализация объектов через именованные параметры

Одной из самых удобных возможностей Groovy является создание объектов с использованием именованных параметров. Это достигается за счёт автоматической генерации конструктора, принимающего Map. Такой подход особенно полезен при работе с объектами, имеющими множество полей, где порядок аргументов не важен, а читаемость кода повышается.

class Configuration {
    String host
    int port
    boolean sslEnabled
}

def config = new Configuration(
    host: "api.example.com",
    port: 443,
    sslEnabled: true
)

Разбор:

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

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

Безопасная навигация и обработка отсутствующих значений

В объектно-ориентированных системах часто возникает необходимость работать с цепочками вызовов, где любой элемент может быть null. Groovy решает эту проблему с помощью оператора безопасной навигации (?.):

def city = person?.address?.city

Разбор:

person?.address?.city безопасно проходит по цепочке свойств.
Если person или address равны null, выражение вернёт null.
Это позволяет избежать каскадов if (x != null) и NullPointerException.
Конструкция особенно полезна в доменных моделях с опциональными полями.

Если person или address равны null, выражение вернёт null, а не выбросит исключение. Это устраняет необходимость в многоуровневых проверках и делает код компактным. В сочетании с оператором элвиса (?:) можно задать значения по умолчанию:

def city = person?.address?.city ?: "Unknown"

Разбор:

Левая часть пытается получить город через безопасную навигацию.
Elvis ?: подставляет "Unknown", если левая часть отсутствует или "ложная".
В одной строке объединены null-safety и дефолт.
Это частый паттерн для API-ответов и отображения данных.

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

Расширение стандартных классов

Groovy позволяет расширять даже базовые классы платформы Java, такие как String, List, File и другие. Это достигается через метапрограммирование или использование категорий. Например, можно добавить метод toCamelCase() к строкам:

String.metaClass.toCamelCase = {
    def parts = delegate.split('_')
    parts[0] + parts[1..-1].collect { it.capitalize() }.join('')
}

println "user_name".toCamelCase() // userName

Разбор:

К String добавляется динамический метод toCamelCase().
delegate.split('_') разбивает исходную строку на части.
Первая часть оставляется как есть, остальные капитализируются и склеиваются.
Вызов "user_name".toCamelCase() демонстрирует итоговое преобразование в userName.
Это пример адаптации стандартных типов под доменную задачу.

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

Создание DSL на основе ООП

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

Пример простого DSL для описания задач:

Код ITЗагрузка примера кода…

Разбор:

TaskBuilder хранит список задач в поле Задачи.
Метод task(String description, Closure action) добавляет описание и выполняет переданное действие.
Вызовы builder.task("...") { ... } образуют мини-DSL с декларативным стилем.
println builder.Задачи показывает накопленный результат после выполнения сценариев.
Пример иллюстрирует, как классы и замыкания формируют читаемый внутренний язык.

Здесь объект TaskBuilder предоставляет интерфейс, который выглядит как декларативный язык, но реализован с использованием классов, методов и замыканий. Такой подход широко используется в Gradle, Spock и других Groovy-проектах.

Работа с коллекциями как с объектами первого класса

В Groovy коллекции — это полноценные объекты с богатым набором методов. Списки, множества, карты поддерживают функциональные операции (collect, findAll, any, every), агрегацию (sum, max, min), группировку (groupBy) и преобразование (toSet, toList). Все эти методы принимают замыкания, что позволяет писать выразительный код без циклов.

def employees = [
    [name: "Alice", department: "Engineering", salary: 80000],
    [name: "Bob", department: "Marketing", salary: 60000],
    [name: "Charlie", department: "Engineering", salary: 90000]
]

def avgSalary = employees.sum { it.salary } / employees.size()
def engineeringNames = employees.findAll { it.department == "Engineering" }
                                .collect { it.name }

Разбор:

employees — список карт, где каждая карта описывает сотрудника.
sum { it.salary } / employees.size() вычисляет среднюю зарплату по выборке.
findAll { it.department == "Engineering" } фильтрует сотрудников нужного отдела.
collect { it.name } оставляет только имена из отфильтрованного набора.
Pipeline читабельно разделяет агрегацию и выборку данных.

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

Поддержка иммутабельности

Хотя Groovy по умолчанию создаёт изменяемые объекты, он предоставляет инструменты для построения иммутабельных структур. Аннотация @Immutable автоматически делает класс неизменяемым — все поля становятся final, генерируются конструкторы, и запрещаются сеттеры.

@Immutable
class Point {
    int x
    int y
}

def p = new Point(10, 20)
// p.x = 5 // ошибка компиляции или выполнения

Разбор:

@Immutable генерирует неизменяемый класс: поля фиксируются после создания.
Экземпляр new Point(10, 20) инициализируется через конструктор.
Попытка p.x = 5 запрещена, так как сеттеры не предусмотрены.
Иммутабельность снижает риски побочных эффектов и упрощает потокобезопасность.

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

Интеграция с JavaBeans и Spring

Groovy полностью совместим с соглашениями JavaBeans. Автоматически сгенерированные геттеры и сеттеры делают Groovy-классы идеальными кандидатами для использования в Spring, Hibernate и других фреймворках, основанных на JavaBeans. При этом разработчик пишет минимум кода, получая максимум функциональности.

@Component
class UserService {
    @Autowired
    UserRepository repository

    List<User> findActiveUsers() {
        repository.findAll().findAll { it.active }
    }
}

Разбор:

@Component регистрирует класс как Spring-бин.
@Autowired UserRepository repository внедряет зависимость репозитория.
findActiveUsers() получает всех пользователей и фильтрует активных через findAll.
Возвращаемый тип List<User> фиксирует контракт метода для клиентов сервиса.
Пример показывает, что Groovy-класс естественно встраивается в Spring-архитектуру.

Этот класс может быть использован в Spring-приложении без каких-либо дополнительных настроек. Groovy берёт на себя всю рутину, связанную с инкапсуляцией и внедрением зависимостей.

Архитектурные рекомендации для ООП в Groovy

В больших кодовых базах полезно разделять зоны динамики и зоны строгой типизации:

доменные сущности и публичные сервисы держите с явными типами;
DSL, скрипты и тестовые фикстуры оставляйте динамичными;
на критичных модулях подключайте @CompileStatic;
динамические трюки (metaClass, methodMissing) концентрируйте в инфраструктурном слое.

import groovy.transform.CompileStatic

@CompileStatic
class PriceService {
    BigDecimal withTax(BigDecimal base, BigDecimal taxRate) {
        base + (base * taxRate)
    }
}

Разбор:

import groovy.transform.CompileStatic подключает аннотацию статической компиляции.
@CompileStatic включает более строгую проверку типов и генерирует более предсказуемый байткод.
withTax(...) типизирован явно: BigDecimal на входе и выходе.
Формула base + (base * taxRate) выражает расчёт итоговой цены с налогом.
Такой стиль подходит для критичных участков доменной логики.

Такой баланс сохраняет выразительность Groovy и улучшает предсказуемость поведения.

Сравнение Groovy с Java

Тема	Groovy	Java
Классы и интерфейсы	`class`, `interface`, `extends`, `implements`	то же
Создание объекта	`new`, map-конструктор, `@Canonical`	`new`, record, Lombok
Свойства	автогенерация геттеров/сеттеров	явные или Lombok
Типизация	опциональная (`def`), динамика в runtime	статическая, обязательные типы
Множественное наследование классов	нет	нет
Примеси поведения	`trait`, `@Delegate`, категории	интерфейсы с default methods
Метапрограммирование	`metaClass`, `methodMissing`, AST	reflection, annotation processing
Null-safety	`?.`, `?:`	`Optional`, nullable annotations
Статическая компиляция	`@CompileStatic`	по умолчанию
Вызов из другого языка	Groovy-класс → Java без обёрток	Java-класс → Groovy напрямую

Groovy не заменяет Java в ядре домена с жёсткими контрактами — он расширяет JVM там, где нужны лаконичность, DSL и скрипты (Gradle, Spock, Jenkins pipeline).

Типичные ошибки

Ошибка	Почему больно	Что делать
Считать `p.name` прямым доступом к полю	вызывается геттер; логика может быть скрыта	читать сгенерированные аксессоры; для инвариантов — явные `get`/`set`
Везде `def` в доменном слое	ошибки типов только в runtime	публичные API с явными типами; `@CompileStatic` на сервисах
`metaClass` в бизнес-логике	глобальное изменение классов, сложный дебаг	MOP только в инфраструктуре, тестах, DSL
Глубокие иерархии `extends`	хрупкий дизайн, нарушение LSP	трейты, композиция, `@Delegate`
Игнорировать `trait` конфликты	неоднозначность методов при нескольких трейтах	явное разрешение, как в Java с default methods
Map-конструктор без проверки ключей	опечатка в имени поля молча игнорируется	`@CompileStatic`, явный конструктор, тесты
Общая мутабельная коллекция в поле класса	все экземпляры делят один список	инициализировать коллекцию в конструкторе/`new`

Чеклист проектирования класса в Groovy

Ответственность — один класс решает одну задачу предметной области.
Конструктор — все обязательные поля инициализированы; инварианты проверены в конструкторе или сеттерах.
Видимость — поля private; наружу только осмысленные методы.
Типы — у публичных методов явные типы параметров и возврата.
Наследование — только отношение является; иначе композиция или trait.
Динамика — metaClass / methodMissing изолированы от домена.
Тест — unit-тест создаёт объект через тот же путь, что production-код (new, фабрика, builder).

Для повторения принципов: ООП — о разделе. Для Groovy-специфики: Типы данных, Особенности и расширения.

Сквозной кейс — сервис каталога книг

На уровне ООП каталог удобно оформить как сервис с четким контрактом:

Код ITЗагрузка примера кода…

Разбор:

Сервис хранит books как private final список, что фиксирует зависимость после создания.
Конструктор принимает данные и гарантирует инициализацию обязательного состояния.
activeBooks() отделяет правило фильтрации активных элементов в отдельный метод.
totalPrice() агрегирует цены: collect вытаскивает поле, inject суммирует с начальным 0G.
Аннотация @CompileStatic делает бизнес-логику более строгой и безопасной на этапе компиляции.

Такой класс легко тестировать и затем подключать к слою БД.

Дальше по кейсу: Работа с базами данных из Groovy.

Учебные примеры ООП

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

Класс и объект

Чертёж класса Figure и конкретные объекты — круг и квадрат.

Код ITЗагрузка примера кода…

Банковский счёт

Инкапсуляция: скрытое поле баланса и методы deposit/withdraw.

Код ITЗагрузка примера кода…

Наследование

Родитель Animal и дочерние Cat и Dog с общим eat() и своим speak().

Код ITЗагрузка примера кода…

Смартфон

Состояние объекта: заряд батареи, звонки и подзарядка.

Код ITЗагрузка примера кода…

Студент

Список оценок, средний балл и проходной порог.

Код ITЗагрузка примера кода…

Корзина покупок

Взаимодействие Product, Cart и Order при оформлении заказа.

Код ITЗагрузка примера кода…

Автомобиль

Пробег, расход топлива и напоминание о техобслуживании.

Код ITЗагрузка примера кода…

Пользователь

Скрытый пароль, вход в систему и публикация сообщений.

Код ITЗагрузка примера кода…

Теория и синтаксис Groovy​

Создание экземпляра и присваивание переменным​

Оператор new и конструкторы​

Присваивание и ссылки​

Именованные параметры и @Canonical​

Модификаторы доступа​

Четыре столпа ООП в Groovy​

Абстракция​

Инкапсуляция​

Наследование​

Полиморфизм​

Объектно-ориентированное программирование в Groovy​

Пример класса​

Классы и объекты​

Интерфейс и реализация​

Сниппет — @Canonical вместо шаблонного кода​

Наследование​

Инкапсуляция​

Полиморфизм​

Замыкания​

Расширенные возможности ООП в Groovy​

Метапрограммирование​

Трейты (Traits)​

Композиция через @Delegate​

Поддержка функционального стиля в рамках ООП​

Соглашения и соглашение о конструкторах​

Совместимость с Java и расширение её возможностей​

Практическое применение ООП в Groovy — идиомы и паттерны​

Инициализация объектов через именованные параметры​

Безопасная навигация и обработка отсутствующих значений​

Расширение стандартных классов​

Создание DSL на основе ООП​

Работа с коллекциями как с объектами первого класса​

Поддержка иммутабельности​

Интеграция с JavaBeans и Spring​

Архитектурные рекомендации для ООП в Groovy​

Сравнение Groovy с Java​

Типичные ошибки​

Чеклист проектирования класса в Groovy​

Сквозной кейс — сервис каталога книг​

Учебные примеры ООП​

Класс и объект​

Банковский счёт​

Наследование​

Смартфон​

Студент​

Корзина покупок​

Автомобиль​

Пользователь​

См. также

История языка Groovy

Что требуется знать перед началом изучения языка программирования Groovy

Рекомендации по разработке на Groovy

Простые приложения на Groovy

Основы языка Groovy

Типы данных и объявление переменных в Groovy

Операторы и выражения в Groovy

Циклы и управляющие конструкции в Groovy

Иерархия исключений в Groovy

Особенности и расширения языка Groovy

Синтаксис и пунктуация в Groovy

Ключевые слова языка Groovy

Теория и синтаксис Groovy

Создание экземпляра и присваивание переменным

Оператор `new` и конструкторы

Присваивание и ссылки

Именованные параметры и `@Canonical`

Модификаторы доступа

Четыре столпа ООП в Groovy

Абстракция

Инкапсуляция

Наследование

Полиморфизм

Объектно-ориентированное программирование в Groovy

Пример класса

Классы и объекты

Интерфейс и реализация

Сниппет — `@Canonical` вместо шаблонного кода

Наследование

Инкапсуляция

Полиморфизм

Замыкания

Расширенные возможности ООП в Groovy

Метапрограммирование

Трейты (Traits)

Композиция через `@Delegate`

Поддержка функционального стиля в рамках ООП

Соглашения и соглашение о конструкторах

Совместимость с Java и расширение её возможностей

Практическое применение ООП в Groovy — идиомы и паттерны

Инициализация объектов через именованные параметры

Безопасная навигация и обработка отсутствующих значений

Расширение стандартных классов

Создание DSL на основе ООП

Работа с коллекциями как с объектами первого класса

Поддержка иммутабельности

Интеграция с JavaBeans и Spring

Архитектурные рекомендации для ООП в Groovy

Сравнение Groovy с Java

Типичные ошибки

Чеклист проектирования класса в Groovy

Сквозной кейс — сервис каталога книг

Учебные примеры ООП

Класс и объект

Банковский счёт

Наследование

Смартфон

Студент

Корзина покупок

Автомобиль

Пользователь