Self Study

As you read through the resources below try to answer the following questions:

• In a sentence or two, summarise what is meant by a software design pattern.
• Are design patterns limited to the field of software engineering? Where else might you see them?
• How do design patterns simplify software development? Think about readability, communication, testability maintainability etc (note these categories of things to consider should be pretty familiar by now!)
• How can design patterns be misused and what are some potential downsides arising from misuse?
• What are some key factors to consider when deciding whether or not to use a design pattern?

Resources

• Refactoring Guru has some really good design patterns content - Read through the overview, history, benefits and criticisms sections

Exercise

Reflections

Think about the following questions, make notes and be prepared to talk through your thoughts in the workshop.

• In the above example, why did you pick your 3 patterns? Were they easiest to understand / clearly beneficial / you’ve already used them / some other reason(s)?
• What might this tell you about those patterns? e.g. does a pattern being easier to understand mean it may deliver greater value than a more complex pattern? No right or wrong answers here!
• What examples of software patterns have you seen already, either in this Java course or in other software development?
• Based on what you’ve seen so far, what do you think are the main benefits of design patterns? Why?
• And what are the main potential drawbacks?
• Can you think of a piece of software you’ve written in the past where using a design pattern may have improved it?

Self Study

As you read through the resources below try to answer the following questions:

• What is a static factory and why is it useful?
• When is it not worth using a static factory? Why?
• What are the key features of the factory method pattern? What problems does it solve? Think about: loose coupling (relates back to the last sprint on interfaces!), testability etc, especially for large codebases where a piece of functionality may be used by lots of teams beyond the one that wrote it.
• Can you think of any code you’ve seen in other sprints that may benefit from use of the factory method pattern? Why?
• How does the abstract factory pattern differ from the factory method pattern? When would you use one over the other? Do they have any similarities?
• Can you think of any downsides to using the factory pattern or abstract factory pattern? Give an example of a specific situation when using either factory pattern would not be appropriate

Resources

• Factory Comparison - ‘Factory’ is a very overloaded term and can refer to lots of similar sounding concepts and patterns, all of which are worth familiarizing yourself with
• Static factories - not a factory pattern as such, but still a useful technique to be familiar with!
• Simple factories - more like a static factory than either of the factory patterns
• The factory method pattern
• The abstract factory pattern

public class NotificationService {
  public void send(String type, String message) {
      if (type.equals("EMAIL")) {
          EmailNotification notification = new EmailNotification();
          notification.send(message);
      } else if (type.equals("SMS")) {
          SMSNotification notification = new SMSNotification();
          notification.send(message);
      }
      // Adding new notification type requires modifying this class
  }
}

Reflections

Think about the following questions, make notes and be prepared to talk through your thoughts in the workshop.

• Was adding the requirement to support MongoDB easier or harder to implement when the factory pattern was already in play? Why?
  • Do the team implementing the MongoDB requirement need to know about the generic database initialising code?
  • Do they need to coordinate with the team that owns the core db initialisation code?
• What about if we wanted to de-support Oracle - what would we need to change? (just think about this, no need to implement)
• What are the key factors to consider when deciding to use the factory method pattern vs the abstract factory pattern? Does one lead to the other?
  • What do the terms YAGNI and KISS mean? (If you’ve not seen them before, have a look online.) How do they apply here?
• What are the main benefits the factory pattern delivers?
  • Are there any drawbacks?

Self Study

As you read through the resources below try to answer the following questions:

• What is mean by the term ‘immutable’ and why is it desirable to have immutable classes in Java?
• Can a class have more than one constructor? Are there any constraints - can you think of an example of two constructors for a class that would not be valid?
• What problems can having either multiple, similar constructors, or constructors with lots of parameters cause?
• How does the builder pattern help to solve these problems?
• What do the terms ‘fluid interface’ and ‘method chaining’ mean?
• Are there any downsides to using the builder pattern? When is it not appropriate to use?

Resources

• CodeGuru provides a good overview of the pattern

Exercises

public class Product {
    private String id;
    private String name;
    private double price;
    private String description;
    private String category;
    private boolean onOffer; 
    
    public Product(String id, String name, double price) { }
    public Product(String id, String name, double price, String description) { }
  
}

Reflections

Think about the following questions, make notes and be prepared to talk through your thoughts in the workshop.

• What are the main advantages and potential disadvantages of the builder pattern?
  • Think of an example where the builder pattern would not be appropriate
• Is there a factory alternative that may be used in some instances for classes with several similar constructors?
  • When would you prefer this to the builder pattern?
• What happens if you forget a required parameter in a builder built class?
• Why should the fields be final and what benefits does this bring?
• Bonus: In the example above we store a monetary amount as a double - what are some potential problems with this? In general is there a preferred approach for modelling money in Java?
  • Similarly, can you think of a more appropriate type to model the product category?