Java设计模式 - 抽象工厂模式

抽象工厂模式是另一个创建模式。
抽象工厂模式，也称为工厂的工厂，有一个工厂创建其他工厂。
当使用抽象工厂模式时，我们首先使用超级工厂创建工厂，然后使用创建的工厂创建对象。
简单来说，抽象工厂模式就是在工厂模式之上再创建一个超级工厂。
接下来看实例

实例

下面的代码展示了如何使用抽象工厂模式。
我们将要创建形状和打印机。对于形状，我们会有圆形，矩形和正方形。对于打印机，我们将有纸张打印机，网络打印机和屏幕打印机。
也就是我们先创建两个普通的工厂模式，普通工厂模式怎么设计我们在上一章已经讲过了，接下来我们直接创建
我们先来创建形状这个工厂
首先创建一个形状接口

interface Shape {
   void draw();
}

再创建三个实现类来实现形状Shape接口类的draw接口

public class Rectangle implements Shape {
    public void draw() {
        System.out.println("Rectangle");
    }
}

public class Circle implements Shape {
    public void draw() {
        System.out.println("Circle");
    }
}

public class Square implements Shape {
    public void draw() {
        System.out.println("Square");
    }
}

形状工厂创建完了，我们再来创建打印机工厂
一样的，先创建一个打印机接口类，并且创建一个print成员接口

public interface Printer {
	void print();
}

再来创建三个实现类来实现Printer 这个接口类的print接口

public class PaperPrinter implements Printer{

   @Override
   public void print() {
      System.out.println("paper");
   }
}

public class WebPrinter implements Printer{

   @Override
   public void print() {
      System.out.println("web");
   }
}


public class ScreenPrinter implements Printer{

   @Override
   public void print() {
      System.out.println("screen");
   }
}

两个工厂都创建好了
然后，我们创建一个抽象类来获取打印机和形状对象的工厂。

public abstract class AbstractFactory {
   abstract Printer getPrinter(String type);
   abstract Shape getShape(String shape) ;
}

再创建两个类根据给定的信息扩展AbstractFactory以生成具体类的对象。
相当于在下面的两个工厂之上再创建两个超级工厂。
第一个超级工厂

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
   Printer getPrinter(String type) {
      return null;
   }
}

第二个超级工厂

public class PrinterFactory extends AbstractFactory {
  
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   Printer getPrinter(String type) {
   if(type == null){
      return null;
    }    
  if(type.equalsIgnoreCase("paper")){
      return new PaperPrinter();
  } else if(type.equalsIgnoreCase("web")){
      return new WebPrinter();
  } else if(type.equalsIgnoreCase("Screen")){
      return new ScreenPrinter();
  }
  return null;
 }
}

再创建一个Factory类来初始化两个超级工厂，后面可以通过传递Shape或Printer等信息来获取工厂。

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("Shape")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("Printer")){
         return new PrinterFactory();
      }
      return null;
   }
}

下面的代码展示了如何使用抽象工厂模式。

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

      //通过Shape来获取形状这个超级工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("Shape");

      // 通过Circle 来获取 Circle这个类并执行draw方法
      Shape shape1 = shapeFactory.getShape("Circle");

      //call draw method of Shape Circle
      shape1.draw();

      //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();

      // 通过Printer来获取打印机这个超级工厂
      AbstractFactory printerFactory = FactoryProducer.getFactory("Printer");

    Printer printer1 = printerFactory.getPrinter("Paper");
    printer1.print();
    Printer printer2 = printerFactory.getPrinter("Web");
    printer2.print();
    Printer printer3 = printerFactory.getPrinter("Screen");
    printer3.print();
   }
}