行为模式

  • 主要涉及到算法和对象之间的职责分配

责任链

使多个对象都有机会处理请求,避免发送者与接受者之间的耦合

  • 拥有动态添加职责的灵活性
  • 不保证被接受
public interface Filter {

    void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;
}
public class LoggingFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //...
    }
}

命令

将请求封装为对象

解释器

定义一个文法,定义一个解释器,解释器解释执行做一些操作

迭代器

提供一种顺序访问对象中的各个元素,并不暴露内部表示

  • 外部迭代与内部迭代的区别在于是由客户控制还是迭代器控制迭代
interface Iterator{
    hasNext();
    next();
}
class ArrayListItr implements Iterator{...}

中介者

用一个中介对象封装一系列对象之间的交互

  • 与外观模式不同之处在于中介模式的交互是双向的,而外观模式只是从外观对象到子系统之间的单向协议

备忘录

不破坏封装性的情况下,保存一个对象的内部状态

观察者

定义对象间一对多的依赖关系,依赖它的对象都会得到通知并自动更新

  • 具体目标与具体观察者之间是抽象耦合
  • 广播通信
  • 推模型与拉模型
abstract class Subject{
    add(Observer ob);
    del(Observer ob);
    notify();
}
interface Observer{
    update();
}
class ConcreteSubject{
    notify(){
        obServerlist.forEachNotify();
    }
}
class ConcreteObserver implements Observer{
    ...
}

状态

允许一个对象在其内部状态改变时改变它的行为

屏幕截图 2020-08-06 134707

  • 对象就是一个状态机,当从一个状态转移到另外一个状态,其行为就会发生改变
class LoginContext{
    private UserState state;
    login(){
        state.login()
    }
}
interface UserState{
    login();
}
class UserNormalState{
    login(){
        if (loginFailCount == 5){
            context.state = new UserBannedState();
        }
        print "login success";
    }
}
class UserBannedState{
    login(){
        print "you are banned";
    }
}

策略模式

封装一系列算法,以使它们可以互相替换

  • 策略模式与状态模式之间的区别在于状态模式的各个状态之间是有联系的

interface Strategy{
    void algorithm();
}

class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    void execute(){
        strategy.algorithm();
    }
}

class StrategyA implements Strategy{
    // 具体实现
}
// 使用
Context context = new Context(new StrategyA());
context.execute();

模板方法

在父类当中定以算法骨架,将一些步骤延迟到子类当中实现

实现一些操作时,整体步骤很固定,但是呢。就是其中一小部分容易变,这时候可以使用模板方法模式,将容易变的部分抽象出来,供子类实现

  • 钩子操作
abstract class BaseAlgorithm{
    void process(){
        process1();
        process2();
    }
    abstract void process1();
    abstract void process2();
}
class ConcreteAlgorithm extends BaseAlgorithm{
    // 实现方法
}
// 使用
BaseAlgorithm algorithm = new ConcreteAlgorithm();
algorithm.process();

访问者

表示一个作用于对象结构中的各元素的操作

识图避免新功能的引入造成接口的修改



results matching " "

No results matching " "

results matching " "

No results matching " "