java设计模式-可复用面向对象软件的基础（四）

时间 2021-04-05

标签 java 正则表达式算法 spring 设计模式数据结构数据结构和算法 ide 学习测试栏目 Java 繁體版

原文原文链接

20、状态模式（State）java

核心思想就是：当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来讲，有几种状态，在线、隐身、忙碌等，每一个状态对应不一样的操做，并且你的好友也能看到你的状态，因此，状态模式就两点：一、能够经过改变状态来得到不一样的行为。二、你的好友能同时看到你的变化。看图：正则表达式

State类是个状态类，Context类能够实现切换，咱们来看看代码：算法

[java] view plain copy spring

package com.xtfggef.dp.state; 设计模式
/** 数据结构
* 状态类的核心类数据结构和算法
* 2012-12-1 ide
* @author erqing 学习
* 测试
*/
public class State {
private String value;
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public void method1(){
System.out.println("execute the first opt!");
}
public void method2(){
System.out.println("execute the second opt!");
}
}

[java] view plain copy

package com.xtfggef.dp.state;
/**
* 状态模式的切换类 2012-12-1
* @author erqing
*
*/
public class Context {
private State state;
public Context(State state) {
this.state = state;
}
public State getState() {
return state;
}
public void setState(State state) {
this.state = state;
}
public void method() {
if (state.getValue().equals("state1")) {
state.method1();
} else if (state.getValue().equals("state2")) {
state.method2();
}
}
}

测试类：

[java] view plain copy

public class Test {
public static void main(String[] args) {
State state = new State();
Context context = new Context(state);
//设置第一种状态
state.setValue("state1");
context.method();
//设置第二种状态
state.setValue("state2");
context.method();
}
}

输出：

execute the first opt!
execute the second opt!

根据这个特性，状态模式在平常开发中用的挺多的，尤为是作网站的时候，咱们有时但愿根据对象的某一属性，区别开他们的一些功能，好比说简单的权限控制等。

2一、访问者模式（Visitor）

访问者模式把数据结构和做用于结构上的操做解耦合，使得操做集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。由于访问者模式使得算法操做增长变得容易。若系统数据结构对象易于变化，常常有新的数据对象增长进来，则不适合使用访问者模式。访问者模式的优势是增长操做很容易，由于增长操做意味着增长新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增长新的数据结构很困难。—— From 百科

简单来讲，访问者模式就是一种分离对象数据结构与行为的方法，经过这种分离，可达到为一个被访问者动态添加新的操做而无需作其它的修改的效果。简单关系图：

来看看原码：一个Visitor类，存放要访问的对象，

[java] view plain copy

public interface Visitor {
public void visit(Subject sub);
}

[java] view plain copy

public class MyVisitor implements Visitor {
@Override
public void visit(Subject sub) {
System.out.println("visit the subject："+sub.getSubject());
}
}

Subject类，accept方法，接受将要访问它的对象，getSubject()获取将要被访问的属性，

[java] view plain copy

public interface Subject {
public void accept(Visitor visitor);
public String getSubject();
}

[java] view plain copy

public class MySubject implements Subject {
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
@Override
public String getSubject() {
return "love";
}
}

测试：

[java] view plain copy

public class Test {
public static void main(String[] args) {
Visitor visitor = new MyVisitor();
Subject sub = new MySubject();
sub.accept(visitor);
}
}

输出：visit the subject：love

该模式适用场景：若是咱们想为一个现有的类增长新功能，不得不考虑几个事情：一、新功能会不会与现有功能出现兼容性问题？二、之后会不会再须要添加？三、若是类不容许修改代码怎么办？面对这些问题，最好的解决方法就是使用访问者模式，访问者模式适用于数据结构相对稳定的系统，把数据结构和算法解耦，

2二、中介者模式（Mediator）

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

User类统一接口，User1和User2分别是不一样的对象，两者之间有关联，若是不采用中介者模式，则须要两者相互持有引用，这样两者的耦合度很高，为了解耦，引入了Mediator类，提供统一接口，MyMediator为其实现类，里面持有User1和User2的实例，用来实现对User1和User2的控制。这样User1和User2两个对象相互独立，他们只须要保持好和Mediator之间的关系就行，剩下的全由MyMediator类来维护！基本实现：

[java] view plain copy

public interface Mediator {
public void createMediator();
public void workAll();
}

[java] view plain copy

public class MyMediator implements Mediator {
private User user1;
private User user2;
public User getUser1() {
return user1;
}
public User getUser2() {
return user2;
}
@Override
public void createMediator() {
user1 = new User1(this);
user2 = new User2(this);
}
@Override
public void workAll() {
user1.work();
user2.work();
}
}

[java] view plain copy

public abstract class User {
private Mediator mediator;
public Mediator getMediator(){
return mediator;
}
public User(Mediator mediator) {
this.mediator = mediator;
}
public abstract void work();
}

[java] view plain copy

public class User1 extends User {
public User1(Mediator mediator){
super(mediator);
}
@Override
public void work() {
System.out.println("user1 exe!");
}
}

[java] view plain copy

public class User2 extends User {
public User2(Mediator mediator){
super(mediator);
}
@Override
public void work() {
System.out.println("user2 exe!");
}
}

测试类：

[java] view plain copy

public class Test {
public static void main(String[] args) {
Mediator mediator = new MyMediator();
mediator.createMediator();
mediator.workAll();
}
}

输出：

user1 exe!
user2 exe!
2三、解释器模式（Interpreter）
解释器模式是咱们暂时的最后一讲，通常主要应用在OOP开发中的编译器的开发中，因此适用面比较窄。

Context类是一个上下文环境类，Plus和Minus分别是用来计算的实现，代码以下：

[java] view plain copy

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

[java] view plain copy

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

[java] view plain copy

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

[java] view plain copy

public class Context {
private int num1;
private int num2;
public Context(int num1, int num2) {
this.num1 = num1;
this.num2 = num2;
}
public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
}

[java] view plain copy

public class Test {
public static void main(String[] args) {
// 计算9+2-8的值
int result = new Minus().interpret((new Context(new Plus()
.interpret(new Context(9, 2)), 8)));
System.out.println(result);
}
}

最后输出正确的结果：3。

基本就这样，解释器模式用来作各类各样的解释器，如正则表达式等的解释器等等！

设计模式基本就这么大概讲完了，整体感受有点简略，的确，这么点儿篇幅，不足以对整个23种设计模式作全面的阐述，此处读者可将它做为一个理论基础去学习，经过这四篇博文，先基本有个概念，虽然我讲的有些简单，但基本都能说明问题及他们的特色，若是对哪个感兴趣，能够继续深刻研究！同时我也会不断更新，尽可能补全遗漏、修正不足，欢迎广大读者及时提出好的建议，咱们一块儿学习！项目中涉及到的代码，已经放到了个人资源里：http://download.csdn.net/detail/zhangerqing/4835830（由于我不喜欢坐享其成，因此没有免积分，只设置了5个，若是有人实在没积分又急要，那么联系我吧，我给你发过去）。