抽象工厂模式（java语言实现）

1 抽象工厂模式：

抽象工厂，简单地说就是产生工厂的工厂。

抽象工厂返回简单工厂

抽象工厂模式更严谨的定义：
定义了一个创建对象的接口（或者抽象类都可以 ，在这个例子中是 AbstractFactory ） ，但是由子类来决定要是实例化的是哪一个。工厂方法让类把实例化推迟到子类。

3 抽象工厂的实现

// 定义一个工厂超类专门产生形状，它的子类实现它，
// 并且提供 draw 方法的具体实现
interface Shape {
   void draw();
}

Shape 接口的具体子类：
class Rectangle implements Shape {

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

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

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


// 定义一个工厂超类专门产生特定方式的打印，它的子类实现它，
// 并且提供 print 方法的具体实现
interface Printer{
   void print();
}

// Printer 接口的具体子类：

class PaperPrinter implements Printer{

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

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

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


// 定义一个工厂的抽象类，
// 它定义了工厂的职责——根据传入的字符串信息返回特定的特定的产品，
// 但没有提供具体的实现。
abstract class AbstractFactory {
   abstract Printer getPrinter(String type);
   abstract Shape getShape(String shape) ;
}

//创建扩展自工厂的抽象类的 ShapeFactory 返回具体的形状产品
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;
   }
}

//创建扩展自工厂的抽象类的 PrinterFactory 返回具体的打印产品
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;
 }
}

// 创建一个 抽象工厂 ，根据传入的字符信息创建并返回简单工厂
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) {

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

      //get an object of Shape Circle
      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();

      //get printer factory
      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();
   }
}


输出：
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
paper
web
screen