策略模式与模板方法-优快云博客

第一类：通过父类与子类的关系进行实现。第二类：两个类之间。第三类：类的状态。第四类：通过中间类

13、策略模式（strategy）

策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数，关系图如下：

图中ICalculator提供同意的方法，
AbstractCalculator是辅助类，提供辅助方法，接下来，依次实现下每个类：

首先统一接口：

[java]view plaincopy 
   
 public interface ICalculator {  
     public int calculate(String exp);  
 }  

辅助类：

[java]view plaincopy 
   
 public abstract class AbstractCalculator {  
       
     public int[] split(String exp,String opt){  
         String array[] = exp.split(opt);  
         int arrayInt[] = new int[2];  
         arrayInt[0] = Integer.parseInt(array[0]);  
         arrayInt[1] = Integer.parseInt(array[1]);  
         return arrayInt;  
     }  
 }  

三个实现类：

[java]view plaincopy 
   
 public class Plus extends AbstractCalculator implements ICalculator {  
   
     @Override  
     public int calculate(String exp) {  
         int arrayInt[] = split(exp,"\\+");  
         return arrayInt[0]+arrayInt[1];  
     }  
 }  

[java]view plaincopy 
   
 public class Minus extends AbstractCalculator implements ICalculator {  
   
     @Override  
     public int calculate(String exp) {  
         int arrayInt[] = split(exp,"-");  
         return arrayInt[0]-arrayInt[1];  
     }  
   
 }  

[java]view plaincopy 
   
 public class Multiply extends AbstractCalculator implements ICalculator {  
   
     @Override  
     public int calculate(String exp) {  
         int arrayInt[] = split(exp,"\\*");  
         return arrayInt[0]*arrayInt[1];  
     }  
 }  

简单的测试类：

[java]view plaincopy 
   
 public class StrategyTest {  
   
     public static void main(String[] args) {  
         String exp = "2+8";  
         ICalculator cal = new Plus();  
         int result = cal.calculate(exp);  
         System.out.println(result);  
     }  
 }  

输出：10

策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。

14、模板方法模式（Template Method）

解释一下模板方法模式，就是指：一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用，先看个关系图：

就是在AbstractCalculator类中定义一个主方法calculate，calculate()调用spilt()等，Plus和Minus分别继承AbstractCalculator类，通过对AbstractCalculator的调用实现对子类的调用，看下面的例子：

[java]view plaincopy 
   
 public abstract class AbstractCalculator {  
       
     /*主方法，实现对本类其它方法的调用*/  
     public final int calculate(String exp,String opt){  
         int array[] = split(exp,opt);  
         return calculate(array[0],array[1]);  
     }  
       
     /*被子类重写的方法*/  
     abstract public int calculate(int num1,int num2);  
       
     public int[] split(String exp,String opt){  
         String array[] = exp.split(opt);  
         int arrayInt[] = new int[2];  
         arrayInt[0] = Integer.parseInt(array[0]);  
         arrayInt[1] = Integer.parseInt(array[1]);  
         return arrayInt;  
     }  
 }  

[java]view plaincopy 
   
 public class Plus extends AbstractCalculator {  
   
     @Override  
     public int calculate(int num1,int num2) {  
         return num1 + num2;  
     }  
 }  

测试类：

[java]view plaincopy 
   
 public class StrategyTest {  
   
     public static void main(String[] args) {  
         String exp = "8+8";  
         AbstractCalculator cal = new Plus();  
         int result = cal.calculate(exp, "\\+");  
         System.out.println(result);  
     }  
 }  

我跟踪下这个小程序的执行过程：首先将exp和"\\+"做参数，调用AbstractCalculator类里的calculate(String,String)方法，在calculate(String,String)里调用同类的split()，之后再调用calculate(int ,int)方法，从这个方法进入到子类中，执行完return num1 + num2后，将值返回到AbstractCalculator类，赋给result，打印出来。正好验证了我们开头的思路。

15、观察者模式（Observer）

包括这个模式在内的接下来的四个模式，都是类和类之间的关系，不涉及到继承，学的时候应该记得归纳，记得本文最开始的那个图。观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。先来看看关系图：

我解释下这些类的作用：MySubject类就是我们的主对象，Observer1和Observer2是依赖于MySubject的对象，当MySubject变化时，Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表，可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象。我们看实现代码：

一个Observer接口：

[java]view plaincopy 
   
 public interface Observer {  
     public void update();  
 }  

两个实现类：

[java]view plaincopy 
   
 public class Observer1 implements Observer {  
   
     @Override  
     public void update() {  
         System.out.println("observer1 has received!");  
     }  
 }  

[java]view plaincopy 
   
 public class Observer2 implements Observer {  
   
     @Override  
     public void update() {  
         System.out.println("observer2 has received!");  
     }  
   
 }  

Subject接口及实现类：

[java]view plaincopy 
   
 public interface Subject {  
       
     /*增加观察者*/  
     public void add(Observer observer);  
       
     /*删除观察者*/  
     public void del(Observer observer);  
       
     /*通知所有的观察者*/  
     public void notifyObservers();  
       
     /*自身的操作*/  
     public void operation();  
 }  

[java]view plaincopy 
   
 public abstract class AbstractSubject implements Subject {  
   
     private Vector<Observer> vector = new Vector<Observer>();  
     @Override  
     public void add(Observer observer) {  
         vector.add(observer);  
     }  
   
     @Override  
     public void del(Observer observer) {  
         vector.remove(observer);  
     }  
   
     @Override  
     public void notifyObservers() {  
         Enumeration<Observer> enumo = vector.elements();  
         while(enumo.hasMoreElements()){  
             enumo.nextElement().update();  
         }  
     }  
 }  

[java]view plaincopy 
   
 public class MySubject extends AbstractSubject {  
   
     @Override  
     public void operation() {  
         System.out.println("update self!");  
         notifyObservers();  
     }  
   
 }  

测试类：

[java]view plaincopy 
   
 public class ObserverTest {  
   
     public static void main(String[] args) {  
         Subject sub = new MySubject();  
         sub.add(new Observer1());  
         sub.add(new Observer2());  
           
         sub.operation();  
     }  
   
 }  

   转载至http://blog.youkuaiyun.com/zhangerqing/article/details/8243942 
 

java设计模式03