Object-Oriented Design Patterns

Why do we need design patterns?

The Classical Book

Erich Gamma et al., Design Patterns: Elements of Reusable Object-Oriented Software Published in 1994 A classical book on software design (although partially outdated) Patterns from this book are referred to as GoF patterns ("Gang of Four" is 4 authors of this book).

Some other sources

Types of design patterns

What we will cover

Superobject antipattern

Composite: Divide and conquer!

Composite: Divide and conquer!

A classic example

A classic example

Draw method of a diagram

class Diagram implements Element {
    void draw() {
        for (Element e: elements) {
            e.draw();
        }
    }
}

A generic decomposition of a typical application

Your own application from Project 1 & 2

Composite takeaways

Now let’s consider the following example

A naïve approach: "Let the objects create what they need themselves"

public class A { private final B b = new B(); private final C c = new C(); } public class B { private final D d = new D(); } public class C { private final D d = ???; //OOPS! } It is impossible to make a single instance of D shared between B and C!

How do we test?

If A creates B and C, how can we test A separately? How do we substitute B and C with mock implementations? This is impossible if we do it like this: public class A { private final B b = new B(...); private final C c = new C(...); }

Let’s make external dependencies "pluggable"

class A { private final B b; private final C C; public A(B b, C c) { this.b = b; this.c = c; }} class B { private final D d; public B(D d){ this.d = d; }} class C { private final D d; public C(D d){ this.d = d; }}

Now testing is possible!

class ATest {
    //Use mocks instead of "real" dependencies
    A objectUnderTest = new A(
            Mockito.mock(B.class),
            Mockito.mock(C.class)
    );


    @Test
    // setup mocks and test as needed
}

Factory Method

/*Move all the "wiring" from classes to the factory method*/ public class ApplicationFactory { public static A createA() { D d = new D(); B b = new B(d); C c = new C(d); A a = new A(b,c); return a; } }

How it’s done in DI ("dependency injection") frameworks

@Component class A { private final B b; private final C C; public A(B b, C c) { this.b = b; this.c = c; }} @Component class B { private final D d; public B(D d) { this.d = d; }} @Component class C { private final D d; public C(D d) { this.d = d; }} A a = context.getBean(A.class);

Factory method takeaways

Strategy: incapsulating a behaviour into an object

In Java, Strategy is often a lambda or a method reference

class Calculator {
    private final Function<Integer, Integer> taxStrategy;
    Calculator(Function<Integer, Integer> taxCalculationStrategy) {
        this.taxStrategy = taxCalculationStrategy;
    }
    Integer calculate(Integer amount) {
        Integer surcharged = amount + 15;
        return surcharged + taxStrategy.apply(surcharged);
    }
    public static void main(String[] args) {
        System.out.println(new Calculator(
                //Flat 20% strategy
                amount -> amount / 5
        ).calculate(100));
    }
}

Comparator: another example of a strategy

Collections.sort(people,
  Comparator
    .comparing(Person::getLastName)
    .thenComparing(Person::getFirstName));
);

Strategy takeaways

Command: Undo and Redo

Command interface

Command takeaways

Visitor Pattern: A Practical Problem

TAKE…​	…​TRANSFORM INTO
	Code Text Visual representation Result of calculation (number, vector, matrix…​)

A very important specific case

Naive approach: add methods to the class?

Program program = Program.parse(....);
//These are methods of class Program
program.verify();
program.compile();
program.execute();

Separation of responisibilities: Visitor pattern

Classes and their methods

Order of calling

What is the simplest visitor pattern implementation?

//This is the data structure
Collection<T> collection = ...;

//Consumer<? super T> parameter is the visitor
collection.forEach (element -> {
  //do anything with each element
})

Example: Let’s implement a simple language

PrimaryTerm variable numeric literal UnaryOperation unary - square root (sqrt) BinaryOperation +, - (lower precedence) *, / (higher precedence) Parentheses (, )

Quadratic equation root formula

(-b - sqrt(b * b - 4 * a * c)) / (2 * a)

Let’s do two things

Visualize	Calculate
	Let’s solve \(x^2 + 2024x + 2023 = 0\) (Evaluate the formula for \(a = 1, b = 2024, c = 2023\)).

Evaluating the formula

Evaluating the formula

Evaluating the formula

Evaluating the formula

Evaluating the formula

Warning

/* It is better to have an abstract draw() method on Element class */
switch (element) {
    case Actor actor -> drawActor(actor);
    case Arrow arrow -> drawArrow(arrow);
    case UseCase useCase -> drawUseCase(useCase);
}

Takeaways (for Visitor)