策略模式
诸葛亮有许多锦囊妙计,每个锦囊妙计都对应着不同的算法和策略,以便在他需要什么策略的时候随取随用。使用策略模式可以动态地让一个对象在许多行为中选择一种行为,避免使用多重条件判断。
step1:创建一个接口:motive
public interface motive {
public void opt();
}
step2:创建几个接口实现类
public class add implements motive {
@Override
public void opt() {
System.out.println("执行加法!");
}
}
public class delete implements motive {
@Override
public void opt() {
System.out.println("执行减法!");
}
}
step3:让我们创建一个诸葛亮
public class zhugeliang {
private motive motive;
void zhugeliang(){}
public void setMotive(motive motive){
this.motive = motive;
}
public void opt(){
motive.opt();
}
}
step4:创建测试类test来查看当它改变策略 motive 时的行为变化
public class test {
public static void main(String[] args) {
zhugeliang zgl = new zhugeliang();
zgl.setMotive(new add());
zgl.opt();
zgl.setMotive(new delete());
zgl.opt();
}
}
类图
输出
观察者模式
当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。观察者模式属于行为型模式。
step1:创建Subject接口和实现类
public interface iSubject {
void register(Observer observer);
void remove(Observer observer);
void notify(String message);
}
public class Subject implements iSubject {
private List<Observer> observers;
Subject(){
this.observers = new ArrayList<>();
}
@Override
public void register(Observer observer) {
observers.add(observer);
}
@Override
public void remove(Observer observer) {
observers.remove(observer);
}
@Override
public void notify(String message) {
for(Observer observer : observers){
observer.update(message);
}
}
}
step2:创建抽象Observer类
public abstract class Observer {
protected Subject subject;
public abstract void update(String message);
}
step3:创建实体类
public class ConcreteObserver1 extends Observer {
private Subject subject;
public ConcreteObserver1(Subject subject){
this.subject = subject;
this.subject.register(this);
}
@Override
public void update(String message){
System.out.println("更新信息1 "+message);
}
}
public class ConcreteObserver2 extends Observer {
private Subject subject;
public ConcreteObserver2(Subject subject){
this.subject = subject;
this.subject.register(this);
}
@Override
public void update(String message) {
System.out.println("更新信息2 " + message);
}
}
step4:创建测试类
public class ConcreteObserver2 extends Observer {
private Subject subject;
public ConcreteObserver2(Subject subject){
this.subject = subject;
this.subject.register(this);
}
@Override
public void update(String message) {
System.out.println("更新信息2 " + message);
}
}
类图
输出
Java内置了观察者模式的api,实现观察者模式非常简单,
[1]创建被观察者类,它继承自java.util.Observable类;
[2]创建观察者类,它实现java.util.Observer接口;
对象 | api | 描述 |
---|---|---|
被观察者 | void addObserver(Observer o) | 添加被观察者的观察者 |
被观察者 | setChanged(); notifyObservers(); | setChange()方法用来设置一个内部标志位注明数据发生了变化; notifyObservers()方法会去调用观察者对象列表中所有的Observer的update()方法,通知它们数据发生了变化。只有在setChange()被调用后,notifyObservers()才会去调用update()。 |
观察者 | void update(Observable o, Object arg) | 形参Object arg,对应一个由notifyObservers(Object arg);传递来的参数,当执行的是notifyObservers();时,arg为null。 |
step1:创建观察者
public class NumbServerable extends Observable {
private int data = 0;
int getData(){
return data;
}
public void setData(int data){
this.data = data;
setChanged();
notifyObservers();
}
}
step2:创建被观察者
public class NumbServer2 implements Observer {
public NumbServer2(NumbServerable numbServerable) {
super();
numbServerable.addObserver(this);//注册加入观察者
}
@Override
public void update(Observable o, Object arg) {
NumbServerable numbServerable = (NumbServerable)o;
System.out.println("Data2 has changed to " +numbServerable.getData());
}
}
public class NumbServer1 implements Observer {
public NumbServer1(NumbServerable numbServerable) {
super();
numbServerable.addObserver(this);//注册加入观察者
}
@Override
public void update(Observable o, Object arg) {
NumbServerable numbServerable = (NumbServerable)o;
System.out.println("Data1 has changed to " +numbServerable.getData());
}
}
step3:测试
public class test {
public static void main(String[] args) {
NumbServerable sm = new NumbServerable();
NumbServer1 a = new NumbServer1(sm);
NumbServer2 b = new NumbServer2(sm);
sm.setData(5);
sm.deleteObserver(a);//注销观察者,以后被观察者有数据变化就不再通知这个已注销的观察者
sm.setData(10);
}
}
输出