Merge pull request dubesar#586 from sourabhvarshney111/Bridge

Added Bridge Pattern

Author: dubesar

Design Patterns/Bridge Pattern/BridgePattern.java

@@ -0,0 +1,55 @@
+/*
+Reference: https://www.tutorialspoint.com/design_pattern/bridge_pattern.htm
+ */
+
+interface DrawAPI {
+   public void drawCircle(int radius, int x, int y);
+}
+
+class RedCircle implements DrawAPI {
+   @Override
+   public void drawCircle(int radius, int x, int y) {
+      System.out.println("Drawing Circle[ color: red, radius: " + radius + ", x: " + x + ", " + y + "]");
+   }
+}
+
+class GreenCircle implements DrawAPI {
+   @Override
+   public void drawCircle(int radius, int x, int y) {
+      System.out.println("Drawing Circle[ color: green, radius: " + radius + ", x: " + x + ", " + y + "]");
+   }
+}
+
+abstract class Shape {
+   protected DrawAPI drawAPI;
+   
+   protected Shape(DrawAPI drawAPI){
+      this.drawAPI = drawAPI;
+   }
+   public abstract void draw();  
+}
+
+class Circle extends Shape {
+   private int x, y, radius;
+
+   public Circle(int x, int y, int radius, DrawAPI drawAPI) {
+      super(drawAPI);
+      this.x = x;  
+      this.y = y;  
+      this.radius = radius;
+   }
+
+   public void draw() {
+      drawAPI.drawCircle(radius,x,y);
+   }
+}
+
+public class BridgePattern {
+   public static void main(String[] args) {
+      Shape redCircle = new Circle(100,100, 10, new RedCircle());
+      Shape greenCircle = new Circle(100,100, 10, new GreenCircle());
+
+      redCircle.draw();
+      greenCircle.draw();
+   }
+}

Design Patterns/Bridge Pattern/README.md

@@ -0,0 +1,23 @@
+### Bridge Pattern
+
+### Introduction
+
+Bridge is used when we need to decouple an abstraction from its implementation so that the two can vary independently. This type of design pattern comes under structural pattern as this pattern decouples implementation class and abstract class by providing a bridge structure between them.
+
+This pattern involves an interface which acts as a bridge which makes the functionality of concrete classes independent from interface implementer classes. Both types of classes can be altered structurally without affecting each other.
+
+### Advantages
+
+- It enables the separation of implementation from the interface.
+- It improves the extensibility.
+- It allows the hiding of implementation details from the client.
+
+### Disadvantages
+
+- Bridge pattern implementation increases code complexity.
+- Interfaces with only single implementation.
+- Multiple indirection - A level of indirection is introduced as the request is passed from the Abstraction to the actual implementor.
+
+### Programming
+
+We have a DrawAPI interface which is acting as a bridge implementer and concrete classes RedCircle, GreenCircle implementing the DrawAPI interface. Shape is an abstract class and will use object of DrawAPI. BridgePattern, our demo class will use Shape class to draw different colored circle.