一. 观察者模式
1.定义观察者
/**
* 观察者接口
* @author ck
*/
abstract class Observer{
/** 观察者名称 */
private String name;
/** 构造函数,初始化观察者名称 */
public Observer(String name) {
this.name = name;
}
public String getName() {
return name;
}
/**
* 观察者更新状态
* @param subject 通知者
* @param event 事件信息
*/
public abstract void update(Subject subject, Object event);
}
/**
* 具体观察者:打游戏的观察者
* @author ck
*/
class GamingObserver extends Observer{
/** 构造函数,初始化打游戏的观察者 */
public GamingObserver(String name) {
super(name);
}
/** 更新状态 */
@Override
public void update(Subject subject, Object event) {
System.out.println(subject.getName()+":"+this.getName()+","+event+"别玩游戏了");
}
}
/**
* 具体的观察者:睡觉的观察者
* @author ck
*/
class SleepObserver extends Observer{
/** 构造函数,初始化睡觉的观察者名称 */
public SleepObserver(String name) {
super(name);
}
/** 更新状态 */
@Override
public void update(Subject subject, Object event) {
System.out.println(subject.getName()+":"+this.getName()+","+event+",别睡觉了");
}
}
2.定义通知者
/**
* 通知者接口
* @author ck
*/
abstract class Subject{
/** 通知者名称 */
private String name;
/** 构造函数,初始化通知者名称 */
public Subject(String name) {
this.name = name;
}
/**
* 添加观察者
* @param observer 观察者
*/
public abstract void addObserver(Observer observer);
/**
* 移除观察者
* @param observer 观察者
*/
public abstract void removeObserver(Observer observer);
/**
* 通知所有观察者
* @param event 事件信息
*/
public abstract void notifyAll(Object event);
/**
* 通知某一个观察者
* @param event 事件信息
* @param observer 观察者
*/
public abstract void notify(Object event, Observer observer);
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* 具体通知者
* @author ck
*/
class ConcreteSubject extends Subject{
/** 构造函数,初始化通知者名称 */
public ConcreteSubject(String name) {
super(name);
}
/** 观察者列表 */
private List<Observer> observerList = new ArrayList<Observer>();
/** 添加观察者 */
@Override
public void addObserver(Observer observer) {
if(observer==null) new NullPointerException("添加的观察者不能为空!");
if(!observerList.contains(observer)) observerList.add(observer);
}
/** 移除观察者 */
@Override
public void removeObserver(Observer observer) {
observerList.remove(observer);
}
/** 通知所有观察者 */
@Override
public void notifyAll(Object event) {
for (Observer observer : observerList) {
observer.update(this, event);
}
}
/** 通知某一个观察者 */
@Override
public void notify(Object event, Observer observer) {
if(observer!=null) observer.update(this, event);
}
}
3.运行测试
/**
* 观察者模式
* @author ck
*/
public class AbserverPattern {
public static void main(String[] args) {
//通知者
ConcreteSubject concreteSubject = new ConcreteSubject("前台mm");
//添加观察者
concreteSubject.addObserver(new GamingObserver("小明"));
concreteSubject.addObserver(new SleepObserver("大鹏"));
concreteSubject.notifyAll("老板来了");
}
}
4.运行结果
前台mm:小明,老板来了别玩游戏了
前台mm:大鹏,老板来了,别睡觉了
二. 事件委托
1.定义通知者
/**
* 通知者
* @author ck
*/
abstract class Notifier {
/** 事件处理器 */
private EventHandler eventHandler = new EventHandler();
public EventHandler getEventHandler() {
return eventHandler;
}
/**
* 添加事件监听
* @param object 执行的对象
* @param methodName 执行方法的方法名
* @param args 执行方法的参数
*/
public abstract void addListener(Object object, String methodName, Object... args);
/**
* 通知所有观察者
*/
public abstract void notifyX();
/**
* 通知某一个观察者
* @param object
*/
public abstract void notifySomeone(Object object);
}
/**
* 具体的通知者
* @author ck
*/
class GoodNotifier extends Notifier{
@Override
public void addListener(Object object, String methodName, Object... args) {
EventHandler eventHandler = this.getEventHandler();
eventHandler.addEvent(object, methodName, args);
}
@Override
public void notifyX() {
this.getEventHandler().notifyX();
}
@Override
public void notifySomeone(Object object) {
this.getEventHandler().notifySomeone(object);
}
}
2.事件处理器
/**
* 事件处理器
* @author ck
*/
class EventHandler{
/** 事件列表 */
private List<Event> events;
/** 构造函数,初始化事件处理器 */
public EventHandler() {
events = new ArrayList<Event>();
}
/**
* 添加事件
* @param object 观察者
* @param methodName 观察者的更新方法
* @param args 观察者更新方法的参数
*/
public void addEvent(Object object, String methodName, Object... args){
events.add(new Event(object, methodName, args));
}
/**
* 通知所有观察者
*/
public void notifyX(){
for (Event event : events) {
event.invoke();
}
}
/**
* 通知某一观察者
* @param object
*/
public void notifySomeone(Object object){
for (Event event : events) {
Object obj = event.getObject();
if(obj.equals(object)){
event.invoke();
}
}
}
}
/**
* 事件
* @author ck
*/
class Event{
/** 观察者 */
private Object object;
/** 观察者的更新方法 */
private String methodName;
/** 观察者更新方法的参数 */
private Object[] params;
/** 观察者更新方法的参数类型 */
private Class[] paramTypes;
public Event(){
}
/** 构造函数 */
public Event(Object object,String methodName,Object...args){
this.object=object;
this.methodName=methodName;
this.params=args;
contractParamTypes(this.params);
}
/** 根据参数数组生成参数类型数组 */
private void contractParamTypes(Object[] params){
if(params!=null && params.length>0){
this.paramTypes=new Class[params.length];
for(int i=0;i<params.length;i++){
this.paramTypes[i]=params[i].getClass();
}
}
}
/**
* 通过反射执行方法
*/
public void invoke() {
try {
Method method = object.getClass().getMethod(methodName, paramTypes);
if(method!=null) method.invoke(object, params);
} catch (Exception e) {
e.printStackTrace();
}
}
/** 获取观察者 */
public Object getObject() {
return object;
}
}
3.定义观察者
/**
* 打游戏的观察者
* @author ck
*/
class GamingListener{
public void stopGaming(){
System.out.println("关闭游戏,开始工作");
}
}
/**
* 睡觉的观察者
* @author ck
*/
class SleepListener{
public void wakeup(){
System.out.println("醒过来,上个厕所,继续工作");
}
}
4.运行测试
/**
* 事件委托
* @author ck
*/
public class EventNotifier {
public static void main(String[] args) {
//创建通知者
GoodNotifier goodNotifier = new GoodNotifier();
//创建观察者
GamingListener gamingListener = new GamingListener();
SleepListener sleepListener = new SleepListener();
//指定观察者更新方法
goodNotifier.addListener(gamingListener, "stopGaming");
goodNotifier.addListener(sleepListener, "wakeup");
//通知
goodNotifier.notifySomeone(gamingListener);
goodNotifier.notifySomeone(sleepListener);
// goodNotifier.notifyX();
}
}
5.运行结果
关闭游戏,开始工作
醒过来,上个厕所,继续工作
三.总结
未完待续…