目录
概述
抽象工厂模式提供一个接口,用于创建相关或依赖对象的家族,而不需要明确指定具体类。可以理解成是多个工厂方法的组合。
解决问题
在工厂方法模式中,我们的具体创建者每次使用都只能创建一个同类型的对象,假如我们现在需要的是多个不同类型的对象,工厂方法就满足不了需求了。这时我们可以把多个工厂方法组合到一个类,这就是抽象工厂模式,它就是专门用来创建多个产品,也可以说是创建产品家族的。
代码实现
原料产品族(只给出示范代码,更多请自己实现)
/**
* 奶酪
* @author Mr.Li
*
*/
public class Cheese {
}
/**
* 面团
* @author Mr.Li
*
*/
public class Dough {
}
public class ReggianoCheese extends Cheese {
}
public class ThinCrustDough extends Dough{
}
创建抽象工厂
/**
* 创建一个原料工厂。该工厂为抽象工厂,负责创建所有的原料。
* @author Mr.Li
*
*/
public interface PizzaIngredientFactory {
/*
* 在接口中,每个原料都有一个对应的方法创建该原料
*/
public Dough createDough();
public Sauce createSauce();
public Cheese createCheese();
public Veggies[] createVeggies();
public Pepperoni createPepperoni();
public Clams createClams();
}
工厂实现
/**
* 原料工厂创建完成之后,需要创建具体的原料工厂。该具体工厂只需要继承PizzaIngredientFactory,然后实现里面的方法即可。
* @author Mr.Li
*
*/
public class NYPizzaIngredientFactory implements PizzaIngredientFactory{
@Override
public Cheese createCheese() {
return new ReggianoCheese();
}
@Override
public Clams createClams() {
return new FreshClams();
}
@Override
public Dough createDough() {
return new ThinCrustDough();
}
@Override
public Pepperoni createPepperoni() {
return new SlicedPepperoni();
}
@Override
public Sauce createSauce() {
return new MarinaraSauce();
}
@Override
public Veggies[] createVeggies() {
Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RefPepper() };
return veggies;
}
}
pizza类
/**
* 披萨类里面,我们需要使用原料,其他方法保持不变,将prepare()方法声明为抽象,在这个方法中,我们需要收集披萨所需要的原料。
* @author Mr.Li
*
*/
public abstract class Pizza {
/*
* 每个披萨都持有一组在准备时会用到的原料
*/
String name;
Dough dough;
Sauce sauce;
Veggies veggies[];
Cheese cheese;
Pepperoni pepperoni;
Clams clams;
/*
* prepare()方法声明为抽象方法。在这个方法中,我们需要收集披萨所需要的原料,而这些原料都是来自原料工厂
*/
public abstract void prepare();
public void bake() {
System.out.println("Bake for 25 munites at 350");
}
public void cut() {
System.out.println("Cutting the pizza into diagonal slices");
}
public void box() {
System.out.println("Place pizza in official PizzaStore box");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* Pizza的代码利用相关的工厂生产原料。所生产的原料依赖所使用的工厂,
* Pizza类根本不关心这些原料,它只需要知道如何制作披萨即可。这里,Pizza和区域原料之间被解耦。
* @author Mr.Li
*
*/
public class CheesePizza extends Pizza{
PizzaIngredientFactory ingredientFactory;
/*
* 要制作披萨必须要有制作披萨的原料,而这些原料是从原料工厂运来的
*/
public CheesePizza(PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
/*
* 实现prepare方法 prepare 方法一步一步地创建芝士比萨,每当需要原料时,就跟工厂要
*/
public void prepare() {
System.out.println("Prepareing " + name);
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
}
}
public class ClamPizza extends Pizza {
PizzaIngredientFactory ingredientFactory;
public ClamPizza(PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
@Override
public void prepare() {
System.out.println("Prepare " + name);
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
clams = ingredientFactory.createClams();
}
}
商店
/**
* 商店抽象
* @author Mr.Li
*
*/
public abstract class PizzaStore {
public Pizza orderPizza(String type){
Pizza pizza;
pizza = createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
/*
* 创建pizza的方法交给子类去实现
*/
abstract Pizza createPizza(String type);
}
/**
* 在披萨店中,我们依然需要关注原料,当地的披萨店需要和本地的原料工厂关联起来。
* @author Mr.Li
*
*/
public class NYPizzaStore extends PizzaStore{
@Override
Pizza createPizza(String type) {
Pizza pizza = null;
// 使用纽约的原料工厂
PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
if ("cheese".equals(type)) {
pizza = new CheesePizza(ingredientFactory);
pizza.setName("New York Style Cheese Pizza");
}else if ("clam".equals(type)) {
pizza = new ClamPizza(ingredientFactory);
pizza.setName("New York Style Clam Pizza");
}
return pizza;
}
}
调用
public static void main(String[] args) {
NYPizzaStore nyPizzaStore = new NYPizzaStore();
nyPizzaStore.orderPizza("cheese");
}
visio图
优缺点及使用场景
/**
* 优点: 1、 抽象工厂隔离了具体类的生成,是的客户端不需要知道什么被创建。所有的具体工厂都实现了抽象工厂中定义的公共接口,因此只需要改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。
* 2、 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。
* 缺点: 1、添加新的行为时比较麻烦。如果需要添加一个新产品族对象时,需要更改接口及其下所有子类,这必然会带来很大的麻烦。
* 使用场景: 1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是重要的。
* 2. 系统中有多于一个的产品族,而每次只使用其中某一产品族。
* 3. 属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来。
* 4. 系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。
*/