浅谈设计模式(二):装饰器模式|中介模式|原型模式

啦啦啦321

发布于 2020-02-11 17:09:16

4151

发布于 2020-02-11 17:09:16

文章被收录于专栏：彭湖湾的编程世界

装饰器模式（Decorator Pattern）

装饰器模式可用来给一个类动态添加功能，将其装饰成一个新的类。这就是装饰器的概念。看到这里我们可能会想，要达到这种效果，我们用子类继承父类不就可以了吗？没错装饰器模式，本身是一种继承的替代方案。那既然是替代方案，那么自然就有它不一样的地方。

具体区别在哪里呢？请看

装饰器模式更灵活：继承时父子类的关系是静态的，而装饰器模式是动态的，装饰类和被装饰类的关系是运行时候确认的
装饰类和被装饰类的耦合关系是松散的，各自可以独立变化

下面看看具体的代码。具体过程可看注释

// 1.首先我们有一个Pen接口
public interface Pen {
  public void write();
}
// 2.Pencil类实现了Pen这个接口
public class Pencil implements Pen {
    public void write () {
        System.out.print("写");
    }
}
// 3.装饰类PencilDecorator也实现了Pen这个接口，且代理调用Pencil的方法
public class PencilDecorator implements Pen{
    Pen pen;
    public PencilDecorator(Pen pen) {
      this.pen = pen;
    }
    public void write () {
      pen.write();
    }
}
// 4.用具体装饰类继承PencilDecorator，这样就可以做扩展变化
public class BluePencilDecorator extends PencilDecorator{
    public BluePencilDecorator (Pen pen) {
        super(pen);
    }
    public void writeBlue () {
        this.write();
        System.out.println("写出来是蓝色的");
    }
}
// 同4.用具体装饰类继承PencilDecorator，这样就可以做扩展变化
public class RedPencilDecorator extends PencilDecorator{
    public RedPencilDecorator (Pen pen) {
        super(pen);
    }
    public void writeRed () {
        this.write();
        System.out.println("写出来是红色的");
    }
}
// 测试
public class Test {
    public static void main(String args []) {
       Pen pencil = new Pencil();
       RedPencilDecorator redPencil = new RedPencilDecorator(pencil);
       BluePencilDecorator bluePencil = new BluePencilDecorator(pencil);
       redPencil.writeRed();
       bluePencil.writeBlue();
    }
}

输出结果

代码的结构如下图所示

从这里我们看到了，经过PencilDecorator类这一层的隔离，Pencil类和BluePencilDecorator类/RedPencilDecorator类在一定程度上解耦，从而各自独立发展了。这就是代理模式能够替代继承的原因和它的独特优势

唉！！等一下，好像看到了什么熟悉的东西，请看

没错，这还真就是代理模式的代码。

在这里，我们可以从两个角度去理解装饰器模式。

第一，从构成上看，装饰器模式 = 代理模式 + 类继承。也就是在代理模式的基础上，加了一堆继承[代理类]的子类，从而进行扩展变化，并且还尽量减少了和原有类的联系。
第二，从功能上看，代理模式侧重的是“控制”，而装饰器模式侧重的是“扩展”。比如说，类A代理了类B，那么这两个类由于同一个接口的约束，它们的方法和实现的功能其实是一样的。而类C装饰了类D，那么这个时候类C不仅仅具备了类D的方法，同时还能加入自己的特殊逻辑。

中介者模式(Mediator Pattern)

简单的说，中介者模式是一个分散到集中的一个过程

还是看下具体的代码

// Colleague接口
public interface Colleague {
    public void handleExternal(Mediator mediator);
    public void handleInternal();
}
// 中介者接口
public abstract class Mediator {
   public Colleague A;
   public Colleague B;
   public Colleague C;
   public Mediator (Colleague A, Colleague B, Colleague C) {
       super();
    this.A = A;
    this.B = B;
    this.C = C;
  }
  public abstract void handleA ();
  public abstract void handleB ();
  public abstract void handleC ();
}
// 实现了中介者接口的中介者类，封装了不同Colleague类的对象间的复杂操作
public class ConcreteMediator extends Mediator{
    public ConcreteMediator(Colleague A, Colleague B, Colleague C) {
        super(A,B,C);
    }
    public void handleA() {
        B.handleInternal();
        C.handleInternal();
    }
    public void handleB() {
      A.handleInternal();
      C.handleInternal();
    }
    public void handleC() {
      A.handleInternal();
      B.handleInternal();
    }
}
// Colleague类在涉及其他Colleague类的复杂操作的时候，通过中介者调用
public class A implements Colleague {
    public void handleExternal(Mediator mediator) {
      mediator.handleA();
      System.out.println("---------------");
    }
    public void handleInternal() {
        System.out.println("A");
    }
}
// Colleague类在涉及其他Colleague类的复杂操作的时候，通过中介者调用
public class B implements Colleague {
    public void handleExternal(Mediator mediator) {
        mediator.handleB();
        System.out.println("---------------");
    }
    public void handleInternal() {
        System.out.println("B");
    }
}
// Colleague类在涉及其他Colleague类的复杂操作的时候，通过中介者调用
public class C implements Colleague {
    public void handleExternal(Mediator mediator) {
        mediator.handleC();
        System.out.println("---------------");
    }
 
    public void handleInternal() {
        System.out.println("C");
    }
}
// 测试
public class main {
    public static void main(String args []) {
        Colleague a = new A();
        Colleague b = new B();
        Colleague c = new C();
        Mediator mediator = new ConcreteMediator(a,b,c);
        a.handleExternal(mediator);
        b.handleExternal(mediator);
        c.handleExternal(mediator);
    }
}

结果输出

中介者模式理解起来，就好像

你有很多杂乱的物品摆放在房间的不同地方，找起来很不好找，现在把这些物品统一放到一个柜子里，方便集中管理。
一群人去食堂打饭的时候，如果各自去取菜那么食堂可能乱做一团，所以这时候食堂大妈就成为了“中介者”

原型模式(Prototype Pattern)

原型模式是什么？

一句话，原型模式就是克隆对象，完了。

这么简单？这也能叫设计模式？

没错，就是这样

让我们看下代码

// 通过实现Cloneable接口并重写clone方法的方式，让Bar对象变得可克隆。
public class Bar implements Cloneable {
    String value;
    public String getValue () {
      return value;
    }
    public void setValue (String value) {
        this.value = value;
    }
    public Bar clone() {
        Bar clone = null;
        try {
            clone = (Bar)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}
// 调用clone方法可以克隆对象
public class mian {
    public static void main(String args []) {
      Bar bar = new Bar();
      Bar bar2 = bar.clone();
      bar.setValue("1");
      bar2.setValue("2");
      System.out.println(bar.getValue());
      System.out.println(bar2.getValue());
    }
}

运行结果

告诉我，原型模式的本质是什么

原型模式的本质就是—— 套娃

原型模式的优缺点

原型模式的优点：底层的二进制实现拷贝，相比起new操作可以节约性能
原型模式的缺点：构造函数没有调用，牺牲了灵活性

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2019-12-31 ，如有侵权请联系 cloudcommunity@tencent.com 删除

面向对象编程

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

面向对象编程

登录后参与评论

0 条评论

热度