• Creational Pattern

  1. Factory Pattern
  2. Abstract Factory Pattern
  3. Singleton Pattern
  • Structural Pattern

  1. Adapter Pattern
  2. Bridge Pattern
  3. Composite Pattern
  4. Proxy Pattern
  • Behavioral Pattern

  1. Chain of Responsibility Pattern
  2. Command Pattern
  3. Observer Pattern
  4. State Pattern
  5. Strategy Pattern

The kind of discussion may be like the following:

Bridge Pattern/Handle-Body :

  1. Motivation - Why is this necessary to separate the interface from its implementation

  2. How does the separation of interface and its implementation solve the issue of extending, modifying and reusing abstractions and implementation separately


  1. To avoid permanent binding between an abstraction and its implementation. This might be the case when we want to switch the implementation at run time

  2. both the abstractions and their implementations should be extensible by subclassing. this pattern lets us combine the different abstractions and implementations and extend them independently.

  3. if we change the implementation, the client code of the abstraction wont be affected, in the sense the client code will not be recompiled

  4. the implementation of the abstraction will be completely hidden from the client code


  1. How an interface is attached with its implementation through Interface constructor. the correct implementation can be passed as a parameter in the concrete abstraction constructor

  2. How a parameterized Factory implementation can be placed in between the Interface and its implementation to solve this issue

  3. How changes in the implementation code won't affect the client code vis-a-vis compilation

  4. Example

Somenath Mukhopadhyay