// Тикет в поддержку
record Ticket(String subject, Severity severity, boolean inFAQ) {}

// Уровень "сложности" тикета.
enum Severity { LOW, MID, HIGH, CRITICAL }

// Контракт обработчика цепочки.
interface Handler { Result handle(Ticket t); }

/*
  Базовый класс для звеньев цепи.
  Делегирование инкапсулировано в forward(t)
*/
abstract class AbstractHandler implements Handler {
    private final Handler next;

    protected AbstractHandler(Handler next) { this.next = next; }

    // Передаём обработку следующему звену
    protected Result forward(Ticket t) {
        return next == null ? new Result.Unhandled() : next.handle(t);
    }
}

// 1) Бот отвечает на известные вопросы из FAQ.
final class Bot extends AbstractHandler {
    Bot(Handler next) { super(next); }

    @Override
    public Result handle(Ticket t) {
        // "Знаю ответ" → завершаем цепочку (ранний выход)
        return t.inFAQ() ? new Result.Handled("Бот: ответил по FAQ")
                         : forward(t); // "Не знаю" → отдаём дальше.
    }
}

// 2) Первая линия поддержки: берёт простые кейсы.
final class L1 extends AbstractHandler {
    L1(Handler next) { super(next); }

    @Override
    public Result handle(Ticket t) {
        return (t.severity().ordinal() <= Severity.MID.ordinal())
                ? new Result.Handled("L1: решено")
                : forward(t);
    }
}

/**
 * 3) Финальная перехватчик: R&D "забирает в работу".
 * Это "поглощающий" обработчик: всегда Handled.
 */
final class RnD extends AbstractHandler {
    RnD() { super(null); }

    @Override
    public Result handle(Ticket t) {
        return new Result.Handled("Эскалация в R&D: взяли в работу");
    }
}

public class CoRExample {
  public static void main(String[] args) {
      // Сборка неизменяемой цепочки: Bot → L1 → RnD.
      Handler chain = new Bot(new L1(new RnD()));

      // Демонстрационные тикеты: FAQ/простой/критичный.
      for (var t : List.of(
          new Ticket("Как сменить пароль?", Severity.LOW, true),
          new Ticket("Смена тарифа", Severity.MID, false),
          new Ticket("Падает прод", Severity.CRITICAL, false))) {

         var r = chain.handle(t);
         switch (r) {
            case Result.Handled h   
                        -> System.out.println(h.message());
            case Result.Unhandled u 
                        -> System.out.println("Некому обработать");
       }
     }
  }
}

// Получатель (Receiver): корзина
final class ShoppingCart {
    // productCode -> count
    private final Map<String, Integer> items = new LinkedHashMap<>();

    void addItem(String productCode, int count) {
        items.merge(productCode, count, Integer::sum);
    }

    void removeItem(String productCode, int count) {
        int currentCount = items.getOrDefault(productCode, 0);
        int nextCount = Math.max(0, currentCount - count);
        
        if (nextCount == 0) items.remove(productCode); 
        else items.put(productCode, nextCount);
    }

    int countOf(String productCode) {
      return items.getOrDefault(productCode, 0);
    }
}

// Контракт команды
interface CartCommand {
    void execute();
    void undo();
}

// Конкретные команды
record AddItemToCart(ShoppingCart cart, String productCode, int count) implements CartCommand {
    @Override public void execute() {
      cart.addItem(productCode, count);
    }

    @Override public void undo() {
      cart.removeItem(productCode, count); // по учебному просто
    }
}

final class RemoveItemFromCart implements CartCommand {
    private final ShoppingCart cart;
    private final String productCode;
    private final int requestedCount;

    // Сколько реально сняли
    private int actuallyRemoved;

    RemoveItemFromCart(ShoppingCart cart, String productCode, int requestedCount) {
        this.cart = cart; this.productCode = productCode; this.requestedCount = requestedCount;
    }

    @Override public void execute() {
        int currentCount = cart.countOf(productCode);
        actuallyRemoved = Math.min(requestedCount, currentCount);
        cart.removeItem(productCode, actuallyRemoved);
    }

    @Override public void undo() {
        if (actuallyRemoved > 0) {
          cart.addItem(productCode, actuallyRemoved);
        }
    }
}

// Инициатор (Invoker): выполняет команды и хранит историю для undo
final class CommandInvoker {
    private final Deque<CartCommand> historyStack = new ArrayDeque<>();

    void run(CartCommand command) {
        command.execute();
        historyStack.push(command);
    }

    void undoLast() {
        CartCommand command = historyStack.poll();
        if (command != null) command.undo();
    }
}

// Клиент
public class ShoppingCartCommandDemo {
  public static void main(String[] args) {
    var cart = new ShoppingCart();
    var invoker = new CommandInvoker();

    // +2 яблока
    invoker.run(new AddItemToCart(cart, "PRODUCT-APPLE", 2));
    // +1 молоко
    invoker.run(new AddItemToCart(cart, "PRODUCT-MILK", 1));
    // -1 яблоко
    invoker.run(new RemoveItemFromCart(cart, "PRODUCT-APPLE", 1));

    // вернёт 1 яблоко
    invoker.undoLast();                                            

    // снимет всё, что было (1)
    invoker.run(new RemoveItemFromCart(cart, "PRODUCT-MILK", 5));
    // вернёт ровно 1
    invoker.undoLast();                                           
  }
}

var list = java.util.List.of("a", "b", "c");
var it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

final class Playlist implements Iterable<String> {
    private static final class Node {
        final String title; Node next;
        Node(String t) { this.title = t; }
    }

    private Node head, tail;
    private int modCount; // отслеживаем изменения

    public void add(String title) {
        Objects.requireNonNull(title);
        Node n = new Node(title);
        if (head == null) head = tail = n;
        else { tail.next = n; tail = n; }
        modCount++;
    }

    @Override public Iterator<String> iterator() {
        final int expected = modCount; // снимок состояния
      
        return new Iterator<>() {
            private Node cur = head;
          
            @Override public boolean hasNext() { return cur != null; }
            @Override public String next() {
                if (expected != modCount) throw new ConcurrentModificationException();
                if (cur == null) throw new NoSuchElementException();
                String v = cur.title;
                cur = cur.next;
                return v;
            }
            @Override public void remove() { 
              throw new UnsupportedOperationException(); 
            }
        };
    }
}

public class IteratorDemo {
    public static void main(String[] args) {
        var pl = new Playlist();
        pl.add("Intro");
        pl.add("Main Theme");
        pl.add("Finale");

        // 1) for-each использует наш Iterator
        for (var track : pl) System.out.println(track);

        // 2) Два независимых курсора
        Iterator<String> it1 = pl.iterator();
        Iterator<String> it2 = pl.iterator();
        System.out.println(it1.next()); // Intro
        System.out.println(it1.next()); // Main Theme
        System.out.println(it2.next());// Intro (другой курсор)
    }
}

Для простоты наш итератор не потокобезопасен. Как и в стандартных коллекциях при модификации во время обхода приводит к ConcurrentModification исключению

// события, о которых сообщают коллеги посреднику
enum Event { SIGNUP_SUBMITTED, USER_SAVED, SAVE_FAILED }

record User(String email) {}

// контракт посредника
interface Mediator { void notify(Event event, User user); }

// базовый класс коллег: знают только посредника
abstract class Colleague {
    protected Mediator mediator;
    void setMediator(Mediator m) { this.mediator = m; }
}

// коллеги (никаких прямых вызовов друг друга)
final class UserController extends Colleague {
    void signup(User u) {
        System.out.println("Controller: signup " + u.email());
        mediator.notify(Event.SIGNUP_SUBMITTED, u);
    }
}

final class UserRepository extends Colleague {
    void save(User u) {
        boolean ok = !u.email().endsWith("@bad");
        System.out.println(ok ? "Repo: saved " : "Repo: save FAILED");
        mediator.notify(ok ? Event.USER_SAVED : Event.SAVE_FAILED, u);
    }
}

final class Mailer extends Colleague {
    void sendWelcome(User u) {
        System.out.println("Mailer: welcome sent to " + u.email());
    }
    void sendSorry(User u) {
        System.out.println("Mailer: sorry email to " + u.email());
    }
}

// посредник: вся схема взаимодействия централизована здесь
final class SignupMediator implements Mediator {
    private final UserRepository repo;
    private final Mailer mailer;
    SignupMediator(UserController c, UserRepository r, Mailer m) {
        this.repo = r; this.mailer = m;
        c.setMediator(this); r.setMediator(this); m.setMediator(this);
    }

    @Override
    public void notify(Event e, User u) {
        switch (e) {
            case SIGNUP_SUBMITTED -> repo.save(u);
            case USER_SAVED       -> mailer.sendWelcome(u);
            case SAVE_FAILED      -> mailer.sendSorry(u);
        }
    }
}

// демо
public class Main {
    public static void main(String[] args) {
        var controller = new UserController();
        var repo = new UserRepository();
        var mailer = new Mailer();
        new SignupMediator(controller, repo, mailer);

        // saved -> welcome
        controller.signup(new User("good@example.com"));
        // failed -> sorry
        controller.signup(new User("oops@bad"));
    }
}

final class TextEditor {
    private StringBuilder buf = new StringBuilder();

    public void append(String s) { buf.append(s); }

    public void deleteLast(int n) {
        int newLen = Math.max(0, buf.length() - Math.max(0, n));
        buf.setLength(newLen);
    }

    public String text() { return buf.toString(); }

    // Сохранить/восстановить снимок 
    // внешний мир видит только интерфейс
    public Memento save() { return new Snap(buf.toString()); }

    public void restore(Memento m) {
        this.buf = new StringBuilder(((Snap) m).state());
    }

    // Узкий тип снимка доступен снаружи (для хранения), 
    // реализация скрыта
    public sealed interface Memento permits Snap {}

    // Реализация снимка — приватная «чёрная коробка»
    private static final record Snap(String state) implements Memento {}
}

// Caretaker
public class Main {
    public static void main(String[] args) {
        TextEditor editor = new TextEditor();
        Deque<TextEditor.Memento> history = new ArrayDeque<>();

        editor.append("Hello");
        history.push(editor.save());              // чекпоинт #1

        editor.append(", world");
        history.push(editor.save());              // чекпоинт #2

        editor.append("!!!");
        System.out.println(editor.text());        // Hello, world!!!

        editor.restore(history.pop());
        System.out.println(editor.text());        // Hello, world

        editor.restore(history.pop());
        System.out.println(editor.text());        // Hello
    }
}

// Наблюдатель: получает ссылку на источник и тянет состояние сам (PULL)
@FunctionalInterface
interface Observer<T> { void onUpdate(Subject<T> source); }

// Источник событий
interface Subject<T> {
    void subscribe(Observer<T> o);
    void unsubscribe(Observer<T> o);
    T state(); // текущее состояние, которое наблюдатели читают в onUpdate(...)
}

// Публикатор новостей (Subject)
final class NewsPublisher implements Subject<String> {
    private final List<Observer<String>> observers = new CopyOnWriteArrayList<>();
    private volatile String lastNews; // актуальная новость

    public void publish(String news) {
        lastNews = news;
        // передаём ИСТОЧНИК, не сами данные
        observers.forEach(o -> o.onUpdate(this)); 
    }

    @Override public String state() { return lastNews; }
    @Override public void subscribe(Observer<String> o)   {
      observers.add(o);
    }
    @Override public void unsubscribe(Observer<String> o) {
      observers.remove(o);
    }
}

// Подписчики (Observers): тянут news через source.state()
final class EmailService implements Observer<String> {
    @Override public void onUpdate(Subject<String> source) {
        System.out.println("[EMAIL] " + source.state());
    }
}
final class SmsService implements Observer<String> {
    @Override public void onUpdate(Subject<String> source) {
        System.out.println("[SMS] " + source.state());
    }
}

// Демонстрация
public class Main {
    public static void main(String[] args) {
        var publisher = new NewsPublisher();
        var email = new EmailService();
        var sms = new SmsService();

        publisher.subscribe(email);
        publisher.subscribe(sms);

        publisher.publish("Распродажа до −50%!");
        publisher.unsubscribe(sms);
        publisher.publish("Вышла новая статья про поведенческие паттерны.");
    }
}

// Контекст + состояния (инкапсулированы внутри)
final class Turnstile {
    // синглтоны состояний
    static final TurnstileState LOCKED   = new Locked();
    static final TurnstileState UNLOCKED = new Unlocked();

    // текущее состояние
    private TurnstileState state = LOCKED;

    // события
    void coin(boolean paid) { state.coin(this, paid); }
    void push()             { state.push(this); }
    void timeout()          { state.timeout(this); }

    // смена состояния — доступна только внутри пакета
    void setState(TurnstileState s) { this.state = s; }

    // «эффекты»
    void lock()   { System.out.println("Turnstile: LOCKED"); }
    void unlock() { System.out.println("Turnstile: UNLOCKED"); }
    void alarm()  { System.out.println("Turnstile: ALARM!"); }
    void thank()  { System.out.println("Turnstile: THANK YOU"); }
}

sealed interface TurnstileState permits Locked, Unlocked {
    void coin(Turnstile t, boolean paid);
    void push(Turnstile t);
    default void timeout(Turnstile t) {} // по умолчанию — нет реакции
}

final class Locked implements TurnstileState {
    @Override public void coin(Turnstile t, boolean paid) {
        if (paid) { t.unlock(); t.setState(Turnstile.UNLOCKED); }
        else t.alarm();
    }
    @Override public void push(Turnstile t) { t.alarm(); }
}

final class Unlocked implements TurnstileState {
    @Override public void coin(Turnstile t, boolean paid) {
      t.thank(); // заплатил ещё раз? поблагодарим :)
    } 
    @Override public void push(Turnstile t) {
      t.lock();
      t.setState(Turnstile.LOCKED);
    }
    @Override public void timeout(Turnstile t) {
      t.lock();
      t.setState(Turnstile.LOCKED);
    }
}

// Демонстрация
public class Main {
    public static void main(String[] args) {
        var gate = new Turnstile();

        gate.push(); // ALARM! (закрыт)
        gate.coin(false); // ALARM! (денег не хватило)
        gate.coin(true); // UNLOCKED
        gate.coin(true); // THANK YOU (лишняя оплата)
        gate.timeout(); // LOCKED (автозакрытие)
        gate.coin(true);  // UNLOCKED
        gate.push(); // LOCKED (прошёл)
    }
}

@FunctionalInterface
interface PricingStrategy {
    BigDecimal price(BigDecimal base);
}

// Контекст
final class PriceCalculator {
    private PricingStrategy strategy;
    PriceCalculator(PricingStrategy s) { this.strategy = Objects.requireNonNull(s); }
    void setStrategy(PricingStrategy s) { this.strategy = Objects.requireNonNull(s); }

    BigDecimal checkout(BigDecimal base) {
        BigDecimal r = Objects.requireNonNull(strategy).price(Objects.requireNonNull(base));
        if (r.signum() < 0) r = BigDecimal.ZERO;                 // инвариант: не уходим в минус
        return r.setScale(2, RoundingMode.HALF_UP);              // единое правило округления
    }
}

// Стратегии
record NoDiscount() implements PricingStrategy {
    public BigDecimal price(BigDecimal base) { return base; }
}

record PercentOff(int percent) implements PricingStrategy {
    public PercentOff {                                        // compact ctor (Java 16+)
        if (percent < 0 || percent > 100) throw new IllegalArgumentException("0..100%");
    }
    public BigDecimal price(BigDecimal base) {
        BigDecimal factor = BigDecimal.ONE.subtract(
                BigDecimal.valueOf(percent).movePointLeft(2)); // percent/100
        return base.multiply(factor);
    }
}

record FlatOff(BigDecimal amount) implements PricingStrategy {
    public FlatOff {
        Objects.requireNonNull(amount);
        if (amount.signum() < 0) throw new IllegalArgumentException("amount >= 0");
    }
    public BigDecimal price(BigDecimal base) { return base.subtract(amount); }
}

// Демонстрация
public class StrategyDemo {
    public static void main(String[] args) {
        var base = new BigDecimal("499.90");
        var calc = new PriceCalculator(new NoDiscount());

        System.out.println(calc.checkout(base)); // 499.90

        calc.setStrategy(new PercentOff(20)); // -20%
        System.out.println(calc.checkout(base)); // 399.92

        calc.setStrategy(new FlatOff(new BigDecimal("50")));
        System.out.println(calc.checkout(base)); // 449.90

        // Можно подставить стратегию лямбдой
        calc.setStrategy(p -> p.multiply(new BigDecimal("0.85"))); // -15%
        System.out.println(calc.checkout(base)); // 424.92
    }
}

// Шаблон (Template)
abstract class SyncJob<T> {
    // фиксируем скелет алгоритма
    public final void run() {
        lock();
        try {
            var data = fetch();  // 1) достаём данные
            var prepared = transform(data);// 2) преобразуем
            persist(prepared);   // 3) сохраняем
        } finally {
            unlock();
        }
    }

    // шаги по умолчанию/крючки
    protected void lock()   { System.out.println("lock"); }
    protected void unlock() { System.out.println("unlock"); }
    protected T transform(T data) { return data; } // hook — можно не переопределять

    // обязательные шаги для подклассов
    protected abstract T fetch();
    protected abstract void persist(T prepared);
}

// Конкретные варианты (подклассы меняют шаги, порядок неизменен)
final class UserSyncJob extends SyncJob<List<String>> {
    @Override 
    protected List<String> fetch() {
      return List.of("ivan", "petr");
    }
  
    @Override 
    protected List<String> transform(List<String> d) {
      return d.stream().map(String::toUpperCase).toList();
    }
  
    @Override 
    protected void persist(List<String> users) {
      System.out.println("save users " + users);
    }
}

final class ProductSyncJob extends SyncJob<List<String>> {
    @Override protected List<String> fetch() {
      return List.of("tv", "phone");
    }
  
    @Override protected void persist(List<String> items) {
      System.out.println("save products " + items);
    }
}

// Демонстрация
public class Main {
    public static void main(String[] args) {
        new UserSyncJob().run();    
        // lock -> fetch -> transform -> persist -> unlock
        new ProductSyncJob().run();
        // тот же порядок, другие реализации шагов
    }
}

// Элементы (Element)
sealed interface DocPart permits PlainText, BoldText, Picture {
    void accept(DocVisitor v);
}
record PlainText(String text) implements DocPart {
    public void accept(DocVisitor v){ v.visit(this);}
}
// аналогично
record BoldText  (String text) implements DocPart { (...) }
record Picture   (String alt ) implements DocPart { (...) }

// Посетитель (Visitor)
interface DocVisitor {
    void visit(PlainText t);
    void visit(BoldText t);
    void visit(Picture p);
}

// Операция 1: HTML-рендер (элементы не меняем)
final class HtmlVisitor implements DocVisitor {
    private final StringBuilder out = new StringBuilder();
    
    public void visit(PlainText t){ out.append(t.text()); }
    
    public void visit(BoldText t) {
      out.append("<b>").append(t.text()).append("</b>");
    }
  
    public void visit(Picture p)  {
      out.append("<img alt='").append(p.alt()).append("'/>");
    }
  
    String result(){ return out.toString(); }
}

// Операция 2: статистика
final class StatsVisitor implements DocVisitor {
    int images, chars;
    
    private void add(String s)    { chars += s.length(); }
    public void visit(PlainText t){ add(t.text()); }
    public void visit(BoldText t) { add(t.text()); }
    public void visit(Picture p)  { images++;      }
}

// Демонстрация
public class Main {
    public static void main(String[] args) {
        List<DocPart> doc = List.of(
                new PlainText("Hello "),
                new BoldText("world"),
                new Picture("logo")
        );

        var html  = new HtmlVisitor();
        var stats = new StatsVisitor();

        doc.forEach(p -> p.accept(html));
        doc.forEach(p -> p.accept(stats));

        System.out.println(html.result());
        // Hello <b>world</b><img alt='logo'/>
        System.out.println("chars=" + stats.chars + 
                           ", images=" + stats.images);
        // chars=10, images=1
    }
}