行为型模式

1.策略模式

2.责任链模式

3.模板方法模式

4.观察者模式

5.迭代子模式

6.命令模式

7.备忘录模式

8.状态模式

9.访问者模式

10.中介者模式

11.解释器模式

1.策略模式

定义：定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。
解决问题：在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。将这些算法封装成一个一个的类，任意地替换。
主要角色：
- 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
- 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
- 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

实现：

//抽象策略
public interface Strategy {
   public int doOperation(int num1, int num2);
}
//具体策略
public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}
//Context上下文
public class Context {
   private Strategy strategy;
     
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
     
   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}
//使用
//其中创建哪个具体策略可以有条件触发创建具体的策略。
 Strategy strategy = new OperationAdd(); 
 Context context = new Context(strategy);    
 System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

应用场景：
- java Comparator,Collections.sort相当于context,Comparator相当于抽象策略，具体的Comparator为具体策略。
ps：comparator和Comparable的区别
- Comparable 是一个接口。若一个类实现了Comparable接口，就意味着“该类支持排序”。可以通过Collections.sort(list)或 Arrays.sort(list)进行排序。
- Comparator 是比较器接口。如果需要对某个类的进行排序，但是该类本身不支持排序(即没有实现Comparable接口)；那么，可以通过建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。可以通过Collections.sort(list,ConcreteComparator)或 Arrays.sort(list,ConcreteComparator)进行排序。

2.责任链模式

定义：职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。
主要角色：
- 抽象处理者（Handler）：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
- 具体处理者（Concrete Handler）：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
- 客户类（Client）：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

实现：

//抽象处理者角色
abstract class Handler
{
    private Handler next;
    public void setNext(Handler next)
    {
        this.next=next; 
    }
    public Handler getNext()
    { 
        return next; 
    }   
    //处理请求的方法
    public abstract void handleRequest(String request);       
}
//具体处理者角色1
class ConcreteHandler1 extends Handler
{
    public void handleRequest(String request)
    {
        if(request.equals("one")) 
        {
            System.out.println("具体处理者1负责处理该请求！");       
        }
        else
        {
            if(getNext()!=null) 
            {
                getNext().handleRequest(request);             
            }
            else
            {
                System.out.println("没有人处理该请求！");
            }
        } 
    } 
}
//具体处理者角色2
class ConcreteHandler2 extends Handler
{
    public void handleRequest(String request)
    {
        if(request.equals("two")) 
        {
            System.out.println("具体处理者2负责处理该请求！");       
        }
        else
        {
            if(getNext()!=null) 
            {
                getNext().handleRequest(request);             
            }
            else
            {
                System.out.println("没有人处理该请求！");
            }
        } 
    }
}
//应用
//组装责任链 
Handler handler1=new ConcreteHandler1(); 
Handler handler2=new ConcreteHandler2(); 
handler1.setNext(handler2); 
//提交请求 
handler1.handleRequest("two");

应用场景：
- java web中的过滤器。chain.doFilter()方法。

3.模板方法模式

定义：封装了不变部分，扩展可变部分。把不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
角色：
- 抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下。
  - 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。
  - 基本方法：是整个算法中的一个步骤，包含以下几种类型。
    - 抽象方法：在抽象类中申明，由具体子类实现。
    - 具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
    - 钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。
- 具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。

实现：

//抽象类
abstract class AbstractClass
{
    public void TemplateMethod() //模板方法
    {
        SpecificMethod();
        abstractMethod1();          
         abstractMethod2();
    }  
    public void SpecificMethod() //具体方法
    {
        System.out.println("抽象类中的具体方法被调用...");
    }   
    public abstract void abstractMethod1(); //抽象方法1
    public abstract void abstractMethod2(); //抽象方法2
}
//具体子类
class ConcreteClass extends AbstractClass
{
    public void abstractMethod1()
    {
        System.out.println("抽象方法1的实现被调用...");
    }   
    public void abstractMethod2()
    {
        System.out.println("抽象方法2的实现被调用...");
    }
}
//使用
AbstractClass tm=new ConcreteClass();
tm.TemplateMethod();

应用：
- java.util.AbstractList的所有非抽象方法

4.观察者模式

定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
角色：
- 抽象主题（Subject）：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
- 具体主题（Concrete Subject）：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
- 抽象观察者（Observer）：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
- 具体观察者（Concrete Observer）：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

实现：

//抽象目标
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(); //通知观察者方法
}
//具体目标
class ConcreteSubject extends Subject
{
    public void notifyObserver()
    {
        System.out.println("具体目标发生改变...");
        System.out.println("--------------");       
           
        for(Object obs:observers)
        {
            ((Observer)obs).response();
        }
           
    }          
}
//抽象观察者
interface Observer
{
    void response(); //反应
}
//具体观察者1
class ConcreteObserver1 implements Observer
{
    public void response()
    {
        System.out.println("具体观察者1作出反应！");
    }
}
//具体观察者1
class ConcreteObserver2 implements Observer
{
    public void response()
    {
        System.out.println("具体观察者2作出反应！");
    }
}
//使用
Subject subject=new ConcreteSubject();
Observer obs1=new ConcreteObserver1();
Observer obs2=new ConcreteObserver2();
subject.add(obs1);
subject.add(obs2);
subject.notifyObserver();

行为型模式

行为型模式

1.策略模式

2.责任链模式

3.模板方法模式

4.观察者模式

5.迭代子模式

6.命令模式

7.备忘录模式

8.状态模式

9.访问者模式

10.中介者模式

11.解释器模式

1.策略模式

2.责任链模式

3.模板方法模式

4.观察者模式

5.迭代子模式

6.命令模式

7.备忘录模式

8.状态模式

9.访问者模式

10.中介者模式

11.解释器模式

See Also

最近文章

分类

标签