JUNE ®️Jun

桥接模式

桥梁模式的重点在解耦。

定义

将抽象和实现解耦，使得两者可以独立的变化。
它使用了类间的聚合关系、继承、覆写等常用功能。解决了继承的缺点而提出的设计模式。

桥接模式通用类图

实现

抽象角色引用实现角色，或者说抽象角色的部分实现是由实现角色完成的。

Abstraction

抽象化角色，定义出该抽象角色的行为，同时保存一个对实现化角色的引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class Abstraction{

    private Implementor imp;
    //必须指定实现者
    public Abstraction(Implementor imp){
        this.imp = imp;
    }

    public void request(){
        this.imp.doSomething();
    }
    public Implementor getImp(){
        return imp;
    }
}

RefindAbstraction

修正抽象化角色，引用实现化角色对抽象化角色进行修正。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class RefindAbstraction extends Abstraction{

    public RefindAbstraction(Implementor imp){
        super(imp);
    }

    @Override
    public void request(){
      //....
      super.request();
      super.getImp().doAnyThing();
    }
}

Implementor

实现化角色，接口或者抽象类，定义角色必须的行为和属性。

1
2
3
4
public interface Implementor{
    public void doSomething();
    public void doAnyThing();
}

ConcreteImplementor

具体实现化角色，实现接口或者抽象类定义的方法和属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ConcreteImplementor1 implements Implementor{

    public void doSomething(){
        //
    }
    public void doAnyThing(){
        //
    }
}

public class ConcreteImplementor2 implements Implementor{

    public void doSomething(){
        //
    }
    public void doAnyThing(){
        //
    }
}

Use

1
2
3
Implementor imp = new ConcreteImplementor1();
Abstraction abs = new RefindAbstraction(imp);
abs.request();

应用

优点

  • 抽象和实现分离
    为了解决继承的缺点而提出的设计模式，在该模式下，实现可以不受抽象的约束，不再绑定到固定的抽象层次上。

  • 优秀的扩展能力

可以随意增加抽象和实现。

  • 实现细节对客户透明

由抽象层通过聚合关系完成了封装。

使用场景

  • 不希望或者不适用使用继承的场景
    继承层次太高，无法更细化设计颗粒等场景，需要考虑使用。
  • 接口或者抽象类不稳定的场景
    接口或者抽象类不稳定，经常变更时，使用桥梁模式。
  • 重用型要求高的场景
    设计的颗粒度粤西，被重用的可能性越大。
    采用继承受到父类的限制，不可能出现太细的粒度。

装饰器模式

定义

动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式相比生成子类更加灵活。

装饰器模式通用类图

实现

Component

Component 是一个接口或者抽象类，定义需要被装饰的原始类。

1
2
3
public abstract class Component{
    public abstract void operate();
}

Concrete Component

Component 的实现类。

1
2
3
4
5
6
7
8
public class ConcreteComponent extends Component{

   @Override
   public void operate(){
      //....
   }

}

Decorator

抽象类，用于实现接口或者抽象方法。包含被修饰的Componnet属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class Decorator extends Component{
    
    private Component component = null;

    public Decorator(Component c){
        this.component = c;
    }
    @Override
    public void operate(){
        this.component.operate();
    }

}

Concrete Decorator

具体装饰角色

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ConcreteDecorator1 extends Decorator{
    public ConcreteDecorator1(Component component){
        super(component);
    }
    private void method1(){
        //....
    }
    public void operate(){
       this.method1();
       super.operate();
    }
}


public class ConcreteDecorator2 extends Decorator{
    public ConcreteDecorator2(Component component){
        super(component);
    }
    private void method2(){
        //....
    }
    public void operate(){
       super.operate();
       this.method2();
    }
}

Use

1
2
3
4
Component c = new ConcreteComponent();
c = new ConcreteDecorator1(c);
c = new ConcreteDecorator2(c);
c.operate();

应用

优点

装饰类和被装饰类可以独立发展，而不会相互耦合。
装饰模式是继承关系的一个替代方案。
装饰模式可以动态地扩展一个实现类的功能。

缺点

当装饰多层时导致系统复杂度高。


16 / 39