01.工厂模式

今天药忘吃喽~ 2023-01-15 08:01 83阅读 0赞

### 工厂模式 ###

*  工厂模式
 *   *  介绍
     *   *  意图
         *  优点
         *  缺点
         *  注意事项
     *  Demo示例
     *   *  简单工厂模式
         *  工厂模式

# 工厂模式 #

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

## 介绍 ##

### 意图 ###

工厂模式定义了一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行

### 优点 ###

1、一个调用者想创建一个对象，只要知道其名称就可以了。

2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3、屏蔽产品的具体实现，调用者只关心产品的接口。

### 缺点 ###

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

### 注意事项 ###

作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

## Demo示例 ##

### 简单工厂模式 ###

我们将创建一个 *Shape* 接口和三个实现 *Shape* 接口的类。下一步是定义工厂类 *SimpleFactoryPattern*。

*FactoryPatternDemo* 类使用 *SimpleFactoryPattern*来获取 *Shape* 对象。它将向 *SimpleFactoryPattern*传递信息（*CIRCLE / RECTANGLE / SQUARE*），以便获取它所需对象的类型。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center]

1.  首先我们创建一个*Shape*接口
    
        /** * @Author Christy * @Date 2021/4/20 14:44 **/
        public interface Shape { 
            void draw();
        }
2.  创建*Shape*的三个实现类
    
        /** * @Author Christy * @Date 2021/4/20 14:51 **/
        public class Circle implements Shape { 
            @Override
            public void draw() { 
                System.out.println("Inside Circle::draw() method!");
            }
        }
    
        /** * @Author Christy * @Date 2021/4/20 14:49 **/
        public class Rectangle implements Shape { 
            @Override
            public void draw() { 
                System.out.println("Inside Rectangle::draw() method");
            }
        }
    
        /** * @Author Christy * @Date 2021/4/20 14:50 **/
        public class Square implements Shape { 
            @Override
        public void draw() { 
                System.out.println("Inside Square::draw() method!");
            }
        }
3.  定义类工厂*SimpleFactoryPattern*
    
        /** * * @Author Christy * @Date 2021/4/20 14:42 **/
        public class SimpleFactoryPattern { 
            public Shape getShape(String shapeType){ 
                if(!StringUtils.hasLength(shapeType)){ 
                    return null;
                }
        
                if(shapeType.equalsIgnoreCase("Rectangle")){ 
                    return new Rectangle();
                } else if(shapeType.equalsIgnoreCase("Square")){ 
                    return new Square();
                } else if(shapeType.equalsIgnoreCase("Circle")){ 
                    return new Circle();
                }
                return null;
            }
        }
4.  编写测试代码*FactoryPatternDemo*
    
        /** * @Author Christy * @Date 2021/4/20 14:55 **/
        public class FactoryPatternDemo { 
            public static void main(String[] args){ 
                SimpleFactoryPattern simpleFactoryPattern =  new SimpleFactoryPattern();
        				/******************** 简单工厂模式 ********************/
                /** 获取 Rectangle 的对象，并调用它的draw方法 **/
                Shape shape01 = simpleFactoryPattern.getShape("RECTANGLE");
                shape01.draw();
        
                /** 获取 Circle 的对象，并调用它的draw方法 **/
                Shape shape02 = simpleFactoryPattern.getShape("CIRCLE");
                shape02.draw();
        
                /** 获取 Circle 的对象，并调用它的draw方法 **/
                Shape shape03 = simpleFactoryPattern.getShape("SQUARE");
                shape03.draw();
            }
        }
5.  测试结果
    
    ![在这里插入图片描述][20210421195439821.png_pic_center]
6.  简单工厂存在的问题
    
    通过上面的代码我们可以发现一个问题：
    
    假如我先要增加一个**Triangle**该怎么办呢？首先我们需要定义一个类**Triangle**并继承**Shape**接口，像下面这样
    
        /** * @Author Christy * @Date 2021/4/21 14:39 **/
        public class Triangle implements Shape { 
            @Override
            public void draw() { 
                System.out.println("Inside Triangle::draw() method!");
            }
        }
    
    这样还不行，我们需要进一步修改**SimpleFactoryPattern**来返回一个Triangle才可以，像这样
    
        /** * * @Author Christy * @Date 2021/4/20 14:42 **/
        public class SimpleFactoryPattern { 
            public Shape getShape(String shapeType){ 
                if(!StringUtils.hasLength(shapeType)){ 
                    return null;
                }
        
                if(shapeType.equalsIgnoreCase("Rectangle")){ 
                    return new Rectangle();
                } else if(shapeType.equalsIgnoreCase("Square")){ 
                    return new Square();
                } else if(shapeType.equalsIgnoreCase("Circle")){ 
                    return new Circle();
                } else if(shapeType.equalsIgnoreCase("Triangle")){ 
                    return new Triangle();
                }
                return null;
            }
        }
    
    这样一来我们就发现该种写法违反了上一节00.认识设计模式中提到的6大设计原则中的第一条`开闭原则(只对扩展开放，对修改关闭)`。所以简单工厂模式**所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了**。

### 工厂模式 ###

基于上述简单工厂存在的缺点，我们看下工厂模式是如何解决这些问题的

1.  首先我们新建一个工厂模式接口类*FactoryPattern*
    
        /** * @Author Christy * @Date 2021/4/21 14:31 **/
        public interface FactoryPattern { 
            Shape createShapeFactory();
        }
2.  新建*RectangleFactory*、*CircleFactory*、*SquareFactory*、*TriangleFactory*四个工厂类分别实现上面定义的工厂模式类接口
    
        /** * @Author Christy * @Date 2021/4/21 15:01 **/
        public class RectangleFactory implements FactoryPattern { 
            @Override
            public Shape createShapeFactory() { 
                return new Rectangle();
            }
        }
    
        /** * @Author Christy * @Date 2021/4/21 15:07 **/
        public class CircleFactory implements FactoryPattern { 
            @Override
            public Shape createShapeFactory() { 
                return new Circle();
            }
        }
    
        /** * @Author Christy * @Date 2021/4/21 15:08 **/
        public class SquareFactory implements FactoryPattern { 
            @Override
            public Shape createShapeFactory() { 
                return new Square();
            }
        }
    
        /** * @Author Christy * @Date 2021/4/21 15:09 **/
        public class TriangleFactory implements FactoryPattern { 
            @Override
            public Shape createShapeFactory() { 
                return new Triangle();
            }
        }
3.  修改Demo示例*FactoryPatternDemo*
    
        /** * @Author Christy * @Date 2021/4/20 14:55 **/
        public class FactoryPatternDemo { 
            public static void main(String[] args){ 
                SimpleFactoryPattern simpleFactoryPattern =  new SimpleFactoryPattern();
                /******************** 简单工厂模式 ********************/
                /** 获取 Rectangle 的对象，并调用它的draw方法 **/
                Shape shape02 = simpleFactoryPattern.getShape("RECTANGLE");
                shape02.draw();
        
                /** 获取 Circle 的对象，并调用它的draw方法 **/
                Shape shape01 = simpleFactoryPattern.getShape("CIRCLE");
                shape01.draw();
        
                /** 获取 Circle 的对象，并调用它的draw方法 **/
                Shape shape03 = simpleFactoryPattern.getShape("SQUARE");
                shape03.draw();
        
        
                /******************** 工厂模式 ********************/
                /** RectangleFactory 生成 Shape 类调用 Rectangle 的 draw 方法 **/
                RectangleFactory rectangleFactory =  new RectangleFactory();
                Shape rectangle = rectangleFactory.createShapeFactory();
                rectangle.draw();
        
                /** CircleFactory 生成 Shape 类调用 Circle 的 draw 方法 **/
                CircleFactory circleFactory = new CircleFactory();
                Shape circle = circleFactory.createShapeFactory();
                circle.draw();
        
                /** CircleFactory 生成 Shape 类调用 Circle 的 draw 方法 **/
                SquareFactory squareFactory = new SquareFactory();
                Shape square = squareFactory.createShapeFactory();
                square.draw();
            }
        }
4.  测试结果
    
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center 1]

由此可以看到工厂模式没有简单工厂中违反开闭原则的缺点，而且符合面向对象的多态性；较之于简单工厂模式有更好的扩展性。假如后期我们想增加一个**Rhombus**，我们只要新建一个**RhombusFactory**并实现*FactoryPattern*即可。

至此，工厂模式我们就学习完了！工厂模式是23中设计模式中最简单的一种设计模式，从工厂模式开始学习也是由易到难、由简至繁的过程，继续加油吧O(∩\_∩)O哈哈~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/b11ee85daf1e48f791fcdedacdb94b5d.png
[20210421195439821.png_pic_center]: /images/20221022/202bd3799a664fdeaf8be54393817760.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221022/17d6084d2abb49a19fc0af761ffa5fcb.png