Java设计模式-创建型模式之工厂模式

1. 简单工厂模式：

   /**
    * 产品基类
    * @author Administrator
    */
   public interface IProduct {
   
       /**
        * 产品描述
        */
       void description();
   }
   
   public class ProductA implements IProduct {
   
       @Override
       public void description() {
           System.out.println("This is product A!");
       }
   }
   
   public class ProductB implements IProduct {
       @Override
       public void description() {
           System.out.println("This is product B!");
       }
   }

   工厂类：

   /**
    * @author  Java设计模式-创建型模式之工厂模式
    * @description 简单工厂模式：
    *      缺点：新增产品时，需要新增产品类并修改工厂类。(扩展性差)
    * @date 2019-04-12 15:08
    */
   public class ProductFactory {
       private static final int PRODUCT_A = 1;
       private static final int PRODUCT_B = 2;
   
       public static IProduct getProductByType(int type){
           switch (type){
               case PRODUCT_A:
                   return new ProductA();
               case PRODUCT_B:
                   return new ProductB();
               default:
                   return new ProductA();
           }
       }
   
       public static void main(String[] args) {
           IProduct project = ProductFactory.getProductByType(ProductFactory.PRODUCT_A);
           project.description();
       }
   }

    

2. 工厂方法模式：

   提供一个用于创建对象的接口(工厂接口)，让其实现类(工厂实现类)决定实例化哪一个类(产品类)，并且由该实现类创建对应类的实例。

   public interface IFactory {
       /**
        * 创建产品
        * @param productType
        * @return
        */
       IProduct createProduct(String productType);
   }
   
   public class ProductFactory implements IFactory {
   
       private static final String PRODUCT_A = "A";
       private static final String PRODUCT_B = "B";
   
       IProduct product;
       Map<String, Object> productParam = new HashMap<String, Object>();
   
       @Override
       public IProduct createProduct(String productType) {
           switch (productType){
               case PRODUCT_A:
                   product = new ProductA();
                   productParam.put("param", "A");
                   break;
               case PRODUCT_B:
                   product = new ProductB();
                   productParam.put("param", "B");
                   break;
               default:
                   product = new ProductB();
                   productParam.put("param", "B");
           }
           product.setProductParam(productParam);
           return product;
       }
   
       public static void main(String[] args) {
           ProductFactory productFactory = new ProductFactory();
           IProduct product;
           try {
               product = productFactory.createProduct("A");
               product.description();
               product = productFactory.createProduct("B");
               product.description();
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   
   

   产品相关：

   public interface IProduct {
       /**
        * 获取生产产品参数
        * @return
        */
       Map<String, Object> getProductParam();
   
       /**
        * 设置生产产品参数
        */
       void setProductParam(Map<String, Object> productParam);
   
       /**
        * 产品描述
        */
       void description() throws Exception;
   }
   
   public class AbstractProduct implements IProduct {
   
       private Map<String, Object> productParam;
   
       @Override
       public Map<String, Object> getProductParam() {
           return productParam;
       }
   
       @Override
       public void setProductParam(Map<String, Object> productParam) {
           this.productParam = productParam;
       }
   
       @Override
       public void description() throws Exception {
   
       }
   }
   
   public class ProductA extends AbstractProduct{
   
       @Override
       public void description() throws Exception{
           Map<String, Object> productParam = getProductParam();
           if(productParam==null){
               throw new Exception("参数不能为空！");
           }else {
               System.out.println("productParam="+productParam.get("param"));
           }
           System.out.println("This is product A!");
       }
   }
   
   public class ProductB extends AbstractProduct{
   
       @Override
       public void description() throws Exception{
           Map<String, Object> productParam = getProductParam();
           if(productParam==null){
               throw new Exception("参数不能为空！");
           }else {
               System.out.println("productParam="+productParam.get("param"));
           }
           System.out.println("This is product B!");
       }
   }