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);
}
}
结果:
主要目的是保存一个对象的某个状态,以便在适当的时候恢复对象,个人觉得叫备份模式更形象些,通俗的讲下:假设有原始类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