设计模式——工厂模式

1、简介

工厂模式主要有三类：简单工厂模式、工厂模式、抽象工厂模式。

简单工厂模式：根据传入的参数，创建新的对应对象。当增加新的对象时，需要修改工厂类内部的结构，违反“开放-封闭原则”

工厂模式：具有工厂接口与产品接口，不同工厂生产不同的产品，遵守了”开放-封闭“原则。

抽象工厂模式：可以通过工厂类生产一批不同类别的产品。

使用较多的是工厂模式。

三种设计模式的详细分析如下。

2、详解

（1）简单工厂模式

简单工厂模式就是由一个工厂类根据传入的参数决定创建哪一种的产品类。

有4个角色：

a.工厂类角色：是具体产品类角色直接调用者;

b.抽象产品角色：接口或抽象类，负责具体产品角色的定义，及与客户端的交互。

c.具体产品角色：被工厂类创建的对象，也是客户端实际操作对象。

d.客户端：调用工厂类产生实例，并调用实例的方法进行相应工作。

public interface people{
      public void say();
}

public class chinese implements people{
      public void say(){
           System.out.println("说中国话");
     }
}

public class american implements people{
      public void say(){
           System.out.println("speak english");
     }
} 

public class peopleFactory{
      public static people create(int type){
           if(type==1){
                  return new chinese();
           }else if(type==2){
                 return new american();
           }
     }
 }

public class test{
      public static void main(String []args){
           people p=peopleFactory.create(1);
           p.say();
           p=peopleFactory.create(2);
            p.say();
     }
 }

（2）工厂模式

工厂方法模式对简单工厂进行了抽象，拥有一个抽象的工厂类，定制接口规范。具体的生产工作交给子类。还有一个抽象的产品类，定义一些规范。具体属性由子类定义。抽象工厂对应抽象产品。具体的某个工厂类生产对应的具体产品。实体工厂实现抽象工厂，实体产品实现抽象产品；抽象工厂生产抽象产品，实体工厂生产实体产品；实体工厂A生产实体产品A，实体工厂B生产实体产品B。

public interface Icar{
           public void docar();
} 

public class bwm implements Icar{
          public void docar(){
               System.out.println("我是宝马，别摸我");
          }
}

 public class buick implements Icar{
          public void docar(){
               System.out.println("我是别克，很酷");
          }
}

public interface Icarfactory{
          public Icar createCar();
} 

public class bmwFactory implements Icarfactory{
          public Icar createCar(){
                   return new bwm();
          }
} 

public class buickFactory implements Icarfactory{
          public Icar createCar(){
                   return new buick();
          }
} 
 
public class test{
      public static void main(String []args){
           Icarfactory factory=new bmwFactory();
           Icar bwm= factory.createCar(); 
           bwm.docar();

           factory=new buickFactory();
           Icar buick= factory.createCar(); 
           buick.docar();
     }
 }

（3）抽象工厂模式

是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

通过子工厂的父工厂，产生子工厂，用子工厂去生产不同的产品。

具体代码如下：

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 class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("Inside Circle::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 Green implements Color {

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

public class Blue implements Color {

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

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

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
   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("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();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}

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

声明：本文部分内容来自以下两处，在此对作者表示感谢！

http://wxg6203.iteye.com/blog/740229

http://www.runoob.com/design-pattern/abstract-factory-pattern.html