„Pattern“ has been defined as „an idea that has been useful in one practical context and will probably be useful in others.“

1. Name - Aliases, classifications

2. Motivation and problem statement

3. Context

4. Solution

   $-$ Structure

   $-$ Participants

   $-$ Collaboration

   $-$ Consequences

   $-$ Implementation

   $-$ Examples

Common vocabulary → helps manage complex systems, better communication

Capture knowledge and make it more widely available

Combination of patterns

Reusability, adaptability, extendability → Minimizes development time and costs

Patterns need to be adapted to the code context

Only indirect code reuse

deceptively simple

Teams may suffer from pattern overload

1. Architectural Patterns

   – Structure of software systems – Subsystems, dependencies, communication

2. Design Patterns

   – level of classes – Snippets focus on low-level details, Programming language specific

3. ProtoPatterns

   – Particular case

4. Antipatterns

   – Commonly used but should be avoided

Similar problems that recur with variations in different contexts

Patterns can be an overkill if solution is simple linear set of instructions

Separate description and concrete implementation

defines the signature operations of an entity

implementations can be added / changed easily afterwards

should be stable - in comparison to implementation

Class needs additional functionality

Outsource functionality into third class and use its instance via delegation

• Example 1

  

  Solution without inheritance:

  Notification-Service gets an instance of the object that should get called.

  

• Example 2

  class A {
  void foo() {
  print("a.foo");
  }
  }class B {
  private delegate A a; // delegation linkpublic B(A a) {
  this.a = a;
  }void foo() {
  a.foo(); // call foo() on the a-instance
  }
  }

  a = new A();
  b = new B(a); // establish delegation between two objects

Object instance should be immutable

Because several threads are accessing same object but object properties should be configurable

1. Initialize variables in constructor

2. Provide only read access with Getter-Methods getName(), getDate()

Only one object instance should exist:

• Example

  public class Person {
  private final Logger LOG = LoggerFactory.getLogger(Person.class);
  Logger getLogger() {
  return LOG;
  }
  }

  In this case LOG is the same object even without static due to the way the LoggerFactory works.

Object creation & configuration is complex

Initialization of additional sub-instances required

• Example

  interface Product { float getPrice(); }public class Milk implements Product {
  final float price;
  public Milk(final float price) { this.price = price; } //constructor
  public float getPrice() { return price; } //getter
  }public class Sugar implements Product {
  final float price;
  public Sugar(final float price) { this.price = price; } //constructor
  public float getPrice () { return price; } //getter
  }public class Product Factory {
  public static Product createProduct(String what){
  //When sugar is requested, we return sugar:
  if (what.equals("Sugar")) { return new Sugar(1.49F) ; }
  // When milk is needed, we return milk:
  else if (what.equals("Milk")) { return new Milk(0.99F); }
  // Otherwise return at least sugar
  else { return new Sugar(1.49F); }
  }
  }

  

Achieving higher abstraction by grouping individual factories with a common theme

A group of individual factories that have a common theme

Two hierarchies → abstract AbstractFactory class provides interface

Client only knows abstract interface → Family may grow independently of the client

Need simplified access to a complex subsystem

Provides an abstracted interface of a subsystem

• Example

  public class SimpleMail {
  public static int sendMail(String address, String subject, String body) {
  int status = 0;
  ... //Complex mail sending operation
  return status;
  }
  }

Need to integrate incompatible external functionality

Translates (data transformation) into a compatible interface

Need to integrate further actions before intended method call

Extends concept of the delegation pattern

Implements interface and acts as a representative of the „original“ implementation

Used in: security, logging, caching

Need to react to state changes in an object

in case of changes of the instance‘s state execute specific action(s) – e.g., notification of instances interested in change

Need to extend object functionality during runtime (inheritance not possible during runtime)

Dynamically add new functionality to an existing object

• Example

  Cake cake = new ChocolateCake();NutsInCake nic = new NutsInCake(cake) ;
  nic.setAmount(15) ;
  nic.setType("hazelnut") ;CandleCake cc = new CandleCake (nic) ;
  cc.setCandles(13);
  cake = (Cake) cc;
  cake.bake();

  VisualComponent vc = new ScrollBar( new Border( new TextEditor() ));
  vc.draw();

  Stream s = new FileStream(filename);
  Stream s = new CompressingStream( new BufferedStream(new FileStream(filename) ));

Need to change object behavior based on current state

Allow an object to update its behavior when its internal state changes

(internal state gets changed with a setState() method)

Dynamically add new algorithms → context chooses algorithm to use

• Example

  class NotificationManager {
  public enum NotificationMethod {SMS, EMAIL};
  private List<Person> members;
  public void addMember(Person person, NotificationMethod notificationPref){
  members.add(person);
  INotification notification;
  if (notificationPref == NotificationMethod.SMS)
  notification = new Sms();
  else
  notification = new Email();
  notification.setPerson(person) ;
  person.setNotificationPreference(notification);
  }public void sendNotifications (String message)
  for (Person p : members)
  p.sendMessage(message);
  }
  }

  

Improve loose coupling between a series of processing logic