The Abstract Factory design pattern provides a solution:
Encapsulate creating a family of objects in a separate factory object.
A class delegates object creation to a factory object
instead of instantiating concrete classes directly.
Describing the Abstract Factory design in more detail is the theme of the following sections.
See Applicability section for all problems Abstract Factory can solve.

• The key idea in this pattern is to abstract the process of object creation. [BGI]
  The process of object creation (new ProductA1(), for example) is abstracted by referring to an interface (delegating to a factory object): factory.createProductA().
  There is no longer anything in the client code that instantiates a concrete class.
  "Creational patterns ensure that your application is written in terms of interfaces, not imple­mentations." [GoF, p18]
• Define separate factory objects:
  
  • For all supported families of objects, define a common interface for creating a family of objects (AbstractFactory | createProductA(),createProductB(),…).
  • Define classes (Factory1,…) that implement the interface.
    
• This enables compile-time flexibility (via inheritance).
  The way objects are created can be implemented and changed independently from clients by defining new (sub)classes.
• A class (Client) delegates the responsibility for creating objects to a factory object (factory.createProductA(),factory.createProductB(),…).
  
• This enables run-time flexibility (via object composition).
  A class can be configured with a factory object, which it uses to create objects, and even more, the factory object can be exchanged dynamically.