抽象工厂模式讲解

Question

我正在研究设计模式并发现 Abstract Factory Pattern 根据定义是：

Abstract Factory Pattern says that just define an interface or abstract class for creating families of related (or dependent) objects but without specifying their concrete sub-classes.That means Abstract Factory lets a class returns a factory of classes.

但是我没能看透。我什至浏览了 this link and this question 中给出的一些示例，但没有任何帮助。

任何人都可以用一个简单、真实的生活示例提供清楚的解释 Abstract Factory Pattern 以及我们应该使用这种设计模式的情况。

Answer 1

这是在java

中实现的抽象工厂pattern.Its的流程

//创建一个shape接口和实现器classes shape

public interface Shape {
   void draw();
}

public class Rectangle implements Shape {

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

public class Square implements Shape {

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

//创建颜色接口及其实现者

public interface Color {
   void fill();
}

public class Red implements Color {

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


public class Blue implements Color {

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

//创建抽象工厂class，通常是一个class生成接口，或者用简单的语言来说，一个可以制造任何你想要的东西的工厂

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

//像你知道的普通工厂制造东西一样创建形状工厂。这是生产的工厂shapes.you只要给它起你想要的形状的名字它就会生产

public class ShapeFactory extends AbstractFactory {

   @Override
   public Shape getShape(String shapeType){

      if(shapeType == null){
         return null;
      }     

      if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();

      }else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }

      return null;
   }

   @Override
   Color getColor(String color) {
      return null;
   }
}

//颜色工厂。这是制造颜色的工厂。你只要给它一个你想要的颜色的名字，它就会制造出来

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("BLUE")){
         return new Blue();
      }

      return null;
   }
}

//生产工厂。现在这个class就像是投资人建设工厂。给它起个名字，它就会为你建造制造那个的工厂。

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;
   }
}

//这个是demo class 像庄家会请投资人建造型厂然后这个工厂可以制造矩形、正方形等。

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {

      //get shape factory
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");


      //get an object of Shape Rectangle
      Shape shape2 = shapeFactory.getShape("RECTANGLE");

      //call draw method of Shape Rectangle
      shape2.draw();

      //get an object of Shape Square 
      Shape shape3 = shapeFactory.getShape("SQUARE");

      //call draw method of Shape Square
      shape3.draw();

      //get color factory
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");

      //get an object of Color Red
      Color color1 = colorFactory.getColor("RED");

      //call fill method of Red
      color1.fill();


      //get an object of Color Blue
      Color color3 = colorFactory.getColor("BLUE");

      //call fill method of Color Blue
      color3.fill();
   }
}

Answer 2

抽象工厂的关键词是"families"。下面是我的一个非常简单的例子。

可以看到，Boss不需要知道是什么工厂，只要是VehichleFacotry即可。 Boss 只需调用 Build() 并创建相关 Vehicle。

abstract class Vehicle { }

class Car : Vehicle { }

class Bus : Vehicle { }

abstract class VehicleFactory 
{
    abstract Vehicle Build();    
}

class CarVehicleFactory : VehicleFacory
{
    Vehicle Build()
    {
        return new Car();
    }
}

class BusVehicleFactory : VehicleFacory
{
    Vehicle Build()
    {
        return new Bus();
    }
}

public class Boss
{
    public void Order(VehicleFactory factory)
    {
        var vehicle = factory.Build();
        //do something else ...
    }
}

public class Foo
{
    public void Bar()
    {
        var boss = new Boss();

        boss.Order(new CarVehicleFactory());
        boss.Order(new BusVehicleFactory());
    }
}

Answer 3

假设您正在设计一个页面，您需要在其中从服务器获取数据（使用分页）、触发一些分析事件并具有可自定义的视图。

现在您希望此页面足够通用，以供希望使用同一组功能的任何人使用。

那么有什么不同呢？

从中获取数据的端点。
您想为各种事件触发的分析（当用户滚动某些视图、单击某些视图、页面加载时、用户导航到下一页时等）
不同页面的不同菜单项。

您可以封装变化的内容并将它们放入单独的 classes 中。像这样

class MyPage {
  IDataFetcher datafetcher;
  IAnalyticsHelper analyticsHelper;
  IMenuBuilder menuBuilder;
}

现在您的 MyPage class 依赖于这些 classes 来呈现页面。但是，如果您仔细观察，这些是为了呈现页面而协同工作的算法系列。（一个重要提示，您可以使用抽象工厂）。

所以您可能可以将代码更改为：

public interface IPageAbstractFactory {
      IDataFetcher getDatafetcher();
      IAnalyticsHelper getAnalyticsHelper();
      IMenuBuilder getMenuBuilder();
}

class MyPage {
      IPageFactory factory;
    }

We just implemented an abstract factory!!! I hope my example is clear.

抽象工厂模式讲解

Abstract Factory Pattern Explanation

design-patterns

abstract-factory