23种设计模式详解(六)

1.中介者模式(Mediator)

中介者模式也是用来降低类类之间的耦合的,因为如果类类之间有依赖关系的话,不利于功能的拓展和维护,因为只要修改一个对象,其它关联的对象都得进行修改。如果使用中介者模式,只需关心和Mediator类的关系,具体类类之间的关系及调度交给Mediator就行,这有点像spring容器的作用。

User接口:

public abstract class User {
    private Mediator mediator;

    public Mediator getMediator() {
        return mediator;
    }

    public User(Mediator mediator) {

        this.mediator = mediator;
    }
    public abstract void work();

}

User1:

public class User1 extends User {
    public User1(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void work() {
        System.out.println("user1 exe....");
    }
}

User2:

public class User2 extends User {
    public User2(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void work() {
        System.out.println("user2 exe....");
    }
}

中介接口:

public interface Mediator {
    public void creatMediator();
    public void allWorkers();
}

中介实现:

public class myMediator implements Mediator{
    private User1 user1;
    private User2 user2;

    public User2 getUser2() {
        return user2;
    }

    public User1 getUser1() {

        return user1;
    }

    @Override
    public void creatMediator() {
        user1=new User1(this);
        user2=new User2(this);
    }

    @Override
    public void allWorkers() {
        user1.work();
        user2.work();
    }
}

测试:

public class Test {
    public static void main(String[] args){
        Mediator mediator=new myMediator();
        mediator.creatMediator();
        mediator.allWorkers();
    }
}

结果:

2.解释器模式(Interpreter Pattern)

解释器模式是我们暂时的最后一讲,一般主要应用在OOP开发中的编译器的开发中,所以适用面比较窄。

上下文环境类:

public class Context {
    private int num1;
    private int num2;

    public Context(int num1,int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }

    public int getNum1() {

        return num1;
    }

    public void setNum1(int num1) {
        this.num1 = num1;
    }
}

计算接口:

public interface Expression {
    public int expression(Context context);
}

实现类:

public class Plus implements Expression{
    @Override
    public int expression(Context context) {
        return context.getNum1()+context.getNum2();
    }
}



public class Minus implements Expression{
    @Override
    public int expression(Context context) {
        return context.getNum1()-context.getNum2();
    }
}

测试:

public class Test {
    public static void main(String[] args){
        //21+22-2
        int result=new Minus().expression(new Context(new Plus().expression(new Context(21,22)),2));
        System.out.println(result);
    }
}

结果:

3.备忘录模式(Memento)

主要目的是保存一个对象的某个状态,以便在适当的时候恢复对象,个人觉得叫备份模式更形象些,通俗的讲下:假设有原始类A,A中有各种属性,A可以决定需要备份的属性,备忘录类B是用来存储A的一些内部状态,类C呢,就是一个用来存储备忘录的,且只能存储,不能修改等操作。

原始类A:

public class A {
    private String Value;
    private B b;

    public A(String value) {
        Value = value;
    }
    public String getValue() {
        return Value;
    }
    public void setValue(String value) {
        Value = value;
    }
    public B creatB(){
        return new B(Value);
    }
    public void restoreB(B b){
        this.Value=b.getValue();
    }

}

备忘录B:

public class B {
    private String value;
    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public B(String value) {
        this.value = value;
    }
}

存储备忘录的类C:

public class C {
    private B b;

    public B getB() {
        return b;
    }

    public void setB(B b) {
        this.b = b;
    }

    public C(B b) {

        this.b = b;
    }
}

测试:

public class Test {
    public static void main(String[] args){
        //创建原始类
        A a=new A("water");
        //创建备忘录
       C c=new C(a.creatB());
        //修改原始类的状态
        a.setValue("ice");
        //恢复原始类的状态
        a.restoreB(c.getB());
    }
}

结果:

源码:

链接: https://pan.baidu.com/s/1RXJLKsQ0z7TBx0hXeUqM3Q

密码: 4mgb

原文发布于微信公众号 - Java大联盟(javaunion)

原文发表时间:2018-05-25

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏后端技术探索

基于Redis实现分布式消息队列(二)

1、访问Redis的工具类 public class RedisManager {

792
来自专栏码匠的流水账

聊聊openmessaging的MessagingAccessPoint

本文主要研究一下openmessaging的MessagingAccessPoint

471
来自专栏JadePeng的技术博客

json转成java对象

avro生成的代码里,String是CharSequence,不能通过Gson反序列化,于是有了下面的代码,ParseArray里还不完善: 1 static...

3437
来自专栏杨熹的专栏

The Chinese zodiac

haoLan: The Chinese zodiac, explained Asking a zodiac sign is a polite way of as...

2748
来自专栏码匠的流水账

聊聊spring cloud gateway的GatewayFilter

本文主要研究一下spring cloud gateway的GatewayFilter

1311
来自专栏码匠的流水账

聊聊jesque的event机制

jesque-2.1.2-sources.jar!/net/greghaines/jesque/worker/WorkerEvent.java

401
来自专栏李家的小酒馆

C# 通过反射初探ORM框架的实现原理

背景:   以前学的Java进行开发,多用到Mybatis,Hiberante等ORM框架,最近需要上手一个C#的项目,由于不是特别难,也不想再去学习C#的OR...

2490
来自专栏微信公众号:Java团长

深入浅出java静态代理和动态代理

代理模式,是常用的设计模式。特征是,代理类与委托类有相同的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类。以及事后处理消息。

851
来自专栏大内老A

EnterLib PIAB又一个BUG?

在《这是EnterLib PIAB的BUG吗?》一文中我们讨论了PIAB关于抽象基类的BUG,今天又发现了一个新的问题。问题的起因源于《IoC+AOP的简单实现...

1679
来自专栏码匠的流水账

聊聊sentinel的ModifyRulesCommandHandler

本文主要研究一下sentinel的ModifyRulesCommandHandler

461

扫码关注云+社区