Design patterns

Problem

The method that grows with every promotion

The price in the shop depends on the promotion:

static double finalPrice(double price, String promo) {
    if (promo.equals("student")) {
        return price * 0.9;
    } else if (promo.equals("black friday")) {
        return Math.max(price - 20, 0);
    } else if (promo.equals("loyal customer")) {
        return price * 0.95;
    }
    return price;
}

System.out.printf("€%.2f%n", finalPrice(120, "student"));
System.out.printf("€%.2f%n", finalPrice(120, "black friday"));
System.out.printf("€%.2f%n", finalPrice(120, "none"));

Output

€108.00
€100.00
€120.00

It works. But marketing comes up with a new promotion every month. Each one means a new else if in this method, and often in two more: the one for the invoice and the one for the confirmation email. The method knows about all the promotions at once, and every change touches it. This problem is so common that its solution has a name.

The idea

Design patterns

A design pattern is a proven solution to a problem that comes up in many programs. It is not a library and not code to copy. It is a way to arrange the classes and interfaces that has already been through thousands of projects.

Patterns fall into three groups:

• Creational: how objects are made. For example Singleton (only one object of the class) and Factory Method (something else decides which class to create).
• Structural: how classes and objects are put together into bigger ones. For example Adapter (connects incompatible interfaces) and Composite (a tree of parts that you work with as one whole).
• Behavioral: how objects split the work and talk to each other. For example Strategy (a replaceable rule) and Observer (subscribers to an event).

Why they are worth knowing:

• you do not reinvent a solution that others have already tested;
• the code changes with less risk, because the part that changes is kept separate;
• the names are a shared language. "Put an adapter here" tells a colleague a whole structure in one word.

More precisely, if you are curious

The classic catalog is the 1994 book "Design Patterns" by four authors known as the "Gang of Four" (GoF). It has 23 patterns. Here are the five you will run into most often in Java code. A pattern is not a goal: if one if does the job, you do not need a pattern.

See it

Strategy: a replaceable rule

The discount becomes an interface. The checkout does not know which promotion it is, it only calls 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);
    }
}

The interface is functional, so each discount is a lambda:

Checkout checkout = new Checkout(price -> price);
System.out.printf("No discount: €%.2f%n", checkout.total(120));

checkout.setDiscount(price -> price * 0.9);
System.out.printf("Student: €%.2f%n", checkout.total(120));

checkout.setDiscount(price -> price - 20);
System.out.printf("Black Friday: €%.2f%n", checkout.total(120));

Output

No discount: €120.00
Student: €108.00
Black Friday: €100.00

A new promotion is a new lambda. Checkout does not change. The rule can also be changed while the program is running, with setDiscount.This is Strategy: a family of rules, each behind the same interface, so they are interchangeable. The Comparator you pass to sort is also a strategy: sort knows how to sort, and you say what to sort by.

More precisely, if you are curious

Before lambdas, each strategy was a separate class, and the class that uses it is called the "context" in the books (here Checkout):

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

Checkout checkout = new Checkout(new StudentDiscount());
System.out.printf("Student: €%.2f%n", checkout.total(120));

Output

Student: €108.00

A class is the better choice when the strategy has its own fields or is long. A lambda, when it is one line.

See it

Observer: subscribers to an event

When the stock of a product changes, the website has to show the new count, and the warehouse has to reorder if there are only a few left. Tomorrow it may be an email to customers too. The product should not know about any of them.

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("Phone", 0);
phone.subscribe((name, qty) -> System.out.println("Website: " + name + ", " + qty + " in stock"));
phone.subscribe((name, qty) -> {
    if (qty < 3) {
        System.out.println("Warehouse: reorder " + name);
    }
});

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

Output

Website: Phone, 10 in stock
Website: Phone, 2 in stock
Warehouse: reorder Phone

• Whoever wants to know subscribes with subscribe.
• On a change, the product goes through the list and notifies each subscriber. Who they are and what they do is none of its business.
• If the count has not changed, nobody is bothered.

Product phone = new Product("Phone", 0);
phone.subscribe((name, qty) -> System.out.println("Website: " + name + ", " + qty + " in stock"));
phone.subscribe((name, qty) -> {
    if (qty < 3) {
        System.out.println("Warehouse: reorder " + name);
    }
});

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

Step by step, in words

1. Phone with 0 in stock and an empty listeners list.
2. The website subscribes: the lambda goes into the list.
3. So does the warehouse. The product does not know who they are, only that they can hear stockChanged.
4. The stock becomes 10. The product goes through the list and calls each subscriber in the order they subscribed. The website shows the new count.
5. The warehouse checks 10 < 3: no, so it does nothing.
6. The stock becomes 2. The product goes through the list and calls each subscriber in the order they subscribed. The website shows the new count.
7. The warehouse checks 2 < 3: yes, so it reorders.

This is Observer. The product is the observed object (the subject), and the listeners are the observers. Buttons in graphical programs work exactly like this: "when clicked, call this".

More precisely, if you are curious

• You also need an unsubscribe that removes the listener from the list. A subscriber that nobody removes stays in memory as long as the product does.
• In the old lecture the observed class is called Subject, with the methods attach and notifyAllObservers, and the observer is an abstract class with a method update(). The idea is the same, and the interface allows lambdas.
• The listeners are called one after another in the thread that changed the count. If one of them is slow, all of them wait.

Try it

Who will hear it?

Product is the one from the card before this one.

What will the program print?

Product coffee = new Product("Coffee", 5);
coffee.subscribe((name, qty) -> System.out.println("A: " + qty));
coffee.setQuantity(4);
coffee.setQuantity(4);
coffee.subscribe((name, qty) -> System.out.println("B: " + qty));
coffee.setQuantity(0);

Answer

A: 4
A: 4
A: 0
B: 0

A: 4
A: 0
B: 0

A: 4
B: 4
A: 0
B: 0

A: 4
A: 0

Check

See it

Factory Method: which class to create

The customer has chosen how we notify them: email or SMS. The code that sends should not write new EmailNotification() in ten places, each with its own if.

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

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

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

The choice is in one place, in a factory:

class NotificationFactory {
    public static Notification create(String channel) {
        return switch (channel) {
            case "email" -> new EmailNotification();
            case "sms" -> new SmsNotification();
            default -> throw new IllegalArgumentException("Unknown channel: " + channel);
        };
    }
}

String[][] customers = {
        { "email", "maria@example.com" },
        { "sms", "+359 88 123 4567" },
        { "pigeon", "5 Shipka St." },
};
for (String[] c : customers) {
    try {
        Notification n = NotificationFactory.create(c[0]);
        n.send(c[1], "Your order has been shipped.");
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage());
    }
}

Output

Email to maria@example.com: Your order has been shipped.
SMS to +359 88 123 4567: Your order has been shipped.
Unknown channel: pigeon

The caller says what it wants ("email") and gets a Notification. Only the factory knows exactly which class is behind it. A new channel, for example push, is a new class and a new line in the switch. The sending is not touched.

More precisely, if you are curious

• This is the most common form in practice. Its more precise name is "simple factory". The Factory Method from the GoF book is something else: the parent has an abstract method that creates the object, and the subclasses decide what kind:

abstract class Shop {
    protected abstract Notification createNotification();

    public void confirmOrder(String to) {
        createNotification().send(to, "The order has been received.");
    }
}

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");

Output

Email to maria@example.com: The order has been received.
SMS to +359 88 123 4567: The order has been received.

confirmOrder is written once, in Shop, and does not know what notification it sends.

• In old examples the factory returns null for an unknown kind. Then the caller blows up with a NullPointerException far from the real cause. An exception with a clear message is better.

See it

Singleton: only one object

The application's settings, like the currency, are read once. If every part of the program makes its own settings object, they are read many times and can drift apart.

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

    private AppConfig() {
        System.out.println("Reading the settings...");
    }

    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());

Output

Reading the settings...
true
EUR

• The constructor is private. Nobody outside the class can write new AppConfig().
• The only object is in the static field instance. getInstance() creates it on the first call and then always returns that one.
• "Reading the settings..." is printed once, and a == b is true: there is one object.

This is Singleton.

More precisely, if you are curious

• If two threads call getInstance() at the same moment, two objects may be created. Threads are in the module "Real-world programs".
• The safest Singleton in Java is an enum with one value. An enum is a type with objects listed in advance. Java creates each one exactly once and does not allow 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);

Output

EUR
true

• A Singleton is a global variable for the whole program with a nice name. Anyone can use it from anywhere, so it is hard to test and hard to replace. It is often better to create the object once in main and pass it through the constructor to the ones that use it.

Try it

Find the bug

Order numbers have to be unique, so the counter is a Singleton. But the program gave out the number 1001 twice:

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

Output

1001
1002
1001

Which line in the class is the bug on?

Pick the line with the bug.

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}

Check

See it

Adapter: connects incompatible interfaces

The shop pays through an interface with an amount in euros and a "yes or no" answer. The bank gives you an old library that wants cents and returns an error code. The library is not yours, and you cannot change it.

// The bank's old library. You cannot change it.
class LegacyBankClient {
    // The amount is in cents. Returns 0 on success and an error code otherwise.
    public int charge(long cents, String reference) {
        System.out.println("Bank: " + cents + " cents for " + reference);
        return cents <= 50000 ? 0 : 51;
    }
}

You write a class that looks like what the shop expects, and inside it calls the bank:

// This is what the shop expects.
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));

Output

Bank: 4990 cents for ORDER-1001
true
Bank: 129900 cents for ORDER-1002
false

The adapter translates in both directions: euros into cents and a number into text on the way there, code 0 into true on the way back. The shop does not know there is an old library behind it. If tomorrow you change banks, you write a new adapter, and the shop is not touched.

This is Adapter: like a plug adapter that changes neither the plug nor the wall.

More precisely, if you are curious

The classic example in the books, and in the old lecture, is a media player. AudioPlayer can play only mp3, and an existing class AdvancedMediaPlayer has the methods playVlc and playMp4. MediaAdapter implements the player's interface and forwards to the right method. The structure is the same as here.

Exercise

Patterns in the shop

Solve the tasks in your editor.

1. Discounts as strategies. An interface DiscountStrategy with static methods that return a lambda (an interface can have static methods with a body, just like default ones): none(), percent(double p) and fixed(double amount) (never below €0). A class Cart with a list of prices and a replaceable discount. Add coffee beans (€18.50), honey (€12) and tea (€4.20), and print the total with no discount, with −10%, with −€5 and with −€50.

Output

No discount: €34.70
-10%: €31.23
-€5: €29.70
-€50: €0.00

2. "Notify me when it is in stock". The product keeps a list of customers who are waiting. When the stock goes from 0 to more than 0, it notifies all of them and clears the list, because the notification is one-time. The console has 0 in stock, Maria and Georgi subscribe, then the stock becomes 5, 0 and 3.

Output

Email to Maria: Console is in stock (5 units)
SMS to Georgi: Console is in stock
End

3. A notification factory. Add PushNotification and a factory for the three channels that ignores uppercase and lowercase. Read a number of lines and then lines "channel;address". Send "Your reservation is confirmed." to each address, and for an unknown channel print the exception's message.

Input

4
Email;maria@example.com
sms;+359 88 123 4567
push;Elena's phone
fax;02 123 456

Output

Email to maria@example.com: Your reservation is confirmed.
SMS to +359 88 123 4567: Your reservation is confirmed.
Push to Elena's phone: Your reservation is confirmed.
Unknown channel: fax

4. An old thermometer. A class OldThermometer returns the temperature in Fahrenheit with readFahrenheit(). The new system works with interface TemperatureSensor { double celsius(); }. Write ThermometerAdapter (°C = (°F − 32) × 5 / 9). In a list of sensors, put two old thermometers (71.6 °F and 39.2 °F) through the adapter, and one new sensor as a lambda that returns 21.5 °C.

Output

Office: 22.0 °C
Warehouse: 4.0 °C
Server room: 21.5 °C

More tasks

• Shipping as a strategy. Make a ShippingStrategy with a price for an office, an address and pickup from the store, and put it in the checkout together with the discount.
• A log as a Singleton. A class Logger with getInstance() and a method log(String) that numbers the lines. Check that the numbers continue when you call it from two different methods.
• A price observer. Add subscribers for price changes to the product, and send a notification only when the price drops by at least 10%.

Test

Check yourself

1. What is a design pattern?

A proven, named solution to a problem that keeps coming up: an idea for how to arrange the classesA compiler ruleA ready-made library you add to the project

2. Every new promotion in the shop adds a new else if to the price method. Which pattern helps?

AdapterSingletonStrategy: each discount is a separate object or lambda, and the checkout is told which one to use

3. The product tells the website, the warehouse and the email system when the stock changes, without knowing who they are. Which pattern is it?

Factory MethodSingletonObserver

4. What does Singleton prevent?

The fields being changedA second object being created: the constructor is private, and the only object is obtained with getInstance()The class being extended

5. You have an old class that returns the temperature in Fahrenheit, and the program expects an interface with degrees Celsius. What do you do?

Rewrite the old classAdapter: a new class implements the interface and calls the old one inside, converting the valuesFactory Method

Check

Start the lesson over