Шаблони за дизайн

Проблем

Методът, който расте с всяка промоция

Цената в магазина зависи от промоцията:

static double finalPrice(double price, String promo) {
    if (promo.equals("студент")) {
        return price * 0.9;
    } else if (promo.equals("черен петък")) {
        return Math.max(price - 20, 0);
    } else if (promo.equals("лоялен клиент")) {
        return price * 0.95;
    }
    return price;
}

System.out.printf("%.2f €%n", finalPrice(120, "студент"));
System.out.printf("%.2f €%n", finalPrice(120, "черен петък"));
System.out.printf("%.2f €%n", finalPrice(120, "без"));

Изход

108.00 €
100.00 €
120.00 €

Работи. Но маркетингът измисля нова промоция всеки месец. Всяка значи нов else if в този метод, а често и в още два: в този за фактурата и в този за имейла с потвърждение. Методът знае за всички промоции наведнъж и всяка промяна го пипа. Тази задача е толкова честа, че решението ѝ си има име.

Идеята

Шаблон за дизайн

Шаблон за дизайн (на английски design pattern) е проверено решение на задача, която се повтаря в много програми. Не е библиотека и не е код за копиране. Той е начин да подредиш класовете и интерфейсите, който вече е минал през хиляди проекти.

Шаблоните се делят на три групи:

• Създаващи: как се правят обекти. Например Singleton (само един обект от класа) и Factory Method (кой клас да се създаде решава друг).
• Структурни: как класове и обекти се сглобяват в по-големи. Например Adapter (свързва несъвместими интерфейси) и Composite (дърво от части, с които се работи като с едно цяло).
• Поведенчески: как обектите си разпределят работата и си говорят. Например Strategy (сменяемо правило) и Observer (абонати за събитие).

Защо си струва да ги знаеш:

• не измисляш наново решение, което другите вече са изпитали;
• кодът се променя с по-малко риск, защото променливата част е отделена;
• имената са общ език. „Тук сложи адаптер“ казва на колегата цяла структура с една дума.

По-точно, за любопитните

Класическият каталог е книгата „Design Patterns“ от 1994 г. на четирима автори, наричани „бандата на четиримата“ (Gang of Four, GoF). В нея има 23 шаблона. Тук са петте, които ще срещаш най-често в Java код. Шаблонът не е цел: ако един if върши работа, шаблон не трябва.

Виж го

Strategy: сменяемо правило

Отстъпката става интерфейс. Касата не знае коя е промоцията, а само вика apply:

interface DiscountStrategy {
    double apply(double price);
}

class Checkout {
    private DiscountStrategy discount;

    public Checkout(DiscountStrategy discount) {
        this.discount = discount;
    }

    public void setDiscount(DiscountStrategy discount) {
        this.discount = discount;
    }

    public double total(double price) {
        return Math.max(discount.apply(price), 0);
    }
}

Интерфейсът е функционален, затова всяка отстъпка е ламбда:

Checkout checkout = new Checkout(price -> price);
System.out.printf("Без отстъпка: %.2f €%n", checkout.total(120));

checkout.setDiscount(price -> price * 0.9);
System.out.printf("Студент: %.2f €%n", checkout.total(120));

checkout.setDiscount(price -> price - 20);
System.out.printf("Черен петък: %.2f €%n", checkout.total(120));

Изход

Без отстъпка: 120.00 €
Студент: 108.00 €
Черен петък: 100.00 €

Нова промоция е нова ламбда. Checkout не се променя. Правилото може да се смени и докато програмата работи, със setDiscount.Това е Strategy: семейство от правила, всяко зад един и същ интерфейс, така че да са взаимозаменяеми. Comparator, който подаваш на sort, е също стратегия: sort знае как се подрежда, а ти казваш по какво.

По-точно, за любопитните

Преди ламбдите всяка стратегия беше отделен клас, а класът, който я ползва, в книгите се казва „контекст“ (тук Checkout):

class StudentDiscount implements DiscountStrategy {
    @Override
    public double apply(double price) {
        return price * 0.9;
    }
}

Checkout checkout = new Checkout(new StudentDiscount());
System.out.printf("Студент: %.2f €%n", checkout.total(120));

Изход

Студент: 108.00 €

Клас е по-добрият избор, когато стратегията има свои полета или е дълга. Ламбда, когато е един ред.

Виж го

Observer: абонати за събитие

Когато наличността на продукт се промени, сайтът трябва да покаже новата бройка, а складът да поръча още, ако бройките са малко. Утре може и имейл до клиентите. Продуктът не трябва да знае за никого от тях.

interface StockListener {
    void stockChanged(String product, int quantity);
}

class Product {
    private String name;
    private int quantity;
    private List<StockListener> listeners = new ArrayList<>();

    public Product(String name, int quantity) {
        this.name = name;
        this.quantity = quantity;
    }

    public void subscribe(StockListener listener) {
        listeners.add(listener);
    }

    public void setQuantity(int quantity) {
        if (quantity == this.quantity) {
            return;
        }
        this.quantity = quantity;
        for (StockListener listener : listeners) {
            listener.stockChanged(name, quantity);
        }
    }
}

Product phone = new Product("Телефон", 0);
phone.subscribe((name, qty) -> System.out.println("Сайт: " + name + ", наличност " + qty + " бр."));
phone.subscribe((name, qty) -> {
    if (qty < 3) {
        System.out.println("Склад: поръчай още " + name);
    }
});

phone.setQuantity(10);
phone.setQuantity(2);

Изход

Сайт: Телефон, наличност 10 бр.
Сайт: Телефон, наличност 2 бр.
Склад: поръчай още Телефон

• Който иска да знае, се абонира с subscribe.
• При промяна продуктът обикаля списъка и уведомява всеки абонат. Кои са те и какво правят, не го интересува.
• Ако бройката не се е променила, никой не се безпокои.

Product phone = new Product("Телефон", 0);
phone.subscribe((name, qty) -> System.out.println("Сайт: " + name + ", наличност " + qty + " бр."));
phone.subscribe((name, qty) -> {
    if (qty < 3) {
        System.out.println("Склад: поръчай още " + name);
    }
});

phone.setQuantity(10);
phone.setQuantity(2);

Стъпка по стъпка, с думи

1. Телефон с наличност 0 и празен списък listeners.
2. Сайтът се абонира: ламбдата му влиза в списъка.
3. Складът също. Продуктът не знае кои са, само че могат да чуят stockChanged.
4. Наличността става 10. Продуктът обикаля списъка и вика всеки абонат по реда на абонирането. Сайтът показва новата бройка.
5. Складът проверява 10 < 3: не, и не прави нищо.
6. Наличността става 2. Продуктът обикаля списъка и вика всеки абонат по реда на абонирането. Сайтът показва новата бройка.
7. Складът проверява 2 < 3: да, и поръчва още.

Това е Observer (наблюдател). Продуктът е наблюдаваният обект, а слушателите са наблюдатели. Бутоните в графичните програми работят точно така: „при натискане извикай това“.

По-точно, за любопитните

• Нужен е и unsubscribe, който маха слушателя от списъка. Абонат, когото никой не маха, живее в паметта, докато живее продуктът.
• В старата лекция наблюдаваният клас се казва Subject, с методи attach и notifyAllObservers, а наблюдателят е абстрактен клас с метод update(). Идеята е същата, а интерфейсът позволява ламбди.
• Слушателите се викат един след друг в нишката, която е сменила бройката. Ако един от тях е бавен, чакат всички.

Пробвай

Кой ще чуе?

Product е този от картата преди тази.

Какво ще отпечата програмата?

Product coffee = new Product("Кафе", 5);
coffee.subscribe((name, qty) -> System.out.println("А: " + qty));
coffee.setQuantity(4);
coffee.setQuantity(4);
coffee.subscribe((name, qty) -> System.out.println("Б: " + qty));
coffee.setQuantity(0);

Отговор

А: 4
А: 0

А: 4
А: 0
Б: 0

А: 4
Б: 4
А: 0
Б: 0

А: 4
А: 4
А: 0
Б: 0

Провери

Виж го

Factory Method: кой клас да се създаде

Клиентът е избрал как да го уведомяваме: имейл или SMS. Кодът, който изпраща, не трябва да пише new EmailNotification() на десет места, всяко със своя if.

interface Notification {
    void send(String to, String text);
}

class EmailNotification implements Notification {
    @Override
    public void send(String to, String text) {
        System.out.println("Имейл до " + to + ": " + text);
    }
}

class SmsNotification implements Notification {
    @Override
    public void send(String to, String text) {
        System.out.println("SMS до " + to + ": " + text);
    }
}

Изборът е на едно място, във фабрика:

class NotificationFactory {
    public static Notification create(String channel) {
        return switch (channel) {
            case "email" -> new EmailNotification();
            case "sms" -> new SmsNotification();
            default -> throw new IllegalArgumentException("Непознат канал: " + channel);
        };
    }
}

String[][] customers = {
        { "email", "maria@example.com" },
        { "sms", "+359 88 123 4567" },
        { "гълъб", "ул. Шипка 5" },
};
for (String[] c : customers) {
    try {
        Notification n = NotificationFactory.create(c[0]);
        n.send(c[1], "Поръчката ти е изпратена.");
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage());
    }
}

Изход

Имейл до maria@example.com: Поръчката ти е изпратена.
SMS до +359 88 123 4567: Поръчката ти е изпратена.
Непознат канал: гълъб

Викащият казва какво иска („email“) и получава Notification. Кой точно клас стои отзад, знае само фабриката. Нов канал, например push, е нов клас и нов ред в switch. Изпращането не се пипа.

По-точно, за любопитните

• Това е най-честата форма в практиката. По-точното ѝ име е „проста фабрика“. Factory Method от книгата на GoF е друго: родителят има абстрактен метод, който създава обекта, а наследниците решават какъв:

abstract class Shop {
    protected abstract Notification createNotification();

    public void confirmOrder(String to) {
        createNotification().send(to, "Поръчката е приета.");
    }
}

class OnlineShop extends Shop {
    @Override
    protected Notification createNotification() {
        return new EmailNotification();
    }
}

class PhoneShop extends Shop {
    @Override
    protected Notification createNotification() {
        return new SmsNotification();
    }
}

new OnlineShop().confirmOrder("maria@example.com");
new PhoneShop().confirmOrder("+359 88 123 4567");

Изход

Имейл до maria@example.com: Поръчката е приета.
SMS до +359 88 123 4567: Поръчката е приета.

confirmOrder е написан веднъж, в Shop, и не знае какво уведомление праща.

• В стари примери фабриката връща null за непознат вид. Тогава викащият гърми с NullPointerException далеч от истинската причина. Изключение с ясно съобщение е по-добре.

Виж го

Singleton: само един обект

Настройките на приложението, като валутата, се четат веднъж. Ако всяка част на програмата прави свой обект с настройки, те се четат много пъти и може да се разминат.

class AppConfig {
    private static AppConfig instance;
    private String currency = "EUR";

    private AppConfig() {
        System.out.println("Чета настройките...");
    }

    public static AppConfig getInstance() {
        if (instance == null) {
            instance = new AppConfig();
        }
        return instance;
    }

    public String getCurrency() {
        return currency;
    }
}

AppConfig a = AppConfig.getInstance();
AppConfig b = AppConfig.getInstance();
System.out.println(a == b);
System.out.println(b.getCurrency());

Изход

Чета настройките...
true
EUR

• Конструкторът е private. Никой извън класа не може да напише new AppConfig().
• Единственият обект е в статичното поле instance. getInstance() го създава при първото извикване и после връща все него.
• „Чета настройките...“ се отпечатва веднъж, а a == b е true: обектът е един.

Това е Singleton.

По-точно, за любопитните

• Ако две нишки извикат getInstance() в един и същи момент, може да се създадат два обекта. За нишките е модул „Програми в истинския свят“.
• Най-сигурният Singleton в Java е enum с една стойност. enum е тип с предварително изброени обекти. Java създава всеки точно веднъж и не позволява new:

enum Settings {
    INSTANCE;

    private String currency = "EUR";

    public String getCurrency() {
        return currency;
    }
}

System.out.println(Settings.INSTANCE.getCurrency());
System.out.println(Settings.INSTANCE == Settings.INSTANCE);

Изход

EUR
true

• Singleton е обща променлива за цялата програма с хубаво име. Всеки може да го ползва отвсякъде, затова е трудно да се тества и да се смени. Често е по-добре обектът да се създаде веднъж в main и да се подаде на тези, които го ползват, през конструктора.

Пробвай

Намери грешката

Номерата на поръчките трябва да са уникални, затова броячът е Singleton. Програмата обаче даде номер 1001 два пъти:

System.out.println(OrderNumbers.getInstance().nextNumber());
System.out.println(OrderNumbers.getInstance().nextNumber());
System.out.println(new OrderNumbers().nextNumber());

Изход

1001
1002
1001

На кой ред в класа е грешката?

Избери реда с грешката.

1class OrderNumbers {2 private static OrderNumbers instance;3 private int next = 1001;45 public OrderNumbers() {6 }78 public static OrderNumbers getInstance() {9 if (instance == null) {10 instance = new OrderNumbers();11 }12 return instance;13 }1415 public int nextNumber() {16 return next++;17 }18}

Провери

Виж го

Adapter: свързва несъвместими интерфейси

Магазинът плаща през интерфейс със сума в евро и отговор „да или не“. Банката дава стара библиотека, която иска центове и връща код на грешка. Библиотеката не е твоя и не може да я промениш.

// Стара библиотека на банката. Не можеш да я променяш.
class LegacyBankClient {
    // Сумата е в центове. Връща 0 при успех и код на грешка иначе.
    public int charge(long cents, String reference) {
        System.out.println("Банка: " + cents + " цента по " + reference);
        return cents <= 50000 ? 0 : 51;
    }
}

Пишеш клас, който изглежда като това, което магазинът очаква, а вътре вика банката:

// Това очаква магазинът.
interface PaymentGateway {
    boolean pay(String orderId, double amountEur);
}

class BankAdapter implements PaymentGateway {
    private LegacyBankClient bank;

    public BankAdapter(LegacyBankClient bank) {
        this.bank = bank;
    }

    @Override
    public boolean pay(String orderId, double amountEur) {
        long cents = Math.round(amountEur * 100);
        return bank.charge(cents, "ORDER-" + orderId) == 0;
    }
}

PaymentGateway gateway = new BankAdapter(new LegacyBankClient());
System.out.println(gateway.pay("1001", 49.90));
System.out.println(gateway.pay("1002", 1299.00));

Изход

Банка: 4990 цента по ORDER-1001
true
Банка: 129900 цента по ORDER-1002
false

Адаптерът превежда в двете посоки: евро в центове и номер в текст по пътя натам, код 0 в true по пътя обратно. Магазинът не знае, че отзад е стара библиотека. Ако утре смениш банката, пишеш нов адаптер, а магазинът не се пипа.

Това е Adapter: като преходник за контакт, който не променя нито щепсела, нито стената.

По-точно, за любопитните

Класическият пример в книгите, и в старата лекция, е медиен плейър. AudioPlayer може да пуска само mp3, а съществуващ клас AdvancedMediaPlayer има методи playVlc и playMp4. MediaAdapter имплементира интерфейса на плейъра и препраща към правилния метод. Структурата е същата като тук.

Упражнение

Шаблоните в магазина

Реши задачите в редактора си.

1. Отстъпки като стратегии. Интерфейс DiscountStrategy със статични методи, които връщат ламбда (интерфейсът може да има static методи с тяло, както и default): none(), percent(double p) и fixed(double amount) (никога под 0 €). Клас Cart със списък цени и сменяема отстъпка. Добави кафе на зърна (18,50 €), мед (12 €) и чай (4,20 €) и отпечатай сумата без отстъпка, с −10%, с −5 € и с −50 €.

Изход

Без отстъпка: 34.70 €
-10%: 31.23 €
-5 €: 29.70 €
-50 €: 0.00 €

2. „Уведоми ме, когато е налично“. Продуктът пази списък с клиенти, които чакат. Когато наличността стане от 0 повече от 0, той уведомява всички и изчиства списъка, защото известието е еднократно. Конзолата е с 0 бройки, Мария и Георги се абонират, после наличността става 5, 0 и 3.

Изход

Имейл до Мария: Конзола е налична (5 бр.)
SMS до Георги: Конзола е налична
Край

3. Фабрика за известия. Добави PushNotification и фабрика за трите канала, която не гледа главни и малки букви. Прочети брой редове и после редове „канал;адрес“. На всеки адрес прати „Резервацията ти е потвърдена.“, а за непознат канал отпечатай съобщението на изключението.

Вход

4
Email;maria@example.com
sms;+359 88 123 4567
push;телефонът на Елена
факс;02 123 456

Изход

Имейл до maria@example.com: Резервацията ти е потвърдена.
SMS до +359 88 123 4567: Резервацията ти е потвърдена.
Push до телефонът на Елена: Резервацията ти е потвърдена.
Непознат канал: факс

4. Стар термометър. Клас OldThermometer връща температурата във Фаренхайт с readFahrenheit(). Новата система работи с interface TemperatureSensor { double celsius(); }. Напиши ThermometerAdapter (°C = (°F − 32) × 5 / 9). В списък със сензори сложи два стари термометъра (71,6 °F и 39,2 °F) през адаптера и един нов сензор като ламбда, който връща 21,5 °C.

Изход

Офис: 22.0 °C
Склад: 4.0 °C
Сървърна: 21.5 °C

Още задачи

• Доставка като стратегия. Направи ShippingStrategy с цена за офис, адрес и вземане от магазина и я сложи в касата заедно с отстъпката.
• Дневник като Singleton. Клас Logger с getInstance() и метод log(String), който номерира редовете. Провери, че номерата продължават, когато го викаш от два различни метода.
• Наблюдател за цена. Към продукта добави абонати за промяна на цената и прати известие само когато цената падне с поне 10%.

Тест

Провери се

1. Какво е шаблон за дизайн?

Готова библиотека, която се добавя в проектаПравило на компилатораПроверено и назовано решение на задача, която се повтаря: идея за това как да се подредят класовете

2. Всяка нова промоция в магазина добавя нов else if в метода за цена. Кой шаблон помага?

Strategy: всяка отстъпка е отделен обект или ламбда, а касата получава коя да ползваAdapterSingleton

3. Продуктът казва на сайта, склада и имейл системата, когато наличността се промени, без да знае кои са те. Кой е шаблонът?

SingletonFactory MethodObserver

4. Какво пази Singleton да не стане?

Полетата да се променятКласът да се наследиДа се създаде втори обект: конструкторът е private, а единственият обект се взима с getInstance()

5. Имаш стар клас, който връща температурата във Фаренхайт, а програмата очаква интерфейс с градуси по Целзий. Какво правиш?

Пренаписваш стария класFactory MethodAdapter: нов клас имплементира интерфейса и вътре вика стария, като превръща стойностите

Провери

Започни урока отначало