Design Mode (8) --- Bridge Mode, design mode ---

Design Mode (8) --- Bridge Mode, design mode ---

Definition:

Bridge Mode: separates abstract parts from their implementations so that they can all change independently.

Explanation: the separation of abstract and its implementation does not mean that abstract classes are separated from their derived classes, but abstract classes and Their Derived classes are used to implement their own objects.

 

UML class diagram and basic code:

Class Program {static void Main (string [] args) {condition ation AB = new RefinedAbstration (); AB. setImplementor (new ConcreteImplementorA (); AB. operation (); AB. setImplementor (new ConcreteImplementorB (); AB. operation (); Console. read () ;}} abstract class Implementor {public abstract void Operation ();} class ConcreteImplementorA: Implementor {public override void Operation () {Console. writeLine ("implement A action") ;}} class ConcreteImplementorB: Implementor {public override void Operation () {Console. writeLine ("implement B action") ;}} class initialization {protected Implementor implementor; public void SetImplementor (Implementor implementor) {this. implementor = implementor;} public virtual void Operation () {implementor. operation () ;}} class RefinedAbstration: Permission ation {public override void Operation () {implementor. operation ();}}View Code

 

When you see an instance on the internet, it feels very appropriate. Refer to learning.

Specifically, the remote control is implemented in real life. The remote control does not include functions such as power-on, shutdown, and change. The remote control only contains references to these functions on the TV, then the infrared rays find the implementation of the corresponding functions on the TV.

Abstract class TV sets and Changhong and Samsung TV sets:

Public abstract class TV {public abstract void On (); public abstract void Off (); public abstract void TurnChannel ();} public class ChangHong: TV {public override void On () {Console. writeLine ("Changhong TV already on");} public override void Off () {Console. writeLine ("Changhong TV has been turned off");} public override void TurnChannel () {Console. writeLine ("Changhong TV for Channel");} public class Samsung: TV {public override void On () {Console. writeLine ("the licensed TV has been turned on");} public override void Off () {Console. writeLine ("the licensed TV has been turned off");} public override void TurnChannel () {Console. writeLine ("changing the channel of a TV set with a license brand ");}}View Code

 

Abstract class remote control and implementation:

Public class RemoteControl {private TV implementor; public TV Implementor {get {return implementor;} set {implementor = value ;}} public virtual void On () {implementor. on ();} public virtual void Off () {implementor. off ();} public virtual void TurnChannel () {implementor. turnChannel () ;}} public class ConcreteRemote: RemoteControl {}View Code

 

Client call:

RemoteControl remoteControl = new ConcreteRemote();            remoteControl.Implementor = new ChangHong();            remoteControl.On();            remoteControl.Off();            remoteControl.TurnChannel();

 

Advantages:

Abstract interfaces and implementations are decoupled.

Abstraction and implementation can be expanded independently without affecting each other.

Disadvantages:

This increases the complexity of the system.

 

Applicable scenarios:

A class has two independent dimensions, and both dimensions need to be extended.

Graphics and window systems that span multiple platforms.

Beacon cat sets hg226 bridging mode, and the VOIP phone cannot be used normally.

We recommend that you change the optical cat adapter (power supply )!
 
What are the design patterns?

There are three types of design patterns: creation, structure, and behavior.
The creation types include:
I. Singleton, Singleton mode: ensure that a class has only one instance and provide a global access point to it.
2. Abstract Factory: provides an interface for creating a series of related or mutually dependent objects without specifying their specific classes.
3. Factory Method: Define an interface used to create objects, and let the subclass decide which class to instantiate. Factory Method delays the instantiation of a class to the subclass.
4. Builder: separates the construction of a complex object from its representation, so that different representations can be created during the same construction process.
5. Prototype: Use a Prototype instance to specify the type of the object to be created, and copy the Prototype to create a new object.
Behavior types:
6. Iterator: provides a method to access each element of an aggregate object sequentially without exposing the internal representation of the object.
7. Observer: Observer mode: defines one-to-many dependencies between objects. When the status of an object changes, all objects dependent on it will be automatically updated by notification.
8. Template Method: defines the skeleton of an algorithm in an operation, and delays some steps to the subclass, templateMethod allows the subclass to redefine a specific step without changing the structure of an algorithm.
9. Command: encapsulate a request as an object so that you can parameterize the customer with different requests, queue requests and record request logs, and supports unrecoverable operations.
10. State: allows an object to change its behavior when its internal State changes. The object seems to have changed its class.
11. Strategy: Define a series of algorithms, encapsulate them one by one, and enable them to replace each other. This mode allows algorithms to be independent of customers who use them.
12. China of Responsibility, Responsibility chain mode: Enables multiple objects to process requests to avoid coupling between the request sender and receiver.
13. Mediator: uses an intermediary object to encapsulate object interaction of some columns.
14. Visitor, Visitor mode: indicates an operation that acts on each element in an object structure. It allows you to define new operations that act on this element without changing the element classes.
15th, Interpreter, Interpreter mode: a language is defined to define a representation of its grammar and an Interpreter. This Interpreter uses this representation to explain sentences in the language.
16. Memento: capture the internal state of an object without interrupting the object, and save the state outside the object.
There are:
17. Composite: Composite combines objects into a tree structure to represent the relationship between parts of the whole. Composite makes the use of a single object and a Composite object consistent.
18. Facade, appearance mode: provides a consistent interface for a group of interfaces in the subsystem. fa? Ade provides a high-level interface, which makes the subsystem easier to use.
19. Proxy: provides a Proxy for other objects to control access to this object.
20. Adapter: the Adapter mode converts a class of interfaces into another interface that the customer wants. The Adapter mode makes those classes unable to work together due to interface incompatibility.
21. Decrator: the Decorator mode dynamically adds some additional responsibilities to an object. In terms of the added functions, the Decorator mode is more flexible than the subclass generation mode.
22. Bridge: link the abstract Part with its implementation... the remaining full text>