Bridge Design Pattern
2015-05-14 16:20
253 查看
“Decouple an abstraction from its implementation so that the two can vary independently” is the intent for bridge design pattern as stated by GoF.
Bridge design pattern is a modified version of the notion of “prefer composition over inheritance”.
Decouple implentation from interface and hiding implementation details from client is the essense of bridge design pattern.
Refined Abstraction – Extends the abstraction takes the finer detail one level below. Hides the finer elements from implemetors.
Implementer – This interface is the higer level than abstraction. Just defines the basic operations.
Concrete Implementation – Implements the above implementer by providing concrete implementation.
manufacture()
Car -> Refined Abstraction 1
manufacture()
Bike -> Refined Abstraction 2
manufacture()
Workshop -> Implementor
work()
Produce -> Concrete Implementation 1
work()
Assemble -> Concrete Implementation 2
work()
Generic UML Diagram for Bridge Design Pattern
Before Bridge Design Pattern
After Bridge Design Pattern
Sample Java Code for Bridge Design Pattern
package com.javapapers.designpattern;
/**
* abstraction in bridge pattern
* */
abstract class Vehicle {
protected Workshop workShop1;
protected Workshop workShop2;
}
package com.javapapers.designpattern;
/**
* Refine abstraction 1 in bridge pattern
*/
public class Car extends Vehicle {
}
package com.javapapers.designpattern;
/**
* Refine abstraction 2 in bridge pattern
*/
public class Bike extends Vehicle {
}
package com.javapapers.designpattern;
/**
* Implementor for bridge pattern
* */
public interface Workshop {
abstract public void work();
}
package com.javapapers.designpattern;
/**
* Concrete implementation 1 for bridge pattern
* */
public class Produce implements Workshop {
}
package com.javapapers.designpattern;
/**
* Concrete implementation 2 for bridge pattern
* */
public class Assemble implements Workshop {
}
package com.javapapers.designpattern;
/*
* Demonstration of bridge design pattern
*/
public class BridgePattern {
}
Output:
Car Produced Assembled.
Bike Produced Assembled.
Summary of Bridge Design Pattern
Creates two different hierarchies. One for abstraction and another for implementation.
Avoids permanent binding by removing the dependency between abstraction and implementation.
We create a bridge that coordinates between abstraction and implementation.
Abstraction and implementation can be extended separately.
Should be used when we have need to switch implementation at runtime.
Client should not be impacted if there is modification in implementation of abstraction.
Best used when you have multiple implementations.
Bridge Vs Adapter Design Pattern
The adapter design pattern helps it two incompatible classes to work together. But, bridge design pattern decouples the abstraction and implementation by creating two different hierarchies.
Bridge design pattern is a modified version of the notion of “prefer composition over inheritance”.
Problem and Need for Bridge Design Pattern
When there are inheritance hierarchies creating concrete implementation, you loose flexibility because of interdependence. Oops! these kind of sentencies shows that the author(I) didn’t understand and tries to escape! Okay, I will decrypt this sentence in the coming paragraphs.Decouple implentation from interface and hiding implementation details from client is the essense of bridge design pattern.
Elements of Bridge Design Pattern
Abstraction – core of the bridge design pattern and defines the crux. Contains a reference to the implementer.Refined Abstraction – Extends the abstraction takes the finer detail one level below. Hides the finer elements from implemetors.
Implementer – This interface is the higer level than abstraction. Just defines the basic operations.
Concrete Implementation – Implements the above implementer by providing concrete implementation.
Example for core elements of Bridge Design Pattern
Vehicle -> Abstractionmanufacture()
Car -> Refined Abstraction 1
manufacture()
Bike -> Refined Abstraction 2
manufacture()
Workshop -> Implementor
work()
Produce -> Concrete Implementation 1
work()
Assemble -> Concrete Implementation 2
work()
Generic UML Diagram for Bridge Design Pattern
Before Bridge Design Pattern
After Bridge Design Pattern
Sample Java Code for Bridge Design Pattern
package com.javapapers.designpattern;
/**
* abstraction in bridge pattern
* */
abstract class Vehicle {
protected Workshop workShop1;
protected Workshop workShop2;
protected Vehicle(Workshop workShop1, Workshop workShop2) { this.workShop1 = workShop1; this.workShop2 = workShop2; } abstract public void manufacture();
}
package com.javapapers.designpattern;
/**
* Refine abstraction 1 in bridge pattern
*/
public class Car extends Vehicle {
public Car(Workshop workShop1, Workshop workShop2) { super(workShop1, workShop2); } @Override public void manufacture() { System.out.print("Car "); workShop1.work(); workShop2.work(); }
}
package com.javapapers.designpattern;
/**
* Refine abstraction 2 in bridge pattern
*/
public class Bike extends Vehicle {
public Bike(Workshop workShop1, Workshop workShop2) { super(workShop1, workShop2); } @Override public void manufacture() { System.out.print("Bike "); workShop1.work(); workShop2.work(); }
}
package com.javapapers.designpattern;
/**
* Implementor for bridge pattern
* */
public interface Workshop {
abstract public void work();
}
package com.javapapers.designpattern;
/**
* Concrete implementation 1 for bridge pattern
* */
public class Produce implements Workshop {
@Override public void work() { System.out.print("Produced"); }
}
package com.javapapers.designpattern;
/**
* Concrete implementation 2 for bridge pattern
* */
public class Assemble implements Workshop {
@Override public void work() { System.out.println(" Assembled."); }
}
package com.javapapers.designpattern;
/*
* Demonstration of bridge design pattern
*/
public class BridgePattern {
public static void main(String[] args) { Vehicle vehicle1 = new Car(new Produce(), new Assemble()); vehicle1.manufacture(); Vehicle vehicle2 = new Bike(new Produce(), new Assemble()); vehicle2.manufacture(); }
}
Output:
Car Produced Assembled.
Bike Produced Assembled.
Summary of Bridge Design Pattern
Creates two different hierarchies. One for abstraction and another for implementation.
Avoids permanent binding by removing the dependency between abstraction and implementation.
We create a bridge that coordinates between abstraction and implementation.
Abstraction and implementation can be extended separately.
Should be used when we have need to switch implementation at runtime.
Client should not be impacted if there is modification in implementation of abstraction.
Best used when you have multiple implementations.
Bridge Vs Adapter Design Pattern
The adapter design pattern helps it two incompatible classes to work together. But, bridge design pattern decouples the abstraction and implementation by creating two different hierarchies.
相关文章推荐
- Design Pattern Bridge 桥设计模式
- Design Pattern Bridge 桥设计模式
- Bridge Design Pattern (桥模式)
- design pattern notes [1] - Bridge and composite
- Design Pattern Explained 读书笔记五——Bridge
- pimpl idiom vs. bridge design pattern
- design_pattern_bridge
- Design Pattern Framework 4.0 C# 之三 Bridge
- design_pattern_bridge
- Design pattern learning III: Bridge pattern
- Bridge Design Pattern
- design pattern notes [1] - Bridge and composite
- 桥接模式(Bridge Pattern)
- Design Pattern—Singleton
- Java设计模式之--桥接模式(bridge pattern)
- JAVA的依赖注入模式(Dependency Injection Design Pattern in Java)
- DPL(Design Pattern Library)
- 设计模式-----桥接模式(Bridge Pattern)
- head first Design Pattern Command
- 桥接模式(Bridge Pattern)要点