职责链模式
主要用于使多个对象都有机会处理请求,避免请求的的发送者和接受者之间的耦合关系。在现实生活中我们多数遇到的是不纯的责任链模式即每个对象都处理请求的一部分后再交给下家。而纯的职责链模式则要求对于一个请求,要不处理要不就交给下家。具体理解呢。我们可以想一下“击鼓传花”的游戏。或则是你帮你的同学传一个纸条。如果传给你你就看,否则就传给下一个同学(嘻嘻)。比较容易理解,主要看一下类图:
和相关代码实现:
public abstract class Handler { /** * 持有后继的责任对象 */ protected Handler successor; /** * 示意处理请求的方法,虽然这个示意方法是没有传入参数的 * 但实际是可以传入参数的,根据具体需要来选择是否传递参数 */ public abstract void handleRequest(); /** * 取值方法 */ public Handler getSuccessor() { return successor; } /** * 赋值方法,设置后继的责任对象 */ public void setSuccessor(Handler successor) { this.successor = successor; } }
具体处理者角色
public class ConcreteHandler extends Handler { /** * 处理方法,调用此方法处理请求 */ @Override public void handleRequest() { /** * 判断是否有后继的责任对象 * 如果有,就转发请求给后继的责任对象 * 如果没有,则处理请求 */ if(getSuccessor() != null) { System.out.println("放过请求"); getSuccessor().handleRequest(); }else { System.out.println("处理请求"); } } }
客户端类
public class Client { public static void main(String[] args) { //组装责任链 Handler handler1 = new ConcreteHandler(); Handler handler2 = new ConcreteHandler(); handler1.setSuccessor(handler2); //提交请求 handler1.handleRequest(); } }
主要用于把发出命令和执行命令的责任分开,委派给不同对象。怎么理解呢?命令模式中请求的实现在接受者中实现但在最后客户请求服务时。具体的实现是通过请求者调用具体命令角色来实现。举个例子。录音机(播放,倒带,停止)三个功能
接收者角色,由录音机类扮演
public class AudioPlayer { public void play(){ System.out.println("播放..."); } public void rewind(){ System.out.println("倒带..."); } public void stop(){ System.out.println("停止..."); } }
抽象命令角色类
public interface Command { /** * 执行方法 */ public void execute(); }
具体命令角色类
public class PlayCommand implements Command { private AudioPlayer myAudio; public PlayCommand(AudioPlayer audioPlayer){ myAudio = audioPlayer; } /** * 执行方法 */ @Override public void execute() { myAudio.play(); } }
public class RewindCommand implements Command { private AudioPlayer myAudio; public RewindCommand(AudioPlayer audioPlayer){ myAudio = audioPlayer; } @Override public void execute() { myAudio.rewind(); } }
public class StopCommand implements Command { private AudioPlayer myAudio; public StopCommand(AudioPlayer audioPlayer){ myAudio = audioPlayer; } @Override public void execute() { myAudio.stop(); } }
请求者角色,由键盘类扮演
public class Keypad { private Command playCommand; private Command rewindCommand; private Command stopCommand; public void setPlayCommand(Command playCommand) { this.playCommand = playCommand; } public void setRewindCommand(Command rewindCommand) { this.rewindCommand = rewindCommand; } public void setStopCommand(Command stopCommand) { this.stopCommand = stopCommand; } /** * 执行播放方法 */ public void play(){ playCommand.execute(); } /** * 执行倒带方法 */ public void rewind(){ rewindCommand.execute(); } /** * 执行播放方法 */ public void stop(){ stopCommand.execute(); } }
客户端角色,由茱丽小女孩扮演
public class Julia { public static void main(String[]args){ //创建接收者对象 AudioPlayer audioPlayer = new AudioPlayer(); //创建命令对象 Command playCommand = new PlayCommand(audioPlayer); Command rewindCommand = new RewindCommand(audioPlayer); Command stopCommand = new StopCommand(audioPlayer); //创建请求者对象 Keypad keypad = new Keypad(); keypad.setPlayCommand(playCommand); keypad.setRewindCommand(rewindCommand); keypad.setStopCommand(stopCommand); //测试 keypad.play(); keypad.rewind(); keypad.stop(); keypad.play(); keypad.stop(); } }
中介者模式
使用场景:集中负责维护对象模型的关系完整性 以及需要 封装对象间交互方式的时候.
===============
交互对象的抽象类,定义了中介者的注入方法 、交互的行为方法
package mediator;
public abstract class Colleague {
}
===============
===============
package mediator;
public class Colleague1 extends Colleague {
}
===============
===============
package mediator;
public class Colleague2 extends Colleague {
}
===============
===============
package mediator;
public class Colleague3 extends Colleague {
}
===============
===============
package mediator;
abstract class Mediator {
}
===============
===============
package mediator;
import java.util.ArrayList;
import java.util.List;
public class ConcreteMediator extends Mediator {
}
===============
===============
package mediator;
public class MediatorTest {
}
观察者模式
观察者模式又称为发布订阅模式,模型视图模式,源-监听器模式。它定义一种一对多的依赖关系,让多个观察者同时监听一个主题对象。这个主题对象发生改变时,所有观察者做出相应变化。例如我们买衣服。我们去买衣服结果没货。我们会把自己的联系方式留下来(注册),等有货时商家通知你。其实这就是一个观察者模式。我们以及其他买衣服者是观察者,商家是被观察者。商家状态改变(有衣服),通知观察者,观察者也做出相应变化(去买衣服)。一个简单的Java例子:
//抽象观察者角色 public interface Watcher { public void update(String str); }
然后定义抽象的主题角色,即抽象的被观察者,在其中声明方法(添加、移除观察者,通知观察者):
//抽象主题角色,watched:被观察 public interface Watched { public void addWatcher(Watcher watcher); public void removeWatcher(Watcher watcher); public void notifyWatchers(String str); }
然后定义具体的观察者:
public class ConcreteWatcher implements Watcher { @Override public void update(String str) { System.out.println(str); } }
之后是具体的主题角色:
import java.util.ArrayList; import java.util.List; public class ConcreteWatched implements Watched { // 存放观察者 private List<Watcher> list = new ArrayList<Watcher>(); @Override public void addWatcher(Watcher watcher) { list.add(watcher); } @Override public void removeWatcher(Watcher watcher) { list.remove(watcher); } @Override public void notifyWatchers(String str) { // 自动调用实际上是主题进行调用的 for (Watcher watcher : list) { watcher.update(str); } } }
编写测试类:
public class Test { public static void main(String[] args) { Watched girl = new ConcreteWatched(); Watcher watcher1 = new ConcreteWatcher(); Watcher watcher2 = new ConcreteWatcher(); Watcher watcher3 = new ConcreteWatcher(); girl.addWatcher(watcher1); girl.addWatcher(watcher2); girl.addWatcher(watcher3); girl.notifyWatchers("开心"); } }
访问者模式适用于数据结构相对稳定的系统,它将算法与对象结构分离开,是操作能相对自由的演化。看一下类图
:
public abstract class Customer {
private String customerId;
private String name;
public String getCustomerId() {
return customerId;
}
public void setCustomerId(String customerId) {
this.customerId = customerId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 接受访问者的访问
* @param visitor
*/
public abstract void accept(Visitor visitor);
}
/**
* 企业客户
*/
public class EnterpriseCustomer extends Customer {
private String linkman;
private String linkTelephone;
private String registerAddress;
public String getLinkman() {
return linkman;
}
public void setLinkman(String linkman) {
this.linkman = linkman;
}
public String getLinkTelephone() {
return linkTelephone;
}
public void setLinkTelephone(String linkTelephone) {
this.linkTelephone = linkTelephone;
}
public String getRegisterAddress() {
return registerAddress;
}
public void setRegisterAddress(String registerAddress) {
this.registerAddress = registerAddress;
}
@Override
public void accept(Visitor visitor) {
//回调访问者对象的方法
visitor.visitEnterpriseCustomer(this);
}
}
/**
* 个人客户
*/
public class PersonalCustomer extends Customer {
private String telephone;
private int age;
public String getTelephone() {
return telephone;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public void accept(Visitor visitor) {
//回调访问者对象的方法
visitor.visitPersonalCustomer(this);
}
}
/**
* 访问者接口
*/
public interface Visitor {
/**
* 访问企业客户,相当于给企业客户添加访问者功能
* @param ec 企业客户对象
*/
public void visitEnterpriseCustomer(EnterpriseCustomer ec);
/**
* 访问个人客户,相当于给个人客户添加访问者的功能
* @param pc
*/
public void visitPersonalCustomer(PersonalCustomer pc);
}
/**
* 具体的访问者,实现对客户的偏好分析
*/
public class PredilectionAnalyzeVisitor implements Visitor {
@Override
public void visitEnterpriseCustomer(EnterpriseCustomer ec) {
// TODO 根据以往的购买历史、潜在购买意向,以及客户所在行业的发展趋势、客户的发展趋势等的分析
System.out.println("现在对企业客户" + ec.getName() + "进行产品偏好分析");
}
@Override
public void visitPersonalCustomer(PersonalCustomer pc) {
System.out.println("现在对个人客户" + pc.getName() + "进行产品偏好分析");
}
}
/**
* 具体的访问者,实现客户提出服务请求的功能
*/
public class ServiceRequestVisitor implements Visitor {
@Override
public void visitEnterpriseCustomer(EnterpriseCustomer ec) {
// TODO 企业客户提出的具体服务请求
System.out.println(ec.getName() + "企业提出服务请求");
}
@Override
public void visitPersonalCustomer(PersonalCustomer pc) {
// TODO 个人客户提出的具体服务请求
System.out.println("客户" + pc.getName() + "提出服务请求");
}
}
public class ObjectStructure {
/**
* 要操作的客户集合
*/
private Collection<Customer> col = new ArrayList<Customer>();
/**
* 提供客户端操作的高层接口,具体的功能由客户端传入的访问者决定
* @param visitor 客户端需要的访问者
*/
public void handleRequest(Visitor visitor) {
for(Customer cm : col) {
cm.accept(visitor);
}
}
/**
* 组建对象结构,想对象中添加元素
* 不同的对象结构有不同的构建方式
* @param ele 加入到对象的结构元素
*/
public void addElement(Customer ele) {
this.col.add(ele);
}
}
public class Client {
public static void main(String[] args) {
ObjectStructure os = new ObjectStructure();
Customer cml = new EnterpriseCustomer();
cml.setName("ABC集团");
os.addElement(cml);
Customer cm2 = new EnterpriseCustomer();
cm2.setName("CDE公司");
os.addElement(cm2);
Customer cm3 = new PersonalCustomer();
cm3.setName("张三");
os.addElement(cm3);
ServiceRequestVisitor srVisitor = new ServiceRequestVisitor();
os.handleRequest(srVisitor);
PredilectionAnalyzeVisitor paVisitor = new PredilectionAnalyzeVisitor();
os.handleRequest(paVisitor);
WorthAnalyzeVisitor waVisitor = new WorthAnalyzeVisitor();
os.handleRequest(waVisitor);
}
}