设计模式笔记之抽象工厂模式

概念：抽象工厂模式也属于创建型工厂模式，在工厂模式的基础上，在建一个超级工厂（其他工厂的工厂），提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

示例代码：

/*

*第一个接口

*/

public interface Shape{

   void draw();

}

/*

*创建第一个接口的第一个实现类

*/

public classRectangle implements Shape{

   public void draw(){

     System.out.println("Inside Rectangle::draw()method.");

   }

}

/*

*创建第一个接口的第二个实现类

*/

public class Square implements Shape{

   public void draw(){

     System.out.println("Inside Square::draw()method.");

   }

}

/*

*创建第一个接口的第三个实现类

*/

public class Circle implements Shape{

   public void draw(){

     System.out.println("Inside Circle::draw()method.");

   }

}

/*

*创建第二个接口

*/

public interface Color{

   void fill();

}

/*

*创建第二个接口的第一个实现类

*/

public class Red implements Color{

   public void fill(){

     System.out.println("Inside Red::fill() method.");

   }

}

/*

*创建第二个接口的第二个实现类

*/

public class Green implements Color{

 

   @Override

   public void fill(){

     System.out.println("Inside Green::fill() method.");

   }

}

/*

*创建第二个接口的第三个实现类

*/

public class Blue implements Color{

   public void fill(){

     System.out.println("Inside Blue::fill() method.");

   }

}

/*

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

*/

public abstract class AbstractFactory{

   abstract Color getColor(String color);

   abstract Shape getShape(String shape);

}

/*

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

*/

public class ShapeFactory extends AbstractFactory{

   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;

   }

   Color getColor(String color){

     return null;

   }

}

public class ColorFactory extends AbstractFactory{

   public Shape getShape(String shapeType){

     return null;

   }

   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;

   }

}

/*

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

*/

public class FactoryProducer{

   public static AbstractFactory getFactory(String choice){

     if(choice.equalsIgnoreCase("SHAPE")){

        return new ShapeFactory();

     }elseif(choice.equalsIgnoreCase("COLOR")){

        return new ColorFactory();

     }

     return null;

   }

}

/*

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

*/

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

   }

}