工厂模式，工厂方法模式，抽象工厂模式 详解



1. 工厂模式

1.1 描述

简单工厂模式是由一个工厂对象根据收到的消息决定要创建哪一个类的对象实例。

1.2 使用场景

工厂类负责创建的对象比较少，客户只需要传入工厂类参数，对于如何创建对象（逻辑）不关心。简单工厂模式很容易违反高内聚低耦合的原则，因此一般只在很简单的情况下使用。

1.3 优点

最大的优点在于工厂类中包含了必要的逻辑，根据客户需要的逻辑动态实例化相关的类。

1.4 例子

[java] view plain copypublic interface Shape {  
      
    public void draw();  
      
}  
[java] view plain copypublic class Circle implements Shape {  
  
    @Override  
    public void draw() {  
        System.out.println("Inside Circle::draw() method.");  
    }  
  
}  
[java] view plain copypublic class Rectangle implements Shape {  
  
    @Override  
    public void draw() {  
        System.out.println("Inside Rectangle::draw() method.");  
    }  
  
}  
[java] view plain copypublic class Square implements Shape {  
  
    @Override  
    public void draw() {  
        System.out.println("Inside Square::draw() method.");  
    }  
  
}  
[java] view plain copypublic class ShapeFactory {  
      
    public Shape getShape(String type) {  
        if ("circle".equals(type)) {  
            return new Circle();  
        } else if ("rectangle".equals(type)) {  
            return new Rectangle();  
        } else if ("square".equals(type)) {  
            return new Square();  
        } else {  
            return null;  
        }  
    }  
      
}  
[java] view plain copypublic class FactoryPatternDemo {  
      
    public static void main(String[] args) {  
        ShapeFactory shapeFactory = new ShapeFactory();  
        shapeFactory.getShape("circle").draw();  
        shapeFactory.getShape("rectangle").draw();  
        shapeFactory.getShape("square").draw();  
    }  
  
}  

2. 工厂方法模式

2.1 描述

定义一个创建对象的工厂接口，让子类决定实例化哪一个类，将实际创建工作推迟到子类当中。

2.2 使用场景

 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

2.3 优点

创建对象的接口，让子类决定具体实例化的对象，把简单的内部逻辑判断移到了客户端。工厂方法模式克服了简单工厂所违背的开闭原则的缺点，又保持了封装对象创建过程的优点。扩展性高，想要增加一个产品，只要扩展一个工厂类就可以。

2.4 例子

[java] view plain copypublic interface ShapeFactory {  
      
    public Shape getShape();  
      
}  
[java] view plain copypublic class CircleFactory implements ShapeFactory {  
  
    @Override  
    public Shape getShape() {  
        return new Circle();  
    }  
  
}  
[java] view plain copypublic class RectangleFactory implements ShapeFactory {  
  
    @Override  
    public Shape getShape() {  
        return new Rectangle();  
    }  
  
}  
[java] view plain copypublic class SquareFactory implements ShapeFactory {  
  
    @Override  
    public Shape getShape() {  
        return new Square();  
    }  
  
}  
[java] view plain copypublic class FactoryMethodDemo {  
      
    public static void main(String[] args) {  
        ShapeFactory circleFactory = new CircleFactory();  
        circleFactory.getShape().draw();  
        ShapeFactory rectangleFactory = new RectangleFactory();  
        rectangleFactory.getShape().draw();  
        ShapeFactory squareFactory = new SquareFactory();  
        squareFactory.getShape().draw();  
    }  
  
}  

3. 抽象工厂

3.1 描述

抽象工厂是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

3.2 使用场景

系统的产品多于一个产品族，而系统只消费某一族的产品。

3.3 优点

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

3.4 例子

[java] view plain copypublic interface Button {  
      
    public void processEvent();  
      
}  
[java] view plain copypublic interface Text {  
      
    public void getWholeText();  
      
}  
[java] view plain copypublic class LinuxButton implements Button {  
  
    @Override  
    public void processEvent() {  
        System.out.println("Inside LinuxButton::processEvent() method.");  
    }  
  
}  
[java] view plain copypublic class WindowsButton implements Button {  
  
    @Override  
    public void processEvent() {  
        System.out.println("Inside WindowsButton::processEvent() method.");  
    }  
  
}  
[java] view plain copypublic class LinuxText implements Text {  
  
    @Override  
    public void getWholeText() {  
        System.out.println("Inside LinuxText::getWholeText() method.");  
    }  
  
}  
[java] view plain copypublic class WindowsText implements Text {  
  
    @Override  
    public void getWholeText() {  
        System.out.println("Inside WindowsText::getWholeText() method.");  
    }  
  
}  
[java] view plain copypublic interface AbstractFactory {  
      
    public Button createButton();  
      
    public Text createText();  
  
}  
[java] view plain copypublic class LinuxFactory implements AbstractFactory {  
  
    @Override  
    public Button createButton() {  
        return new LinuxButton();  
    }  
  
    @Override  
    public Text createText() {  
        return new LinuxText();  
    }  
  
}  
[java] view plain copypublic class WindowsFactory implements AbstractFactory {  
  
    @Override  
    public Button createButton() {  
        return new WindowsButton();  
    }  
  
    @Override  
    public Text createText() {  
        return new WindowsText();  
    }  
  
}  
[java] view plain copypublic class AbstractFactoryDemo {  
      
    public static void main(String[] args) {  
        AbstractFactory linuxFactory = new LinuxFactory();  
        linuxFactory.createButton().processEvent();  
        linuxFactory.createText().getWholeText();  
        AbstractFactory windowsFactory = new WindowsFactory();  
        windowsFactory.createButton().processEvent();  
        windowsFactory.createText().getWholeText();  
    }  
  
}  

4. 总结

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
       所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。