抽象策略角色(Strategy)

具体策略角色(ConcreteStrategy)

环境角色(Context)

抽象策略角色

public interface Operation {
      public double  op(double a, double b);
}

添加4个具体策略角色类Add、Sub、Multi、Div

public class Add implements Operation {

       @Override
       public double op(double a, double b) {
              double result = a + b;
              return result;
        }
}
public class Sub implements  Operation {
     @Override
     public double op(double a, double b) {
            double result = a-b;
            return result;
     }
}
 public class Multi  implements  Operation {
    @Override
    public double op(double a, double b) {
           double result = a*b;
        return result;
    }
}
 public class Div  implements  Operation {
    @Override
    public double op(double a, double b) {
           double result = a/b;
        return result;
    }
}

环境角色

public class Calc {
      public static  final  Add add = new Add();
      public static  final  Sub sub = new Sub();
      public static  final  Div div = new Div();
      public static  final  Multi multi = new Multi();
}

测试类

public class Test {

    public static void main (String[] args) {
          Calc calc = new Calc();
          double add =   calc.add.op(11,22);
          double sub =  calc.sub.op(22,11);
          double div = calc.div.op(33,11);
          double multi = calc.multi.op(33,33);
          System.out.println(add);
          System.out.println(sub);
          System.out.println(div);
          System.out.println(multi);
     }
}

测试结果

 33.0
 11.0
 3.0
 1089.0

优点

缺点

方式一

public abstract class Book {
       // 价格
       private double price;
       // 书名称
       private String name;
       // 定义计算折扣的变量
       public abstract double getSalePrice();
       // 省略set()get()方法
}

儿童图书类

public class ChildrenBook extends  Book {

       public ChildrenBook (String name,double price) {
              this.setName(name);
              this.setPrice(price);
       }
       @Override
       public double getSalePrice() {
              return this.getPrice() -1;
       }
}

计算机类

public class CsBook extends Book {
    public CsBook (String name,double price) {
           this.setName(name);
           this.setPrice(price);
     }
     @Override
     public double getSalePrice() {
          return this.getPrice() * 0.7;
     }
}

测试类

public class Client {
    public static void main(String[] args) {
         // 方式一  在实现抽象类方法，在子类进行各自实现打折算法，即使打折算法相同。也要重写。
         Book book = new CsBook("Think in java",45);
         Book childrenBook = new ChildrenBook("安徒生的故事",20);
         System.out.println("Think in java原价："+book.getPrice() +"打折价："+book.getSalePrice());
         System.out.println("安徒生的故事原价："+childrenBook.getPrice() +"打折价："+childrenBook.getSalePrice());
   }
}

小结：

方式二

public abstract class Book {

       private double price;

       private String name;
       // 把打折策略代码提到父类来实现
       public static double toSalePrice (Book book) {
              double result = 0;
             if (book instanceof  ChildrenBook) {
                  result = book.getPrice() - 1;
             } else if (book instanceof  CsBook) {
                  result = book.getPrice() * 0.7;
             } else {
                  result = 0;
             }
              return result;
        }
}

测试类

public class Client {

        public static void main(String[] args) {
            Book book = new CsBook("Think in java",45);
            Book childrenBook = new ChildrenBook("安徒生的故事",20);
           System.out.println("Think in java原价："+book.getPrice() +"打折价："+ Book.toSalePrice(book));
           System.out.println("安徒生的故事原价："+childrenBook.getPrice() +"打折价："+ Book.toSalePrice(childrenBook));
        }
}

小结：

策略模式

抽象策略角色

public interface BookInterface {
       public double dissCount(double price);
}

具体实现角色(计算机图书类)

public class CalculationBook implements  BookInterface {
      @Override
      public double dissCount(double price) {
        double result = price * 0.7;
        return result;
      }
}

具体实现角色(儿童图书类)

public class ChildrenBook implements  BookInterface {
    @Override
    public double dissCount(double price) {
        double result = price - 1;
        return result;
    }
}

环境角色

public class DiscountStrategy {

    public final static CalculationBook book = new CalculationBook();
    public final static ChildrenBook childrenBook = new ChildrenBook();
}

在Book类添加折扣策略类

public abstract class Book {

      private double price;

      private String name;

      public abstract double getSalePrice();
      // 折扣策略
      private DiscountStrategy discountStrategy;
}

测试类

public class Client {

        public static void main(String[] args) {
            Book book = new CsBook("Think in java",45);
            Book childrenBook = new ChildrenBook("安徒生的故事",20);
            System.out.println("Think in java原价："+book.getPrice() +"打折价："+ book.getDiscountStrategy().book.dissCount(book.getPrice()));
            System.out.println("安徒生的故事原价："+childrenBook.getPrice() +"打折价："+ book.getDiscountStrategy().childrenBook.dissCount(childrenBook.getPrice()));

         }
}

小结：

作用

重点

注意啦! 往期文章目录在这里