抽象工厂模式

目录

https://blog.csdn.net/dongganen/article/details/79688794

---

定义抽象工厂

---

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

案例分析

---

我很喜欢一道菜叫蛋炒饭，蛋炒饭是由蛋和饭组成的，假设宁波蛋炒饭是由鸡蛋A和米饭A炒，上海蛋炒饭有鸡蛋B和米饭B炒。

硬编码实现

class HardCoded{

    public EggsRice fryEggsRice(String type){
        EggsRice eggsRice = null;
        if(type.equals("NB")){
            eggsRice = new EggsRice(new EggsA(), new RiceA());
        }else if(type.equals("SH")){
            eggsRice = new EggsRice(new EggsB(), new RiceB());
        }
        return eggsRice;
    }
}

分析

我们引入了新类型的工厂，也就是所谓的抽象工厂，来创建蛋炒饭原料。通过抽象工厂提供的接口，可以创建产品的家族。蛋炒饭需要原料蛋和饭，不同类型的蛋炒饭所用的原料不同。

UNL图

代码

//抽象工厂
public class AbstrackFactory {

    public static void main(String[] args) {
        //来一碗宁波蛋炒饭
        EggsRice eggsRice = SimpleFactory.createEggsRice("NB");
        eggsRice.fry();
    }
}

//简单工厂
class SimpleFactory{

    public static EggsRice createEggsRice(String type){
        EggsRice eggsRice = null;
        if(type.equals("NB")){
            eggsRice = new EggsRice(new NBStyleEggsRiceFactory());
        }else if(type.equals("SH")){
            eggsRice = new EggsRice(new SHStyleEggsRiceFactory());
        }
        return eggsRice;
    }
}

//蛋炒饭
class EggsRice{

    Eggs eggs;
    Rice rice;
    EggsRiceFactory eggsRiceFactory;

    EggsRice(EggsRiceFactory eggsRiceFactory){
        this.eggsRiceFactory = eggsRiceFactory;
    }

    public void fry(){
        this.eggs = eggsRiceFactory.createEggs();
        this.rice = eggsRiceFactory.createRice();
        System.out.println("用" + eggs.name + "和" + rice.name + "炒");
    }
}

//蛋炒饭工厂
interface EggsRiceFactory{
    Eggs createEggs();
    Rice createRice();
}

//宁波蛋炒饭
class NBStyleEggsRiceFactory implements EggsRiceFactory{

    @Override
    public Eggs createEggs() {
        return new EggsA();
    }

    @Override
    public Rice createRice() {
        return new RiceA();
    }
}

//上海蛋炒饭
class SHStyleEggsRiceFactory implements EggsRiceFactory{

    @Override
    public Eggs createEggs() {
        return new EggsB();
    }

    @Override
    public Rice createRice() {
        return new RiceB();
    }
}

//鸡蛋
abstract class Eggs{
    String name;
}

//米饭
abstract class Rice{
    String name;
}

//鸡蛋A
class EggsA extends Eggs{

    public EggsA(){
        name = "EggsA";
    }
}

//鸡蛋B
class EggsB extends Eggs{
    public EggsB(){
        name = "EggsB";
    }
}

//米饭A
class RiceA extends Rice{
    public RiceA(){
        name = "RiceA";
    }
}

//米饭B
class RiceB extends Rice{
    public RiceB(){
        name = "RiceB";
    }
}

抽象工厂模式和工厂模式的区别

---

工厂模式	抽象工厂模式
方法的继承	对象的组合
同一类型	产品家族
扩展只要在具体工厂改动就可以	如果扩展需要改接口，改动比较大

参考《Head First设计模式》

---