三种工厂设计模式分别是:简单工厂设计模式、抽象工厂方法设计模式、工厂方法设计模式

短命女 2022-06-01 12:48 199阅读 0赞

1、简单工厂方法设计模式:

工厂模式：

工厂设计模式(Factory Pattern)是java当中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象的时候不会对客户端暴露创建逻辑，而是通过一个共同的接口来指向新创建的对象。

介绍：

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

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同的实例对象时候。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类中执行：

应用实例：

1.您需要一辆汽车，可以直接从工厂里面提货，而不用去管这量汽车是怎么做出来的，以及这个汽车里面的具体实现

2.Hibnernate中更换数据库只需要更换方言和驱动就可以了

优点：

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

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

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

缺点：

每次增加一个产品时，都需要增加一个具体的类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统的具体类的依赖，调用者只关心产品的接口。

使用场景：1、日志记录器：记录可能记录到本地硬盘、系统事件，远程服务器等，用户可以选择记录日志到什么地方。

2.数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。3、设计一个连接服务器的框架，需要三个协议，“POP3”“IMAP”“HTTP”，可以把这三个座位产品类，共同实现一个接口。

实现：

我们将创建一个Shape接口和实现Shape接口的实现类，下一步是定义工厂类 ShapeFactory

FactoryPatternDemo,我们的演示使用ShapeFactory来获取Shape对象，它将向ShapeFactory传递信息(CIRCLE/RECTANGLE/SQUARE),以便获取它所需要的对象的类型。

![SouthEast][]

### 步骤 1 ###

创建一个接口。

*Shape.java*

public interface Shape {
       
       void draw();
    }

### 步骤 2 ###

创建实现接口的实体类。

*Rectangle.java*

public class Rectangle implements Shape {
       
    
       @Override
       public void draw() {
       
          System.out.println("Inside Rectangle::draw() method.");
       }
    }

*Square.java*

public class Square implements Shape {
       
    
       @Override
       public void draw() {
       
          System.out.println("Inside Square::draw() method.");
       }
    }

*Circle.java*

public class Circle implements Shape {
       
    
       @Override
       public void draw() {
       
          System.out.println("Inside Circle::draw() method.");
       }
    }

### 步骤 3 ###

创建一个工厂，生成基于给定信息的实体类的对象。

*ShapeFactory.java*

public class ShapeFactory {
       
        
       //使用 getShape 方法获取形状类型的对象
       public Shape getShape(String shapeType){
       
          if(shapeType == null){
       
             return null;
          }        
          if(shapeType.equalsIgnoreCase("CIRCLE")){
       
             return new Circle();
          } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
       
             return new Rectangle();
          } else if(shapeType.equalsIgnoreCase("SQUARE")){
       
             return new Square();
          }
          return null;
       }
    }

### 步骤 4 ###

使用该工厂，通过传递类型信息来获取实体类的对象。

*FactoryPatternDemo.java*

public class FactoryPatternDemo {
       
    
       public static void main(String[] args) {
       
          ShapeFactory shapeFactory = new ShapeFactory();
    
          //获取 Circle 的对象，并调用它的 draw 方法
          Shape shape1 = shapeFactory.getShape("CIRCLE");
    
          //调用 Circle 的 draw 方法
          shape1.draw();
    
          //获取 Rectangle 的对象，并调用它的 draw 方法
          Shape shape2 = shapeFactory.getShape("RECTANGLE");
    
          //调用 Rectangle 的 draw 方法
          shape2.draw();
    
          //获取 Square 的对象，并调用它的 draw 方法
          Shape shape3 = shapeFactory.getShape("SQUARE");
    
          //调用 Square 的 draw 方法
          shape3.draw();
       }
    }

### 步骤 5 ###

验证输出。

Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.

## （使用小结） ##

##     ##

使用反射机制可以解决每次增加一个产品时，都需要增加一个对象实现工厂的缺点

public class ShapeFactory {
       
        public static Object getClass(Class<?extends Shape> clazz) {
       
            Object obj = null;
    
            try {
       
                obj = Class.forName(clazz.getName()).newInstance();
            } catch (ClassNotFoundException e) {
       
                e.printStackTrace();
            } catch (InstantiationException e) {
       
                e.printStackTrace();
            } catch (IllegalAccessException e) {
       
                e.printStackTrace();
            }
    
            return obj;
        }
    }

使用的使用采用强制转换

Rectangle rect = (Rectangle) ShapeFactory.getClass(Rectangle.class);
    rect.draw();
    Square square = (Square) ShapeFactory.getClass(Square.class);
    square.draw();

这样就只需要一个对象实现工厂

2.工厂方法设计模式

1、什么是工厂方法。

具体的工厂对象负责生产具体的产品对象；

2、补充说明

符合开放--封闭原则(OCP),新增产品时，只需新增工厂的实现类、产品的实现类，不修改原来的代码，工厂方法设计模式属于23种设计模式中的一种。

角色：

抽象工厂、具体工厂、抽象产品、具体产品、产品使用者

具体工厂继承抽象工厂

具体产品继承抽象产品

每个具体工厂负责生产对应的具体产品

产品使用者使用每个具体工厂生产的具体产品

案例如下：

类关系图：

![SouthEast 1][]![SouthEast 2][]

代码实现：

【抽象工厂】 定义一个工厂接口，包含一个创建实例的方法，如下：

package com.pichen.dp.creationalpattern.factorymethod;
    
    public interface IFatherFactory {
        public Father createFather(String name);
    }

【具体工厂】 定义两个具体工厂类，实现工厂接口，如下：

![复制代码][copycode.gif]

package com.pichen.dp.creationalpattern.factorymethod;
    
    public class ChineseFatherFactory implements IFatherFactory{
    
        @Override
        public Father createFather(String name) {
            return new ChineseFather(name);
        }
    
    }

package com.pichen.dp.creationalpattern.factorymethod;
    
    public class AmericanFatherFactory implements IFatherFactory{
    
        @Override
        public Father createFather(String name) {
            return new AmericanFather(name);
        }
    
    }

【抽象产品】 定义一个抽象产品类

package com.pichen.dp.creationalpattern.factorymethod;
    
    public abstract class Father {
        private String name;
    
        /**
         * @return the name
         */
        public String getName() {
            return name;
        }
    
        /**
         * @param name the name to set
         */
        public void setName(String name) {
            this.name = name;
        }
        
        public abstract void printName();
    }

【具体产品】定义两个具体产品类，继承抽象产品

package com.pichen.dp.creationalpattern.factorymethod;
    
    public class ChineseFather extends Father{
        public ChineseFather(String name) {
            this.setName(name);
        }
        @Override
        public void printName() {
            System.out.println(this.getClass().getName() + ":" + this.getName());
        }
    
    }

package com.pichen.dp.creationalpattern.factorymethod;
    
    public class AmericanFather extends Father{
        public AmericanFather(String name) {
            this.setName(name);
        }
        @Override
        public void printName() {
            System.out.println(this.getClass().getName() + ":" + this.getName());
        }
    
    }

【产品使用者】写个main函数，调用具体工厂类生产具体的产品

package com.pichen.dp.creationalpattern.factorymethod;
    
    public class Main {
        public static void main(String[] args) {
            IFatherFactory cnff = new ChineseFatherFactory();
            Father cnFather = cnff.createFather("cn father");
            cnFather.printName();
            
            IFatherFactory usff = new AmericanFatherFactory();
            Father usFather = usff.createFather("us father");
            usFather.printName();
        }
    
    }

3、抽象工厂设计模式

抽象工厂模式(Abstract Factory Pattern) 是一个围绕一个超级工厂创建其他工厂，该超级工厂又成为其他工厂的工厂。这种类型的设计模式属于创建型设计模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个对象相关的工厂，不需要显式的指定他们的类。每个生成的工厂都能按照工厂模式提供对象。

介绍：

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

主要解决：主要解决接口的选择问题 。

何时使用：系统的产品有多个于一个产品族，而系统只消费其中某一族的产品。

如何解决：在一个产品族里面，定义多个产品。

关键代码：在一个工厂里面聚合多个同类产品。

应用实例：工作了，为了参加一些聚会，肯定有两套或者多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装，商务男装，时尚女主，时尚男装，

这些都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜中只能存放某一种这样的衣服，(成套，一系列具体产品)，

每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用OO的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），

这些具体的上衣其实也都是上衣（具体产品），具体的裤子也都是裤子（另外一个抽象产品）。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的Creator里加代码，又要在具体的里面加代码。

使用场景：1、QQ换皮肤，一整套一起换。 2、生成不同草祖宗系统的程序

注意事项：产品族难扩展，产品登记易扩展。

实现：

我们将创建 Shape 和 Color接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类

ShapeFactory和ColorFactory，这两个工厂类都是扩展了AbstractFactory，然后创建一个工厂构造器，生成器类 FactoryProducer

AbstractFactoryPatternDemo,我们的演示类使用FactoryProducer来获取 AbstractFactory对象，它将想AbstractFactory传递形状信息Shape

(CIRCLE/RECTANGLE/SQUARE),以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color(RED/GREEN/BLUE),

以便获取它所需对象的类型..

![SouthEast 3][]

### 步骤 1 ###

为形状创建一个接口。

*Shape.java*

public interface Shape {
       
       void draw();
    }

### 步骤 2 ###

创建实现接口的实体类。

*Rectangle.java*

public class Rectangle implements Shape {
       
    
       @Override
       public void draw() {
       
          System.out.println("Inside Rectangle::draw() method.");
       }
    }

*Square.java*

public class Square implements Shape {
       
    
       @Override
       public void draw() {
       
          System.out.println("Inside Square::draw() method.");
       }
    }

*Circle.java*

public class Circle implements Shape {
       
    
       @Override
       public void draw() {
       
          System.out.println("Inside Circle::draw() method.");
       }
    }

### 步骤 3 ###

为颜色创建一个接口。

*Color.java*

public interface Color {
       
       void fill();
    }

### 步骤4 ###

创建实现接口的实体类。

*Red.java*

public class Red implements Color {
       
    
       @Override
       public void fill() {
       
          System.out.println("Inside Red::fill() method.");
       }
    }

*Green.java*

public class Green implements Color {
       
    
       @Override
       public void fill() {
       
          System.out.println("Inside Green::fill() method.");
       }
    }

*Blue.java*

public class Blue implements Color {
       
    
       @Override
       public void fill() {
       
          System.out.println("Inside Blue::fill() method.");
       }
    }

### 步骤 5 ###

为 Color 和 Shape 对象创建抽象类来获取工厂。

*AbstractFactory.java*

public abstract class AbstractFactory {
       
       abstract Color getColor(String color);
       abstract Shape getShape(String shape) ;
    }

### 步骤 6 ###

创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。

*ShapeFactory.java*

public class ShapeFactory extends AbstractFactory {
       
        
       @Override
       public Shape getShape(String shapeType){
       
          if(shapeType == null){
       
             return null;
          }        
          if(shapeType.equalsIgnoreCase("CIRCLE")){
       
             return new Circle();
          } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
       
             return new Rectangle();
          } else if(shapeType.equalsIgnoreCase("SQUARE")){
       
             return new Square();
          }
          return null;
       }
       
       @Override
       Color getColor(String color) {
       
          return null;
       }
    }

*ColorFactory.java*

public class ColorFactory extends AbstractFactory {
       
        
       @Override
       public Shape getShape(String shapeType){
       
          return null;
       }
       
       @Override
       Color getColor(String color) {
       
          if(color == null){
       
             return null;
          }        
          if(color.equalsIgnoreCase("RED")){
       
             return new Red();
          } else if(color.equalsIgnoreCase("GREEN")){
       
             return new Green();
          } else if(color.equalsIgnoreCase("BLUE")){
       
             return new Blue();
          }
          return null;
       }
    }

### 步骤 7 ###

创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。

*FactoryProducer.java*

public class FactoryProducer {
       
       public static AbstractFactory getFactory(String choice){
       
          if(choice.equalsIgnoreCase("SHAPE")){
       
             return new ShapeFactory();
          } else if(choice.equalsIgnoreCase("COLOR")){
       
             return new ColorFactory();
          }
          return null;
       }
    }

### 步骤 8 ###

使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

*AbstractFactoryPatternDemo.java*

public class AbstractFactoryPatternDemo {
       
       public static void main(String[] args) {
       
    
          //获取形状工厂
          AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
    
          //获取形状为 Circle 的对象
          Shape shape1 = shapeFactory.getShape("CIRCLE");
    
          //调用 Circle 的 draw 方法
          shape1.draw();
    
          //获取形状为 Rectangle 的对象
          Shape shape2 = shapeFactory.getShape("RECTANGLE");
    
          //调用 Rectangle 的 draw 方法
          shape2.draw();
          
          //获取形状为 Square 的对象
          Shape shape3 = shapeFactory.getShape("SQUARE");
    
          //调用 Square 的 draw 方法
          shape3.draw();
    
          //获取颜色工厂
          AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
    
          //获取颜色为 Red 的对象
          Color color1 = colorFactory.getColor("RED");
    
          //调用 Red 的 fill 方法
          color1.fill();
    
          //获取颜色为 Green 的对象
          Color color2 = colorFactory.getColor("Green");
    
          //调用 Green 的 fill 方法
          color2.fill();
    
          //获取颜色为 Blue 的对象
          Color color3 = colorFactory.getColor("BLUE");
    
          //调用 Blue 的 fill 方法
          color3.fill();
       }
    }

### 步骤 9 ###

验证输出。

Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.
    Inside Red::fill() method.
    Inside Green::fill() method.
    Inside Blue::fill() method.

总结一下三种设计模式：

简单工厂：不同的工厂生产不同的产品

抽象工厂：工厂的工厂，使用一个工厂去生产出工厂，然后在使用工厂再来生产我想要的产品

工厂方法：各自的工厂生产各自的产品

[SouthEast]: /images/20220601/e3c580f012bd45ff960ce205d99cf2cd.png
[SouthEast 1]: https://img-blog.csdn.net/20180301162100048?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvYmFpZHVfMjQ1NDU5MDE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 2]: /images/20220601/5db1eff040cc481a96bb114408c86703.png
[copycode.gif]: /images/20220601/3f78a92e848c475ab5fc0a74105ea83b.png
[SouthEast 3]: /images/20220601/6d8fc23aed7a4035b0372c6565d9c0ed.png