工厂模式和策略模式的一些见解

1. 工厂模式

   1. 工厂，顾名思义，就是生产东西，故工厂模式就是创建实例
   2. 实现：
      1. 接口
      2. 实现类
      3. 工厂：根据某个条件来创建相应的实例
      4.  

         /**
          * 接口
          */
         public interface IProduct {
             void show();
         }
         
         /**
          * 实现类1
          */
         public class FruitProduct implements IProduct {
             @Override
             public void show() {
                 System.out.println("水果");
             }
         }
         
         /**
          * 实现类2
          */
         public class ClothesProduct implements IProduct {
             @Override
             public void show() {
                 System.out.println("衣服");
             }
         }
         
         /**
          * 工厂
          */
         public class CreateProductFactory {
         
             public IProduct getProduct(String productContent) {
                 /**
                  * 这里可以用策略模式来替代多个if
                  */
                 if ("水果".equals(productContent)) {
                     return new FruitProduct();
                 } else if ("衣服".equals(productContent)) {
                     return new ClothesProduct();
                 }
                 return null;
             }
         }
         
         
         /**
          * 客户端调用
          */
         public class FactoryTest {
             public static void main(String[] args) {
                 CreateProductFactory createProductFactory = new CreateProductFactory();
                 IProduct product = createProductFactory.getProduct("水果");
                 product.show();
                 // 如接口增加buy()方法，则要在客户端再写代码，增加耦合
                 product.buy();
             }
         }
         

          

2. 策略模式

   1. 策略模式，上下文策略类和接口的实现类是组合关系，一般通过构造方法传递参数决定接口实现类
   2. 实现，
      1. 接口
      2. 实现类
      3. 上下文策略类

      4. /**
          * 接口
          */
         public interface IProduct {
             void show();
         }
         
         /**
          * 实现类1
          */
         public class FruitProduct implements IProduct {
             @Override
             public void show() {
                 System.out.println("水果");
             }
         }
         
         /**
          * 实现类2
          */
         public class ClothesProduct implements IProduct {
             @Override
             public void show() {
                 System.out.println("衣服");
             }
         }
         
         
         /**
          * 上下文策略类
          */
         public class ContextStrategy {
             private IProduct product;
             private static Map<String, Class> map = new HashMap<String, Class>();
         
             static {
                 map.put("水果", FruitProduct.class);
                 map.put("衣服", ClothesProduct.class);
             }
         
             public ContextStrategy(String productContent) {
                 Class productClass = map.get(productContent);
                 try {
                     this.product = (IProduct) productClass.newInstance();
                 } catch (InstantiationException e) {
                     e.printStackTrace();
                 } catch (IllegalAccessException e) {
                     e.printStackTrace();
                 }
             }
         
             public void doShow(){
                 product.show();
                 // todo 可以执行 product的其他方法，如 buy()等等
             }
         }
         
         
         /**
          * 客户端调用
          */
         public class StrategyTest {
             public static void main(String[] args) {
                 ContextStrategy contextStrategy = new ContextStrategy("水果");
                 contextStrategy.doShow();
             }
         }
         

          

3. 工厂模式和策略模式的区分
   1. 工厂模式实现的功能，策略模式也可以实现
   2. 工厂模式注重创建实例，策略模式注重过程
   3. 如果接口增加了方法，则工厂模式需要在客户端再写方法，增加耦合，而策略模式则可以在封装的方法中实现方法增加，降低耦合。