有一个连锁披萨店要在湖南和广东两个地方开店，但是湖南人喜欢辣，广东人喜欢清淡
需求故事
- 1.作为一个披萨店PizzaStore，可以根据客人要求orderPizza提供湖南口味的Pizza，口味是peppery+cheese；
- 2.作为一个披萨店PizzaStore, 还可以根据客人要求orderPizza提供广东口味Pizza，口味是seafood+cheese；
- 3.作为一个披萨店PizzaStore，还可以根据客人要求orderChicken生产广东口味的FriedChicken，口味是peppery+chicken，而作为一个广东的披萨店GDPizzaStore，可以生产FriedChicken，口味是light+chicken
Story1
作为一个披萨店PizzaStore，可以根据客人要求orderPizza提供湖南口味的Pizza，口味是peppery+cheese；
Story1 Test Case
由于Story1的需求都很具体，所以都是使用具体类来实现的
public class PizzaStoreTest {
@Test
public void testOrderPizzaStory1(){
HNPizzaStore hnPizzaStore = new HNPizzaStore();
HNStylePizza hnStylePizza = hnPizzaStore.orderPizza();
assertEquals("peppery+cheese",hnStylePizza.taste());
assertTrue(hnStylePizza.isBaked());
}
}
Story1 Implementation
public class HNStylePizza {
private boolean baked=false;
public String taste() {
return "peppery+cheese";
}
public void baking() {
baked = true;
}
public boolean isBaked() {
return baked;
}
}
public class HNPizzaStore {
public HNStylePizza orderPizza() {
HNStylePizza pizza = new HNStylePizza();
pizza.baking();
return pizza;
}
}
Story2
作为一个新的连锁广东披萨店PizzaStore, 还可以根据客人要求orderPizza提供广东口味Pizza，口味是seafood+cheese；
Story2 Test Case
增加的一个连锁披萨店，所以可以对披萨店进行抽象PizzaStore。广东风味的披萨和湖南风味的披萨口味也不通，但都是披萨，所以对披萨也要进行抽象Pizza来准备testcase
@Test
public void testOrderPizzaStory2(){
PizzaStore hnPizzaStore = new HNPizzaStore();
Pizza hnStyledPizza = hnPizzaStore.orderPizza();
assertEquals("peppery+cheese",hnStyledPizza.taste());
assertTrue(hnStyledPizza.isBaked());
PizzaStore gdPizzaStore = new GDPizzaStore();
Pizza gdStyledPizza = gdPizzaStore.orderPizza();
assertEquals("seafood+cheese",gdStyledPizza.taste());
assertTrue(gdStyledPizza.isBaked());
}
Story2 Implemetation
public abstract class Pizza {
private boolean baked=false;
public void baking() {
baked = true;
}
public boolean isBaked() {
return baked;
}
public abstract String taste();
}
public class HNStylePizza extends Pizza {
public String taste() {
return "peppery+cheese";
}
}
public class HNPizzaStore extends PizzaStore {
public Pizza prepareUnbakedPizza() {
HNStylePizza pizza = new HNStylePizza();
pizza.baking();
return pizza;
}
}
public abstract class PizzaStore {
public Pizza orderPizza() {
Pizza pizza = prepareUnbakedPizza();
pizza.baking();
return pizza;
}
protected abstract Pizza prepareUnbakedPizza();
}
public class GDPizzaStore extends PizzaStore {
@Override
protected Pizza prepareUnbakedPizza() {
Pizza pizza = new GDStylePizza();
return pizza;
}
}
public class HNPizzaStore extends PizzaStore {
@Override
public Pizza prepareUnbakedPizza() {
Pizza pizza = new HNStylePizza();
return pizza;
}
}
上面的实现就是一个标准的Factory模式实现了，所以Factory模式就是把生产的对象，和生产的工厂进行抽象，从而达到了把实现产品的细节放到了工厂的子类中实现。
Factory模式的使用场景是使用不同的工厂来创建对象，以及要对创建的对象进行一些初始化操作，所以Factory模式里面通常都包含了Template方法模式
Story3
作为一个披萨店PizzaStore，还可以根据客人要求orderChicken生产广东口味的Chicken，口味是peppery+chicken，而作为一个广东的披萨店GDPizzaStore，可以生产Chicken，口味是light+chicken
Story3 Test Case
public void testOrderChickenStory3(){
PizzaStore pizzaStore = new HNPizzaStore();
Chicken chicken = pizzaStore.orderChicken();
assertEquals("peppery+chicken",chicken.taste());
pizzaStore = new GDPizzaStore();
chicken = pizzaStore.orderChicken();
assertEquals("light+chicken",chicken.taste());
}
Story3 Implementation
public abstract class Chicken {
public abstract String taste();
}
public class PeppyChicken extends Chicken {
@Override
public String taste() {
return "peppery+chicken";
}
}
public class LightChicken extends Chicken {
@Override
public String taste() {
return "light+chicken";
}
}
public abstract class PizzaStore {
public Pizza orderPizza() {
Pizza pizza = prepareUnbakedPizza();
pizza.baking();
return pizza;
}
protected abstract Pizza prepareUnbakedPizza();
public abstract Chicken orderChicken();
}
public class HNPizzaStore extends PizzaStore {
public Pizza prepareUnbakedPizza() {
HNStylePizza pizza = new HNStylePizza();
return pizza;
}
@Override
public Chicken orderChicken() {
return new PeppyChicken();
}
}
public class GDPizzaStore extends PizzaStore {
@Override
protected Pizza prepareUnbakedPizza() {
Pizza gdStylePizza = new GDStylePizza();
return gdStylePizza;
}
@Override
public Chicken orderChicken() {
return new LightChicken();
}
}
这就是Abstract Factory模式的实现了，你没有看错，Abstract Factory比Factory最大的区别就是多了生产其他产品的方法，所以如果Factory就是只生产1个产品的Abstract Factory。
和坚思辨
Factory模式系列其实是要解决创建对象的问题，应用的场景是当创建一个对象比较复杂，使用构造函数来创建对象无法满足需求的情况。所以是否使用Factory系列相关模式的主要问题就是当你需要一个对象，但是使用构造函数还需要再做其他的额外准备时，就应该考虑Factory系列模式。
Factory系列其实一套一共有3个：
Simple Factory模式
Factory模式
Abstract Factory模式
其中Simple Factory就是根据传递的参数，用IF来判断创建对象，由于我个人不是很喜欢这种很多if的嵌套结构，所以我就没有进行介绍了。
