Search

Design Patterns (TID)


  • The pattern is an organised way of solving some specific class of problems.
  • These patterns come in to the picture at analysis and high-level-design phase.
  • The first step of applying one pattern to the code base is first to understand the find the vector of change in the code base.
  • Next step is to isolate the things that are subject to change form the things that are not.
  • That is adding a layer of abstraction to the code.
  • The goal of design patterns is isolating the changes in your code.
  • Understand Inheritance and Composition as a solution to a specific class of problems.
    • Inheritance: - It allows you to express differences in behavior (that's the thing that changes) in objects that all have the same interface (that's what stays the same).
    • Composition: - Composition can also be considered a pattern, since it allows you to change—dynamically or statically—the objects that implement your class, and thus the way that class works.
  • Some principles of designing the code:
    • Principle of least astonishment
    • Make common things easy and rare things possible
    • Consistency: -
      the more random rules you pile onto the programmer, rules that have nothing to do with solving the problem at hand, the slower the programmer can produce.
    • Law of Demeter: - "Don't talk to strangers." An object should only reference itself, its attributes, and the arguments of its methods.
    • Make the solution to be the most Simple.
    • One abstraction per class, one class per abstraction. Might also be called Isomorphism.
    • Independence or Orthogonality. Express independent ideas independently. This complements Separation, Encapsulation and Variation, and is part of the Low-Coupling-High-Cohesion message.
    • Once and once only: Avoid duplication of logic and structure where the duplication is not accidental, ie where both pieces of code express the same intent for the same reason.
  • Classifying Patterns
    • Creational: - how an object can be created. This often involves isolating the details of object creation so your code isn't dependent on what types of objects there are and thus doesn't have to be changed when you add a new type of object. The aforementioned Singleton is classified as a creational pattern, and later in this book you'll see examples of Factory Method and Prototype.
    • Structural: designing objects to satisfy particular project constraints. These works with the way objects are connected with other objects to ensure that changes in the system don't require changes to those connections.
    • Behavioral: objects that handle particular types of actions within a program. These encapsulate processes that you want to perform, such as interpreting a language, fulfilling a request, moving through a sequence (as in an iterator), or implementing an algorithm. This book contains examples of the Observer and the Visitor patterns.
  • It is required to classify the patterns in those categories so that we come across a specific type of problem then they help us to provide a solution.
  • Some basics to be kept in mind during coding.
    • Use a Class as messenger so that u can pass the bunch as a package. Make it public so that all can access.
    • Still to understand…
      Collecting Parameter
  • Object Pool pattern: -
    • An object pool is a set of initialised objects that are kept ready to use rather than allocated or destroyed on demand.
    • A client of the pool will request an object from the pool and perform operations on the returned object. When the client has finished with an object, it returns it to the pool, rather than destroying it. It is a specific type of factory object.
    • The case where it should be used: - Object pooling can offer a significant performance boost in situations where the cost of initializing a class instance is high, the rate of instantiation of a class is high, and the number of instances in use at any one time is low.
  • Singleton Pattern : -
    • Possibly the simplest design pattern is the singleton, which is a way to provide one and only one object of a particular type.  An important aspect of Singleton is that you provide a global access point, so singletons are often a solution for what you would have used a global variable for in C.
    • Singletons can be found in java library.
    • The Code Example:
      //: singleton: SingletonPattern.java
      // The Singleton design pattern: you can
      // never instantiate more than one.
      package singleton;
      import junit.framework.*;


      // Since this isn't inherited from a Cloneable
      // base class and cloneability isn't added,
      // making it final prevents cloneability from
      // being added through inheritance:


      final class Singleton {
        private static Singleton s = new Singleton(47);
      //Static as no duplicates are allowed for static methods and vars
        private int i;
        private Singleton(int x) { i = x; }


      //The method is static because it is accessing the static parameter so it has to be static to access it.
        public static Singleton getReference() {
          return s;
        }
        public int getValue() { return i; }
        public void setValue(int x) { i = x; }
      }


      public class SingletonPattern extends TestCase {
        public void test() {
      //This is possible because static methods can be called even without
      //object references
          Singleton s = Singleton.getReference();
          String result = "" + s.getValue();
          System.out.println(result);
          assertEquals(result, "47");
          Singleton s2 = Singleton.getReference();
          s2.setValue(9);
          result = "" + s.getValue();
          System.out.println(result);
          assertEquals(result, "9");
          try {
            // Can't do this: compile-time error.
            // Singleton s3 = (Singleton)s2.clone();
          } catch(Exception e) {
            throw new RuntimeException(e);
          }
        }
        public static void main(String[] args) {
          junit.textui.TestRunner.run(SingletonPattern.class);
        }
      } ///:~