工厂模式简介

工厂模式是我们日常开发工作中经常使用的设计模式,它属于创建型设计模式,我们常用的工厂模式有:简单工厂模式工厂方法模式抽象工厂模式 三种类型;下面我们一起来领略一下它们各自的特点。

简单工厂模式

简单工厂模式,又称为静态工厂模式;其核心是工厂类,包含了必要的处理逻辑,可以根据外界跟定的信息,返回指定的结果。参考以下示例:

Car

//定义Car
public interface Car {

    String getName();

}

//Jeep实现类
public class Jeep implements Car {

    @Override
    public String getName() {
        return "Jeep";
    }
}

//Truck实现类
public class Truck implements Car {

    @Override
    public String getName() {
        return "Truck";
    }
}

//Cooper实现类
public class Cooper implements Car {

    @Override
    public String getName() {
        return "Cooper";
    }
}

Factory

//Car 工厂类,根据传入的name,生产具体的Car
public class CarFactory {

    public Car getCar(String name) {
        switch (name) {
            case "Jeep":
                return new Jeep();
            case "Truck":
                return new Truck();
            case "Cooper":
                return new Cooper();
            default:
                throw new RuntimeException();
        }
    }
}

演示Demo

public class Demo {

    public static void main(String[] args) {
        CarFactory factory = new CarFactory();
        Car jeep = factory.getCar("Jeep");
        System.out.println(jeep.getName());
        Car truck = factory.getCar("Truck");
        System.out.println(truck.getName());
        Car cooper = factory.getCar("Cooper");
        System.out.println(cooper.getName());
    }
}

当然,简单工厂的缺点也很明显:

  • 增加新的产品,需要修改Factory的代码
  • 不存在所有Object都可以生产的工厂

工厂方法模式的出现,对这些缺点有了一定的克服。

工厂方法模式

工厂方法模式的特点是在工厂类中定义了创建产品的接口,而具体的实现交由子类工厂去实现;通过此种方式将变化封装了起来,遵守开闭原则,实现了可扩展;参看以下示例。

public interface CarFactory {
    // 定义了获取Car接口
    Car getCar();
}
//Jeep工厂类
public class JeepFactory implements CarFactory {

    @Override
    public Car getCar() {
        return new Jeep();
    }
}
//Cooper工厂类
public class CooperFactory implements CarFactory {

    @Override
    public Car getCar() {
        return new Cooper();
    }
}
//Truck工厂类
public class TruckFactory implements CarFactory {

    @Override
    public Car getCar() {
        return new Truck();
    }
}

演示Demo

public class Demo {

    public static void main(String[] args) {
        CarFactory jeepFactory = new JeepFactory();
        Car jeep = jeepFactory.getCar();
        System.out.println(jeep.getName());
        TruckFactory truckFactory = new TruckFactory();
        Car truck = truckFactory.getCar();
        System.out.println(truck.getName());
        CooperFactory cooperFactory = new CooperFactory();
        Car cooper = cooperFactory.getCar();
        System.out.println(cooper.getName());
    }
}

工厂方法模式是对简单工厂做了抽象,工厂方法模式是典型的模板模式的应用。通过代码,我们发现:工厂方法模式的较简单工厂而言实现比较复杂对于可以形成产品族的情况较难处理

其中针对对于可以形成产品族的情况较难处理这里情况,在抽象工厂模式中得到一定的处理。

抽象工厂模式

image

抽象工厂模式是为一系列相关的,或者有依赖关系的对象创建提供接口;我们可以参考一下代码:


public interface Shape {

    String draw();
}

public interface Color {

    String fill();
}

public class Circle implements Shape {

    @Override
    public String draw() {
        return "circle";
    }
}

public class Square implements Shape {

    @Override
    public String draw() {
        return "square";
    }
}

public class Rectangle implements Shape {

    @Override
    public String draw() {
        return "rectangle";
    }
}


public class Green implements Color {

    @Override
    public String fill() {
        return "green";
    }
}


public class Red implements Color {

    @Override
    public String fill() {
        return "red";
    }
}

public class Blue implements Color {

    @Override
    public String fill() {
        return "blue";
    }
}

AbstractFactory

public interface AbstractFactory {

    Shape getShape(String shape);

    Color getColor(String color);

}

public class ShapeFactory implements AbstractFactory {

    @Override
    public Shape getShape(String shape) {
		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
    public Color getColor(String color){
		return null;
    }
}

public class ColorFactory implements AbstractFactory {

    @Override
    public Shape getShape(String shape) {
      return null;
    }

    @Override
    public 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;
    }
}

FactoryProducer.java

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

Demo.java

public class Demo {

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

相较于工厂方法模式,抽象工厂模式对产品族(相关联的对象)支持的较好,但是还是没有解决实现复杂的问题;而针对这一问题,我们可以通过与简单工厂的结合使用,或者与反射的结合使用来降低实现的复杂度。