抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。

---

Java

Creator

public interface Creator {
    public ProductA factoryA();
    public ProductB factoryB();
}

ConcreteCreator

public class ConcreteCreator1 implements Creator{

    @Override
    public ProductA factoryA() {
        return new ProductA1();
    }

    @Override
    public ProductB factoryB() {
        return new ProductB1();
    }

}


public class ConcreteCreator2 implements Creator{

    @Override
    public ProductA factoryA() {
        return new ProductA2();
    }

    @Override
    public ProductB factoryB() {
        return new ProductB2();
    }

Product

public interface ProductA {
    void show();
}

public interface ProductB {
    void show();
}

ConcreteProduct

public class ProductA1 implements ProductA {

    @Override
    public void show() {
        System.out.println("ProductA1");
    }

}

public class ProductA2 implements ProductA {

    @Override
    public void show() {
        System.out.println("ProductA2");
    }

}

public class ProductB1 implements ProductB {

    @Override
    public void show() {
        System.out.println("ProductB1");
    }

}


public class ProductB2 implements ProductB {

    @Override
    public void show() {
        System.out.println("ProductB2");
    }

}

Client

public class Client {
    public static void main(String[] args) {
        Creator creator1 = new ConcreteCreator1();
        creator1.factoryA().show();
        creator1.factoryB().show();
        Creator creator2 = new ConcreteCreator2();
        creator2.factoryA().show();
        creator2.factoryB().show();
    }
}

---

C井

Creator

    public interface Creator
    {
        ProductA factoryA();
        ProductB factoryB();
    }

ConcreteCreator

    public class ConcreteCreator1 : Creator
    {
        public ProductA factoryA() {
        return new ProductA1();
    }

    public ProductB factoryB() {
        return new ProductB1();
    }
    }


    public class ConcreteCreator2 : Creator
    {
        public ProductA factoryA() {
        return new ProductA2();
    }

    public ProductB factoryB() {
        return new ProductB2();
    }
    }

Product

    public interface ProductA
    {
        void show();
    }

    public interface ProductB
    {
        void show();
    }

ConcreteProduct

public class ProductA1 : ProductA
    {
        public void show() 
        {
            Console.WriteLine("ProductA1");
        }
    }

public class ProductA2 : ProductA
    {
        public void show()
        {
            Console.WriteLine("ProductA2");
        }

 public class ProductB1 : ProductB
    {
        public void show()
        {
            Console.WriteLine("ProductB1");
        }
    }

public class ProductB2 : ProductB
    {
        public void show()
        {
            Console.WriteLine("ProductB2");
        }
    }

Client

public static void Main(string[] args)
        {
            Creator creator1 = new ConcreteCreator1();
            creator1.factoryA().show();
            creator1.factoryB().show();
            Creator creator2 = new ConcreteCreator2();
            creator2.factoryA().show();
            creator2.factoryB().show();
            Console.ReadLine();
        }

---

C艹

Product

class ProductA
{
public:
    virtual void show() = 0;
};

class ProductB
{
public:
    virtual void show() = 0;
};

ConcreteProduct

class ProductA1 : public ProductA
{
public:
    virtual ~ProductA1() {};
    virtual void show()
    {
        cout << "ProductA1" << endl;
    };
};

class ProductA2 : public ProductA
{
public:
    virtual ~ProductA2() {};
    virtual void show()
    {
        cout << "ProductA2" << endl;
    };
};

class ProductB1 : public ProductB
{
public:
    virtual ~ProductB1() {};
    virtual void show()
    {
        cout << "ProductB1" << endl;
    };
};

class ProductB2 : public ProductB
{
public:
    virtual ~ProductB2() {};
    virtual void show()
    {
        cout << "ProductB2" << endl;
    };
};

Creator

class Creator
{
public:
    virtual ProductA* factoryA() = 0;
    virtual ProductB* factoryB() = 0;
};

ConcreteCreator

class ConcreteCreator1 : public Creator
{
public:
    virtual ~ConcreteCreator1() {};
    virtual ProductA* factoryA()
    {
        return new ProductA1;
    };
    virtual ProductB* factoryB()
    {
        return new ProductB1;
    };
};


class ConcreteCreator2 : public Creator
{
public:
    virtual ~ConcreteCreator2() {};
    virtual ProductA* factoryA()
    {
        return new ProductA2;
    };
    virtual ProductB* factoryB()
    {
        return new ProductB2;
    };
};

Client

int main()
{
    Creator* creator1 = new ConcreteCreator1;
    ProductA* productA1 = creator1->factoryA();
    productA1->show();
    delete productA1;
    ProductB* productB1 = creator1->factoryB();
    productB1->show();
    delete productB1;
    delete creator1;
    Creator* creator2 = new ConcreteCreator2;
    ProductA* productA2 = creator1->factoryA();
    productA2->show();
    delete productA2;
    ProductB* productB2 = creator1->factoryB();
    productB2->show();
    delete productB2;
    delete creator2;
    system("pause");
    return 0;
}

---