设计模式之抽象工厂-java版

现在我不止想吃汉堡了，还想喝可乐，但吃汉堡太干了。但我还不想自己做，我想别人直接做好给我，而且汉堡我也不止想吃一种，这个时候一种选择就是扩展工厂类，假如某款套餐特别热销，出货量大，我们就单独做一个工厂，这个套餐包括鸡腿堡和可乐。
产品有2个一个是汉堡，一个是饮料，分别是麦当劳和肯德基实现。

产品抽象类

public abstract class AbstractHamburger {  
    //鸡腿堡  
    public abstract void makeChickenLegBurger();  
    //鳕鱼堡  
    public abstract void makeCodburger();  
}

public abstract class AbstractDrinks {  
    public abstract void makeCola();  
  
    public abstract void makeSprite();  
}

public class KfcBurger extends AbstractHamburger{  
    @Override  
    public void makeChickenLegBurger() {  
        System.out.println("kfc 鸡腿堡");  
    }  
  
    @Override  
    public void makeCodburger() {  
        System.out.println("kfc 鱼堡");  
    }  
}
public class McBurger extends AbstractHamburger{  
    @Override  
    public void makeChickenLegBurger() {  
        System.out.println("mc 鸡腿堡");  
    }  
  
    @Override  
    public void makeCodburger() {  
        System.out.println("mc 鱼堡");  
    }  
}
public class KfcDrinks extends AbstractDrinks{  
    @Override  
    public void makeCola() {  
        System.out.println("kfc cola");  
    }  
  
    @Override  
    public void makeSprite() {  
        System.out.println("kfc sprite");  
    }  
}
public class McDrinks extends AbstractDrinks{  
    @Override  
    public void makeCola() {  
        System.out.println("mc cola");  
    }  
  
    @Override  
    public void makeSprite() {  
        System.out.println("mc sprite");  
    }  
}

快餐套餐包括鸡肉汉堡和可乐

public abstract class FastFoodShop {  
    public abstract void makeChickenBurger();  
    public abstract void makeCola();  
}

kfc和mc的工厂实现

public class KfcShop extends FastFoodShop{  
    @Override  
    public void makeChickenBurger() {  
        AbstractHamburger kfcHamburger = new KfcBurger();  
        kfcHamburger.makeChickenLegBurger();  
    }  
  
    @Override  
    public void makeCola() {  
        AbstractDrinks kfcHamburger = new KfcDrinks();  
        kfcHamburger.makeCola();  
    }  
}

public class McShop extends FastFoodShop{  
    @Override  
    public void makeChickenBurger() {  
        McBurger mcBurger = new McBurger();  
        mcBurger.makeChickenLegBurger();  
    }  
  
    @Override  
    public void makeCola() {  
        AbstractDrinks mcBurger = new McDrinks();  
        mcBurger.makeCola();  
    }  
}

一个客户点了2个工厂的套餐

public class Customer2 {  
    public static void main(String[] args) {  
        FastFoodShop kfcShop = new KfcShop();  
        FastFoodShop mcShop = new McShop();  
  
        kfcShop.makeChickenBurger();  
        kfcShop.makeCola();  
  
        mcShop.makeChickenBurger();  
        mcShop.makeCola();  
    }  
}

kfc 鸡腿堡
kfc cola
mc 鸡腿堡
mc cola

抽象
产品类

public abstract class AbstractProductA {  
    public void shareMethod(){  
  
    }  
    public abstract void doSomething();  
}
public abstract class AbstractProductB {  
    public void shareMethod(){  
  
    }  
    public abstract void doSomething();  
}

工厂类

public abstract class AbstractCreator {  
    public abstract AbstractProductA createProductA();  
  
    public abstract AbstractProductB createProductB();  
}

public class Creator1 extends AbstractCreator{  
    @Override  
    public AbstractProductA createProductA() {  
        return new ProductA1();  
    }  
  
    @Override  
    public AbstractProductB createProductB() {  
        return new ProductB1();  
    }  
}

public class Creator2 extends AbstractCreator{  
    @Override  
    public AbstractProductA createProductA() {  
        return new ProductA2();  
    }  
  
    @Override  
    public AbstractProductB createProductB() {  
        return new ProductB2();  
    }  
}

调用类

public class Client2 {  
    public static void main(String[] args) {  
        AbstractCreator creator1 = new Creator1();  
        AbstractCreator creator2 = new Creator2();  
  
        AbstractProductA a1 = creator1.createProductA();  
        AbstractProductA a2 = creator2.createProductA();  
  
        AbstractProductB b1 = creator1.createProductB();  
        AbstractProductB b2 = creator2.createProductB();  
  
    }  
}

总结

1. 属于创建模式，新建对象
2. 通过继承的方式方便扩展，而且是生产一堆商品，比[[设计模式-工厂方法]] 创建的方法更多
3. 缺点是要增加产品特征比较难，但新增一个产品比较简单，适合抽象固定的产品创建。