Abstract Factory

最新推荐文章于 2024-04-25 09:25:45 发布

我不是大明

最新推荐文章于 2024-04-25 09:25:45 发布

阅读量397

点赞数

分类专栏： Design Patterns 文章标签： class interface constructor object application output

Design Patterns 专栏收录该内容

19 篇文章

订阅专栏

e.g.

For example, there is a program to make out animals world in different continents.

Different continent has its owner different carnivores and Herbivores. So we can use abstract factory to create the different animals.

participants

In Asia tigers eat other animals and in Africa Lions eat other animals.

// Abstract Factory pattern -- Real World example

using System;

namespace DoFactory.GangOfFour.Abstract.RealWorld
{
  // MainApp test application

  class MainApp
  {
    public static void Main ()
    {
      // Create and run the Africa animal world
      ContinentFactory africa = new AfricaFactory();
      AnimalWorld world = new AnimalWorld( africa );
      world.RunFoodChain();

      // Create and run the America animal world
      ContinentFactory america = new AmericaFactory();
      world = new AnimalWorld( america );
      world.RunFoodChain();

      // Wait for user input
      Console.Read();
    }
  }

  // "AbstractFactory"

  abstract class ContinentFactory
  {
    public abstract Herbivore CreateHerbivore();
    public abstract Carnivore CreateCarnivore();
  }

  // "ConcreteFactory1"

  class AfricaFactory : ContinentFactory
  {
    public override Herbivore CreateHerbivore()
    {
      return new Wildebeest();
    }
    public override Carnivore CreateCarnivore()
    {
      return new Lion();
    }
  }

  // "ConcreteFactory2"

  class AmericaFactory : ContinentFactory
  {
    public override Herbivore CreateHerbivore()
    {
      return new Bison();
    }
    public override Carnivore CreateCarnivore()
    {
      return new Wolf();
    }
  }

  // "AbstractProductA"

  abstract class Herbivore
  {
  }

  // "AbstractProductB"

  abstract class Carnivore
  {
    public abstract void Eat(Herbivore h);
  }

  // "ProductA1"

  class Wildebeest : Herbivore
  {
  }

  // "ProductB1"

  class Lion : Carnivore
  {
    public override void Eat(Herbivore h)
    {
      // Eat Wildebeest
      Console.WriteLine(this.GetType().Name +
        " eats " + h.GetType().Name);
    }
  }

  // "ProductA2"

  class Bison : Herbivore
  {
  }

  // "ProductB2"

  class Wolf : Carnivore
  {
    public override void Eat(Herbivore h)
    {
      // Eat Bison
      Console.WriteLine(this.GetType().Name +
        " eats " + h.GetType().Name);
    }
  }

  // "Client"

  class AnimalWorld
  {
    private Herbivore herbivore;
    private Carnivore carnivore;

    // Constructor
    public AnimalWorld(ContinentFactory factory)
    {
      carnivore = factory.CreateCarnivore();
      herbivore = factory.CreateHerbivore();
    }

    public void RunFoodChain()
    {
      carnivore.Eat(herbivore);
    }
  }
}

Output

Lion eats Wildebeest
Wolf eats Bison

The classes and/or objects participating in this pattern are:

AbstractFactory (ContinentFactory)
- declares an interface for operations that create abstract products
ConcreteFactory (AfricaFactory, AmericaFactory)
- implements the operations to create concrete product objects
AbstractProduct (Herbivore, Carnivore)
- declares an interface for a type of product object
Product (Wildebeest, Lion, Bison, Wolf)
- defines a product object to be created by the corresponding concrete factory
- implements the AbstractProduct interface
Client (AnimalWorld)
- uses interfaces declared by AbstractFactory and AbstractProduct classes