设计模式--策略模式

1、策略模式的定义：

策略模式定义了一系列的算法，并将每y一个算法封装起来，而且使它们之间可以相互替换。策略模式算法使它独立于客户而独立变化。

策略模式的目的是将定义和使用分开，也就是将算法的行为和环境分开。

策略模式是用来封装算法的，在实践中，我们发现它可以封装任何类型的规则。

使用的环境是：不同的条件，需要不同的算法，那么这种情况下，就可以使用策略模式。

2、根据以上定义，定义出策略模式的UML图形：

说明：将业务逻辑中共有的功能在策略的抽象类中或者接口中定义，然后定义具体的实现类，还有上下文类，这个类是控制具体的实现类实现具体的功能。

3、代码演示：

（1）、业务需求：

（2）、UML图设计：

（3）、代码编写：

目录结构（其中代码，首先由UML生成，再在其中编写具体的业务代码）：

o

Discount.java:

package celue_2;

public interface Discount {
 
   public abstract double calculate(double price);
}

ChildrenDiscount.java:

package celue_2;

public class ChildrenDiscount implements Discount {
   /**
    * @see Discount#calculate(double)
    */
   public double calculate(double price) {
      if (price >= 20) {
         double result = price - 10;
         return result;
      } else {
         return price;
      }
   }
}

StudentDiscount.java:

package celue_2;

public class StudentDiscount implements Discount {
 
   /**
    * @see Discount#calculate(double)
    */
   public double calculate(double price) {

      double result=price*0.8;
      return result;
   }
    
}

VipDiscount.java:

package celue_2;

public class VipDiscount implements Discount {
 
   /**
    * @see Discount#calculate(double)
    */
   public double calculate(double price) {
      double result=price*0.5;
      System.out.println("VIP积分");
      return result;
   }
    
}

MovieTicket.java:

package celue_2;

public class MovieTicket {

   private double price;
 
   private Discount discount;
    
   public double operate(double price) {

      double result=discount.calculate(price);
      return result;
   }

   public double getPrice() {
      double result=this.operate(this.price);
      return result;
   }

   public void setPrice(double price) {
      this.price = price;
   }

   public Discount getDiscount() {
      return discount;
   }

   public void setDiscount(Discount discount) {
      this.discount = discount;
   }
}

Test.java

package celue_2;

/**
 * Created by Administrator on 2017/4/23.
 */
public class Test {
    public static void main(String[] args) {
        MovieTicket movieTicket=new MovieTicket();
        StudentDiscount studentDiscount=new StudentDiscount();
        ChildrenDiscount childrenDiscount=new ChildrenDiscount();
        VipDiscount vipDiscount=new VipDiscount();

        movieTicket.setPrice(45);
        movieTicket.setDiscount(studentDiscount);
        System.out.println("学生的折扣后价格："+movieTicket.getPrice());

        movieTicket.setPrice(50);
        movieTicket.setDiscount(childrenDiscount);
        System.out.println("儿童的折扣后价格："+movieTicket.getPrice());

        movieTicket.setPrice(40);
        movieTicket.setDiscount(vipDiscount);
        System.out.println("VIP折扣后价格："+movieTicket.getPrice());
    }
}

4、策略模式的优缺点：

优点：

（1）、策略模式提供了一种算法的复用机制。策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或者行为。

（2）、策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族，恰当使用继承可以把公共的代码移到抽象策略类中，从而避免重复的代码。

（3）、使用策略模式可以避免多重条件选择语句。

缺点：

（1）、客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。

（2）、无法同时在客户端使用多个策略类，也就是说，在使用策略模式的时候，客户端只能每次使用一个策略类，不支持使用一个策略类完成部分功能后，由另外一个策略类来完成剩余的功能。

5、使用总结：

（1）、定义一个抽象超类，这个超类申明行为的变量，定义共有的方法，将需要每个子类实现的方法定义为抽象方法；
（2）、将行为定义为接口，每个不同的行为定义一个行为类，实现行为接口，将每种行为的实现类封装起来，它们之间可以互换；
（3）、定义超类的子类，使用多态的，在构造函数中，初始化超类中定义好的行为的变量，采用组合的方式，描述每个子类的特点，实现超类中抽象方法。
（4）、这个设计模式运用到了封装、继承、多态、抽象，涉及到的原则是变化封装、多用组合，少用继承、针对接口编程，不是实现编程。