Введение в шаблоны проектирования Java

Шаблон проектирования — это именованное, многократно используемое решение задачи, которая регулярно возникает при разработке программного обеспечения. Шаблоны — это не библиотеки для импорта и не код для копирования: это формы организации классов и объектов, которые опытные разработчики выработали со временем. Изучение шаблонов даёт вам общий словарь: скажите «здесь используем Factory» — и другой Java-разработчик сразу поймёт, что вы имеете в виду.

На этой странице рассказывается, что такое шаблоны проектирования, какие три семейства они образуют, и разбираются три самых распространённых — Strategy, Factory и Singleton — с запускаемым примером, который объединяет их. Предполагается, что вы уже уверенно работаете с интерфейсами и полиморфизмом, поскольку почти каждый шаблон опирается на них.

Шаблоны стали популярны благодаря книге 1994 года Design Patterns «Банды четырёх», в которой описано 23 шаблона. Не нужно знать все 23, чтобы начать. Несколько из них, применённых в нужный момент, делают код проще в изменении без риска что-то сломать.

Три семейства

Классический каталог делит шаблоны на три группы по тому, с чем они помогают:

Семейство	Задача	Примеры
Порождающие	Как создаются объекты	Singleton, Factory, Builder
Структурные	Как объекты компонуются	Adapter, Decorator, Facade
Поведенческие	Как объекты взаимодействуют	Strategy, Observer, Iterator

В самом Java таких шаблонов множество. StringBuilder — это Builder, Iterator — шаблон Iterator, а java.util.logging использует Singleton. Вы уже применяли шаблоны, не называя их по именам.

Strategy: замена алгоритма

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

interface DiscountStrategy {
    double apply(double price);
}

class PercentOff implements DiscountStrategy {
    private final double percent;
    PercentOff(double percent) { this.percent = percent; }
    public double apply(double price) { return price * (1 - percent / 100); }
}

Класс контекста хранит один DiscountStrategy и делегирует ему работу вместо цепочки if/switch. Добавление нового вида скидки означает добавление класса — без изменения существующего кода. (Полный контекст Checkout, а также варианты NoDiscount и FlatOff представлены в запускаемом примере ниже.)

Factory: централизованное создание

Factory — это единственный метод (или класс), отвечающий за выбор конкретного типа для создания экземпляра. Вызывающий код запрашивает объект по описанию и получает его, реализующий интерфейс, не зная точного класса.

static DiscountStrategy forCustomer(String tier) {
    return switch (tier) {
        case "gold"   -> new PercentOff(20);
        case "silver" -> new PercentOff(10);
        default       -> new NoDiscount();
    };
}

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

Singleton: ровно один экземпляр

Singleton гарантирует, что у класса есть только один экземпляр, и предоставляет глобальную точку доступа к нему. В современном Java самый простой и потокобезопасный способ — использовать enum: JVM гарантирует, что его константы создаются ровно один раз. Варианты с ленивой инициализацией и двойной проверкой блокировки рассматриваются в разделе Шаблон Singleton.

enum Config {
    INSTANCE;
    private final String env = "production";
    public String env() { return env; }
}

// usage
String e = Config.INSTANCE.env();

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

Когда не стоит применять шаблон

Шаблоны добавляют структуру, а структура имеет свою цену. switch с двумя вариантами не нуждается в шаблоне Strategy; класс, создаваемый один раз, не нуждается в Factory. Обращайтесь к шаблону тогда, когда ощущаете ту боль, которую он решает — дублирующиеся ветвления, разбросанные вызовы new, запутанные зависимости объектов, — а не прежде. Чрезмерное применение шаблонов порождает код, который сложнее читать, чем исходная задача.

Strategy и Factory вместе

Приведённый ниже запускаемый пример объединяет два шаблона. DiscountStrategy — это интерфейс Strategy с тремя реализациями; forCustomer — Factory, которая выбирает одну из них. Контекст Checkout делегирует работу той стратегии, которую хранит, поэтому его код не изменяется по мере смены ценового поведения.

java— editable, runs on the server

import java.util.*;

public class PatternsDemo {

// Strategy: a family of interchangeable algorithms behind one interface.
    interface DiscountStrategy {
        double apply(double price);
        String name();
    }

static class NoDiscount implements DiscountStrategy {
        public double apply(double price) { return price; }
        public String name() { return "none"; }
    }

static class PercentOff implements DiscountStrategy {
        private final double percent;
        PercentOff(double percent) { this.percent = percent; }
        public double apply(double price) { return price * (1 - percent / 100); }
        public String name() { return percent + "% off"; }
    }

static class FlatOff implements DiscountStrategy {
        private final double amount;
        FlatOff(double amount) { this.amount = amount; }
        public double apply(double price) { return Math.max(0, price - amount); }
        public String name() { return "$" + amount + " off"; }
    }

// Context: holds a strategy and delegates to it.
    static class Checkout {
        private DiscountStrategy strategy = new NoDiscount();
        void setStrategy(DiscountStrategy s) { this.strategy = s; }
        double total(double price) { return strategy.apply(price); }
        String policy() { return strategy.name(); }
    }

// Factory: one place that decides which strategy to build.
    static DiscountStrategy forCustomer(String tier) {
        return switch (tier) {
            case "gold"   -> new PercentOff(20);
            case "silver" -> new PercentOff(10);
            case "coupon" -> new FlatOff(5);
            default       -> new NoDiscount();
        };
    }

public static void main(String[] args) {
        double price = 100.0;
        Checkout checkout = new Checkout();

// Swap algorithms at runtime without touching Checkout's code.
        List<String> tiers = List.of("regular", "silver", "gold", "coupon");
        for (String tier : tiers) {
            checkout.setStrategy(forCustomer(tier));
            System.out.printf("%-8s -> %-8s total = $%.2f%n",
                tier, checkout.policy(), checkout.total(price));
        }

// The context never changes even as behaviour varies.
        checkout.setStrategy(forCustomer("gold"));
        double cheapest = checkout.total(price);
        System.out.println("Best price for gold: $" + cheapest);
        System.out.println("Strategy in effect: " + checkout.policy());
    }
}

Что следует вынести из запуска:

Каждый уровень выводит разную итоговую сумму — regular остаётся $100.00, silver снижается до $90.00, gold до $80.00, coupon до $95.00 — хотя Checkout.total вызывает один и тот же единственный метод.
Контекст Checkout никогда не ветвится по уровню сам; он просто делегирует работу той DiscountStrategy, которую хранит в данный момент.
Factory forCustomer — единственное место, которое знает, какой конкретный класс соответствует какому уровню, поэтому логика выбора сосредоточена в одном месте.
Смена поведения — это просто setStrategy(...) во время выполнения: добавление четвёртой скидки потребует нового класса и одного case в фабрике без каких-либо изменений в Checkout.
Последние строки подтверждают активную стратегию: после повторного выбора gold политика показывает 20.0% off, а итог равен $80.00, что доказывает: контекст отражает последнюю установленную стратегию.

Практика

Какую задачу решает шаблон Strategy?

Позволяет выбирать среди взаимозаменяемых алгоритмов во время выполнения за общим интерфейсомГарантирует, что у класса есть только один экземпляр в программеПреобразует один интерфейс в другой, чтобы несовместимые классы могли работать вместеЦентрализует создание всех объектов в едином глобальном реестре