Java Design Patterns Interview Questions and Answers

Prototype pattern refers to creating duplicate object while keeping performance in mind. This type of design pattern comes under creational pattern as this pattern provides one of the best way to create an object.

This pattern involves implementing a prototype interface which tells to create a clone of the current object. This pattern is used when creation of object directly is costly. For example, a object is to be created after a costly database operation. We can cache the object, returns its clone on next request and update the database as as and when needed thus reducing database calls.

We're going to create an abstract class Mobile and concrete classes extending the Mobile class. A class MobileCache is defined as a next step which stores shape objects in a Hashtable and returns their clone when requested.

PrototypPatternDemo, our demo class will use MobileCache class to get a Mobile object.

Create an abstract class implementing Clonable interface.

Mobile.java

public abstract class Mobile implements Cloneable {

   

   private String id;

   protected String type;

   

   abstract void make();

   

   public String getType(){

      return type;

   }

   

   public String getId() {

      return id;

   }

   

   public void setId(String id) {

      this.id = id;

   }

   

   public Object clone() {

      Object clone = null;

      try {

         clone = super.clone();

      } catch (CloneNotSupportedException e) {

         e.printStackTrace();

      }

      return clone;

   }

}

Create concrete classes extending the above class.

Sony.java

public class Sony extends Mobile {

   public Sony(){

     type = "Sony";

   }

   @Override

   public void make() {

      System.out.println("Inside Sony::make() method.");

   }

}

Blackberry.java

public class Blackberry extends Mobile {

   public Blackberry(){

     type = "Blackberry";

   }

   @Override

   public void make() {

      System.out.println("Inside Blackberry::make() method.");

   }

}

Samsung.java

public class Samsung extends Mobile {

   public Samsung(){

     type = "Samsung";

   }

   @Override

   public void make() {

      System.out.println("Inside Samsung::make() method.");

   }

}

Create a class to get concreate classes from database and store them in a Hashtable.

MobileCache.java

import java.util.Hashtable;

public class MobileCache {

   private static Hashtable<String, Mobile> shapeMap 

      = new Hashtable<String, Mobile>();

   public static Mobile getMobile(String shapeId) {

      Mobile cachedMobile = shapeMap.get(shapeId);

      return (Mobile) cachedMobile.clone();

   }

   // for each shape run database query and create shape

   // shapeMap.put(shapeKey, shape);

   // for example, we are adding three shapes

   public static void loadCache() {

      Samsung circle = new Samsung();

      circle.setId("1");

      shapeMap.put(circle.getId(),circle);

      Blackberry square = new Blackberry();

      square.setId("2");

      shapeMap.put(square.getId(),square);

      Sony rectangle = new Sony();

      rectangle.setId("3");

      shapeMap.put(rectangle.getId(),rectangle);

   }

}

PrototypePatternDemo uses MobileCache class to get clones of shapes stored in a Hashtable.

PrototypePatternDemo.java

public class PrototypePatternDemo {

   public static void main(String[] args) {

      MobileCache.loadCache();

      Mobile clonedMobile = (Mobile) MobileCache.getMobile("1");

      System.out.println("Mobile : " + clonedMobile.getType());

      Mobile clonedMobile2 = (Mobile) MobileCache.getMobile("2");

      System.out.println("Mobile : " + clonedMobile2.getType());

      Mobile clonedMobile3 = (Mobile) MobileCache.getMobile("3");

      System.out.println("Mobile : " + clonedMobile3.getType());

   }

}

Verify the output.

Mobile : Samsung

Mobile : Blackberry

Mobile : Sony

Decorator pattern allows to add new functionality an existing object without altering its structure. This type of design pattern comes under structural pattern as this pattern acts as a wrapper to existing class.

This pattern creates a decorator class which wraps the original class and provides additional functionality keeping class methods signature intact.

We are demonstrating use of Decorator pattern via following example in which we'll decorate a shape with some color without alter shape class.

We're going to create a Mobile interface and concrete classes implementing the Mobile interface. We then create a abstract decorator class MobileDecorator implementing the Mobile interface and having Mobile object as its instance variable.

RedMobileDecorator is concrete class implementing MobileDecorator.

DecoratorPatternDemo, our demo class will use RedMobileDecorator to decorate Mobile objects.

Step 1

Create an interface.

Mobile.java

public interface Mobile {

   void make();

}

Step 2

Create concrete classes implementing the same interface.

Sony.java

public class Sony implements Mobile {

   @Override

   public void make() {

      System.out.println("Mobile: Sony");

   }

}

Blackberry.java

public class Blackberry implements Mobile {

   @Override

   public void make() {

      System.out.println("Mobile: Blackberry");

   }

}

Step 3

Create abstract decorator class implementing the Mobile interface.

MobileDecorator.java

public abstract class MobileDecorator implements Mobile {

   protected Mobile decoratedMobile;

   public MobileDecorator(Mobile decoratedMobile){

      this.decoratedMobile = decoratedMobile;

   }

   public void make(){

      decoratedMobile.make();

   }

}

Step 4

Create concrete decorator class extending the MobileDecorator class.

RedMobileDecorator.java

public class RedMobileDecorator extends MobileDecorator {

   public RedMobileDecorator(Mobile decoratedMobile) {

      super(decoratedMobile);

   }

   @Override

   public void make() {

      decoratedMobile.make();       

      setRedBorder(decoratedMobile);

   }

   private void setRedBorder(Mobile decoratedMobile){

      System.out.println("Border Color: Red");

   }

}

Step 5

Use the RedMobileDecorator to decorate Mobile objects.

DecoratorPatternDemo.java

public class DecoratorPatternDemo {

   public static void main(String[] args) {

      Mobile circle = new Blackberry();

      Mobile redBlackberry = new RedMobileDecorator(new Blackberry());

      Mobile redSony = new RedMobileDecorator(new Sony());

      System.out.println("Blackberry with normal border");

      circle.make();

      System.out.println("nBlackberry of red border");

      redBlackberry.make();

      System.out.println("nSony of red border");

      redSony.make();

   }

}

Step 6

Verify the output.

Blackberry with normal border

Mobile: Blackberry

Blackberry of red border

Mobile: Blackberry

Border Color: Red

Sony of red border

Mobile: Sony

Border Color: Red