Software Design Pattern: Bridge Pattern
Tags: designpatterns, softwareengineering, java, programming
Published: 2023-05-26 07:53:40

Bridge is a structural design pattern that lets you split a large class or a set of closely related classes into two separate hierarchies—abstraction and implementation—which can be developed independently of each other.

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.

## Example:
When we purchase a smartphone, we get a charger. The charger cable can be separated so that it can be used as a USB cable to connect other devices. Another example is when we use a remote control to operate a TV. The remote control is the abstraction and the TV is the implementation.

## Code:

Shape.java
```java
public abstract class Shape{
    protected Color color;
    public Shape(Color color){
        this.color = color;
    }
    public abstract void draw();
}

```
Circle.java

```java
public class Circle extends Shape{
    public Circle(Color color){
        super(color);
    }
    public void draw(){
        System.out.println("Circle is filled with " + color.fill());
    }
}

```
Rectangle.java

```java
public class Rectangle extends Shape{
    public Rectangle(Color color){
        super(color);
    }
    public void draw(){
        System.out.println("Rectangle is filled with " + color.fill());
    }
}

```
Triangle.java

```java
public class Triangle extends Shape{
    public Triangle(Color color){
        super(color);
    }
    public void draw(){
        System.out.println("Triangle is filled with " + color.fill());
    }
}

```
Color.java

```java
public interface Color{
    String fill();
}

```
Red.java

```java
public class Red implements Color{
    public String fill(){
        return "red";
    }
}

```
Green.java

```java
public class Green implements Color{
    public String fill(){
        return "green";
    }
}

```
Blue.java

```java
public class Blue implements Color{
    public String fill(){
        return "blue";
    }
}

```

Main.java

```java
public class Main{
	public static void main(String[] args){
		Shape shape1 = new Circle(new Blue());
		shape1.draw();
		
		Shape shape2 = new Rectangle(new Green());
		shape2.draw();
	}
}
```


## Output:

```
Circle is filled with blue
Rectangle is filled with green
```

## Explain:

- The code defines a set of classes that implement the Shape interface. The Shape interface provides definitions for objects that represent some form of geometric shape

- Each Shape object provides callbacks to get the bounding box of the geometry, determine whether points or rectangles lie partly or entirely within the interior of the Shape, and retrieve a PathIterator object that describes the trajectory path of the Shape outline

- The Color interface provides a fill method that returns a string representing the color of the shape

- The Red, Green, and Blue classes implement the Color interface and return strings representing their respective colors

- The Circle, Rectangle, and Triangle classes extend the Shape class and implement its draw method. The draw method prints out a message indicating that the shape is filled with a particular color

The Bridge design pattern is used to decouple an abstraction from its implementation so that the two can vary independently. In the context of the code I provided, the Shape class is the abstraction and the Color interface is the implementation. The Bridge pattern allows you to separate the abstraction from the implementation. 

Follow me on : [Github](https://github.com/jps27cse) [Linkedin](https://www.linkedin.com/in/jps27cse/)