二十三种设计模式(三)--抽象工厂模式

抽象工厂模式

抽象工厂模式在代码上看, 仅仅是将工厂方法模式的具体方法类由一个扩展成了多个,

方法类接口由一个变成一组

但是抽象方法类最终要解决的是"一组相关属性"的问题

具体实现示例如下:

工厂类的接口包含一组方法接口, 这里是和工厂方法模式最直接的区别

所以, 抽象工厂模式解决的问题就是, 一个工厂对象是通过一组相关子对象共同协作完成的.

如图所示, 当工厂类的产品不是单一的类对象构成, 而是需要一组类对象才能构成时, 就需要通过抽象工厂模式实现更大程度的解耦及更大程度的扩展性.

具体实现示例:

java 复制代码

// 工厂类本身可扩展
// 工厂类, 相比较工厂方法类, 此处扩展方法接口为一组方法
public interface Factory {
    PartA getPartA();
    PartB getPartB();
    PartC getPartC();
}

class FactoryA implements Factory {
    public PartA getPartA() {
        return new PartAImplA();
    }

    public PartB getPartB() {
        return new PartBImplA();
    }

    public PartC getPartC() {
        return new PartCImplA();
    }
}

class FactoryB implements Factory {
    public PartA getPartA() {
        return new PartAImplB();
    }

    public PartB getPartB() {
        return new PartBImplB();
    }

    public PartC getPartC() {
        return new PartCImplB();
    }
}

具体的实现类接口A部分:

java 复制代码

public interface PartA {
    void do_part_a();
}

class PartAImplA implements PartA {
    public void do_part_a() {
        System.out.println("Worker finished 1/3 job in Factory A.");
    }
}

class PartAImplB implements PartA {
    public void do_part_a() {
        System.out.println("Worker finished 1/3 job in Factory B");
    }
}

具体的实现类接口B部分:

java 复制代码

public interface PartB {
    void do_part_b();
}

class PartBImplA implements PartB {
    public void do_part_b() {
        System.out.println("Worker finished 2/3 job in Factory A.");
    }
}

class PartBImplB implements PartB {
    public void do_part_b() {
        System.out.println("Worker finished 2/3 job in Factory B.");
    }
}

具体的实现类接口C部分:

java 复制代码

public interface PartC {
    void do_part_c();
}

class PartCImplA implements PartC {
    public void do_part_c() {
        System.out.println("Worker finished 3/3 job in Factory A.");
    }
}

class PartCImplB implements PartC {
    public  void do_part_c() {
        System.out.println("Worker finished 3/3 job in Factory B.");
    }
}

实例化并调用:

java 复制代码

public class AbstractFactory {
    public static void main(String[] args) {
        FactoryA factoryA = new FactoryA();
        PartA workAPartA = factoryA.getPartA();
        PartB workAPartB = factoryA.getPartB();
        PartC workAPartC = factoryA.getPartC();
        workAPartA.do_part_a();
        workAPartB.do_part_b();
        workAPartC.do_part_c();

        FactoryB factoryB = new FactoryB();
        PartA workBPartA = factoryB.getPartA();
        PartB workBPartB = factoryB.getPartB();
        PartC workBPartC = factoryB.getPartC();
        workBPartA.do_part_a();
        workBPartB.do_part_b();
        workBPartC.do_part_c();
    }
}

运行结果:

复制代码

Worker finished 1/3 job in Factory A.
Worker finished 2/3 job in Factory A.
Worker finished 3/3 job in Factory A.
Worker finished 1/3 job in Factory B
Worker finished 2/3 job in Factory B.
Worker finished 3/3 job in Factory B.

抽象工厂模式与工厂方法模式显著的区别如下:

工厂方法模式中, 一个工厂只生产一个产品, 但抽象工厂模式下, 一个工厂产生一组相关产品
工厂类接口的一组方法是相类似的, 成套出现的

总结, 抽象方法是多个工厂方法的组合 + 产品族一致性的约束。