GOF 23设计模式之（行为型模式二）

目录

1.状态模式

2.观察者模式

3.中介者模式

4.迭代器模式

五、状态模式（State）

      解决系统中复杂的状态转换和不同状态行为的封装问题。把复杂的判断逻辑提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

      核心角色：

• (1)环境角色(Context)：称为上下文。定义客户感兴趣的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
• (2)抽象状态角色(State)：定义一个接口，用于封装环境对象中待定状态所对应的行为。
• (3)具体状态角色(Concrete State)：实现抽象状态所对应的行为。

      优点：

• (1)将特定状态相关的行为局部化到一个状态中，并将不同状态的行为分割开，满足单一职责原则。
• (2)减少对象间的互相依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确。
• (3)有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

      缺点：

• (1)使用必然会增加系统的类与对象的个数。
• (2)其结构与实现都比较复杂。

public class textCommand {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        Context context = new Context();
        context.Handle();
        context.Handle();
        context.Handle();
    }
}

//环境类
class Context{
    
    private State state;
    
    public Context() { //定义环境类的初始状态
        
        this.state = new ConcreteStateA();
    }

    
    //设置新的状态
    public void setState(State state) {
        this.state = state;
    }
    
    //读取状态
    public State getState() {
        return state;
    }
    
    //对请求做处理
    public void Handle() {
        
        state.Handle(this);
    }
    
}

//抽象状态类
abstract class State{
    
    public abstract void Handle(Context context);
}

//具体状态类A
class ConcreteStateA extends State{

    @Override
    public void Handle(Context context) {
        System.out.println("当前状态A");
        context.setState(new ConcreteStateB());
    }
}

//具体状态类B
class ConcreteStateB extends State{

    @Override
    public void Handle(Context context) {
        System.out.println("当前状态B");
        context.setState(new ConcreteStateA());
    }
}

返回顶部

六、观察者模式

      指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式又称为发布-订阅模式、模型-视图模式。

      核心角色：

• (1)抽象主题角色(Subject)：也叫抽象目标类，一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
• (2)具体主题角色(Concrete Subject)：也叫具体目标类，实现抽象目标中的方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
• (3)抽象观察者角色(Observer)：是一个抽象类或者接口。包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
• (4)具体观察者角色(Concrete Observer)：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

      优点：

• (1)降低目标与观察者之间的耦合关系，两者之间是抽象耦合。
• (2)目标观察者时间建立了一套触发机制。

      缺点：

• (1)目标与观察者的依赖关系没有完全解除，而且可能出现循环引用。
• (2)当观察者对象很多时，通知发布会花很多时间，影响程序的效率。

public class textCommand {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        //模拟电台与收音机。
        //如果电台中换了播放的节目。那所有真再收听的收音机也会对应变化。
        
        Subject dt = new ConcreteSubject();//电台节目
        
        Observer syA = new ConcreteObserverA();//创建收音设备
        Observer syB = new ConcreteObserverB();
        
        dt.add(syA); //正在收音的设备
        dt.add(syB);
        
        //原来播放的节目
        dt.notifyObserver("乡村爱情故事");
        System.out.println("-------------");
        
        //电台改变节目
        dt.notifyObserver("王牌对王牌");
        
    }
}

//抽象目标 （电台）
abstract class Subject{
    
    protected List<Observer> observers = new ArrayList<Observer>();
    
    //增加观察者方法
    public void add(Observer observer) {
        observers.add(observer);
    }
    
    //删除观察者方法
    public void remove(Observer observer) {
        observers.remove(observer);
    }
    
    //通知观察者方法
    public abstract void notifyObserver(String show);//设置一个参数
}

//具体目标 （节目）
class ConcreteSubject extends Subject{

    @Override
    public void notifyObserver(String show) {
        System.out.println("电台播放<"+show+">节目");
        
        for (Observer obs : observers) {
            ((Observer)obs).response(show);
        }
    }
}

//抽象观察者 （收音设备）
interface Observer{
    void response(String show);//定义一个参数
}

//具体观察者A    （收音机A）
class ConcreteObserverA implements Observer{

    @Override
    public void response(String show) {
        System.out.println("收音机A正在播放<"+show+">节目");
    }
}

//具体观察者B（收音机A）
class ConcreteObserverB implements Observer{

    @Override
    public void response(String show) {
        System.out.println("收音机A正在播放<"+show+">节目");
    }
}

返回顶部

三、中介者模式（Mediator）

      定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，可以独立地改变他们之间的交互。又叫调停模式，是迪米特法则的典型应用。

      核心角色:

• (1)抽象中介者角色(Mediator)：提供同事对象注册与转发同事对象信息的抽象方法。
• (2)具体中介者角色(Concrete Mediator)：实现中介者接口，定义一个List来管理同事对象，协调各个同事角色之间的交互关系，因此依赖于同事角色。
• (3)抽象同事类角色(Colleague)：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
• (4)具体同事类角色(Concrete Colleague)：抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

      优点：

• (1)降低对象之间的耦合性，使得对象易于独立地被复用。
• (2)将对象间的一对多关联，转变为一对一的关联，提高系统的灵活性。

      缺点：

• (1)当同事类太多，中介者的职责将很大，会变得复杂而庞大，系统难于维护。

public class textMediator {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        Mediator md = new ConcreteMediator();
        
        Colleague c1 = new ConcreteColleagueA();
        Colleague c2 = new ConcreteColleagueB();
        
        md.register(c1);
        md.register(c2);
        c1.send();
        
        System.out.println("----------");
        c2.send();
        
        
    } 
}

//抽象中介者 
abstract class Mediator{
    
    public abstract void register(Colleague colleague);
    public abstract void relay(Colleague cl);//转发
}

//具体中介者
class ConcreteMediator extends Mediator{

    private List<Colleague> colleagues = new ArrayList<Colleague>();
    
    @Override
    public void register(Colleague colleague) {
        
        if(!colleagues.contains(colleague)) {
            colleagues.add(colleague);
            colleague.setMediator(this);
        }
    }

    @Override
    public void relay(Colleague cl) {
        
        for (Colleague ob : colleagues) {
            if(!ob.equals(cl)) {
                ((Colleague)ob).recevie();
            }
        }
    }
}

//抽象同事类
abstract class Colleague{
    
    protected Mediator mediator;
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
    
    public abstract void recevie();
    public abstract void send();
}

//具体同事类A
class ConcreteColleagueA extends Colleague{

    @Override
    public void recevie() {
        System.out.println("具体同事类A收到请求");
    }

    @Override
    public void send() {
        System.out.println("具体同事类A发出请求");
        mediator.relay(this);//请中介者转发
    }
}

//具体同事类B 
class ConcreteColleagueB extends Colleague{

    @Override
    public void recevie() {
        System.out.println("具体同事类B收到请求");
    }

    @Override
    public void send() {
        System.out.println("具体同事类B发出请求");
        mediator.relay(this); //请中介者转发
    }
}

返回顶部

四、迭代器模式（Iterator）

      提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。就是在不透露聚合对象内部的结构的情况下，让外部代码透明地访问聚合的内部数据。

      核心角色：

• (1)抽象聚合角色(Aggregate)：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
• (2)具体聚合角色(Concrete Aggregate)：实现抽象聚合类，返回一个具体迭代器的实例。
• (3)抽象迭代器角色(Iterator)：定义访问和遍历聚合元素的接口，通常包含hasNext()、first()、next()等方法。
• (4)具体迭代器角色(Concrete Iterator)：实现抽象迭代器接口中定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

      优点：

• (1)访问一个聚合对象的内容，无需暴露它的内部表示。
• (2)遍历任务交给迭代器完成，简化了聚合类。
• (3)支持不同方式遍历一个聚合，并且可以自定义迭代器的子类来支持新的遍历。
• (4)增加新的聚合和迭代器类不需要修改原有代码。
• (5)封装性良好，为遍历不同的聚合结构提供一个统一的接口。

      缺点：

• (1)增加类的的个数，在一定程度上增加了系统的复杂性。

public class textAggregate {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
        Aggregate ag = new ConcreteAggregate();//所有内聚对象
        ag.add("第一个内聚");
        ag.add("第二个内聚");
        ag.add("第三个内聚");
        
        Iterator iterator = ag.getIterator();//获取内聚对象
        
        while(iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next.toString());
        }
    } 
}

//抽象聚合
interface Aggregate{
    
    public void add(Object obj);
    public void remove(Object obj);
    public Iterator getIterator();
    
}

//具体聚合
class ConcreteAggregate implements Aggregate{

    private List<Object> list = new ArrayList<Object>();
    
    @Override
    public void add(Object obj) {
        list.add(obj);
    }

    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }

    @Override
    public Iterator getIterator() {
        
        return (new ConcreteIterator(list));
    }
}

//抽象迭代器
interface Iterator{
    
    Object frist();
    Object next();
    boolean hasNext();
}

//具体迭代器
class ConcreteIterator implements Iterator{
    
    private List<Object> list = null;
    private int index = 0;
    
    public ConcreteIterator(List<Object> list) {
        this.list = list;
    }

    @Override
    public Object frist() {
        
        index = 0;
        Object obj = list.get(index);
        
        return obj;
    }

    @Override
    public Object next() {
    
        Object obj = null;
        
        if(this.hasNext()) {
            obj = list.get(index++);
        }
        
        return obj;
    }

    @Override
    public boolean hasNext() {
        
        if(index >= list.size()) {
            return false;
        }else {
            return true;
        }
        
    }
}

返回顶部