Метод Фабрика (шаблон)

UML диаграма на Метод Фабрика

Метод Фабрика е създаващ шаблон за дизайн, който се използва в обектно-ориентираното програмиране.

Фабриката има за цел инстанцирането на различни обекти, чиито типове не са предефинирани. Обектите се създават динамично в зависимост от параметрите предадени на фабриката. По принцип фабриките са единствени в дадена програма, затова за създаването им често се използва шаблонът Сек (Singleton).

Примери

C++

#include<iostream>
#include<string>
using namespace std;

// "Product"
class Product{
public:
	virtual string getName() = 0;
};

// "ConcreteProductA"
class ConcreteProductA: public Product{
public:
	string getName(){
		return "ConcreteProductA";
	}
};

// "ConcreteProductB"
class ConcreteProductB: public Product{
public:
	string getName(){
		return "ConcreteProductB";
	}
};

// "Creator"
class Creator{
public:
	virtual Product* FactoryMethod() = 0;
};

// "ConcreteCreatorA"
class ConcreteCreatorA: public Creator{
public:
	Product* FactoryMethod() {
		return new ConcreteProductA();
	}
};

// "ConcreteCreatorB"
class ConcreteCreatorB: public Creator{
public:
	Product* FactoryMethod() {
		return new ConcreteProductB();
	}
};

int main(){
	const int size = 2;
	// An array of creators
	Creator* creators[size];
      creators[0] = new ConcreteCreatorA();
      creators[1] = new ConcreteCreatorB();

	// Iterate over creators and create products
	for(int i=0;i<size;i++){
		Product* product = creators[i]->FactoryMethod();
		cout<<product->getName()<<endl;
		delete product;
	}

	int a;
	cin>>a;

	for(int i=0;i<size;i++){
		delete creators[i];
	}
	return 0;
}

C#

 // Factory Method pattern -- Structural example

  class MainApp
  {
    static void Main()
    {
      // An array of creators
      Creator[] creators = new Creator[2];
      creators[0] = new ConcreteCreatorA();
      creators[1] = new ConcreteCreatorB();

      // Iterate over creators and create products
      foreach(Creator creator in creators)
      {
        Product product = creator.FactoryMethod();
        Console.WriteLine("Created {0}",
          product.GetType().Name);
      }

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

  // "Product"

  abstract class Product
  {
  }

  // "ConcreteProductA"

  class ConcreteProductA: Product
  {
  }

  // "ConcreteProductB"

  class ConcreteProductB: Product
  {
  }

  // "Creator"

  abstract class Creator
  {
    public abstract Product FactoryMethod();
  }

  // "ConcreteCreatorA"

  class ConcreteCreatorA: Creator
  {
    public override Product FactoryMethod()
    {
      return new ConcreteProductA();
    }
  }

  // "ConcreteCreatorB"

  class ConcreteCreatorB: Creator
  {
    public override Product FactoryMethod()
    {
      return new ConcreteProductB();
    }
  }

Java

abstract class Pizza {
    public abstract double getPrice();
}

class HamAndMushroomPizza extends Pizza {
    private double price = 8.5;

    public double getPrice() {
        return price;
    }
}

class DeluxePizza extends Pizza {
    private double price = 10.5;

    public double getPrice() {
        return price;
    }
}

class HawaiianPizza extends Pizza {
    private double price = 11.5;

    public double getPrice() {
        return price;
    }
}

class PizzaFactory {
    public enum PizzaType {
        HamMushroom,
        Deluxe,
        Hawaiian
    }

    public static Pizza createPizza(PizzaType pizzaType) {
        switch (pizzaType) {
            case HamMushroom:
                return new HamAndMushroomPizza();
            case Deluxe:
                return new DeluxePizza();
            case Hawaiian:
                return new HawaiianPizza();
        }
        throw new IllegalArgumentException("The pizza type " + pizzaType + " is not recognized.");
    }
}

class PizzaLover {
    /**
     * Create all available pizzas and print their prices
     */
    public static void main (String args[]) {
        for (PizzaFactory.PizzaType pizzaType: PizzaFactory.PizzaType.values()) {
            System.out.println("Price of " + pizzaType + " is " + PizzaFactory.createPizza(pizzaType).getPrice());
        }
    }
}

 public class FactoryMethodExample
 {
     public static void main(String[] args)
     {
         // an array of creators
         Creator[] creators = new Creator[2];
         creators[0] = new ConcreteCreatorA();
         creators[1] = new ConcreteCreatorB();

         // iterate over creators and create products
         for (Creator creator: creators)
         {
             Product product = creator.factoryMethod();
             System.out.printf("Created {%s}\n", product.getClass());
         }
     }
 }

 // Product
 abstract class Product
 {
 }

 // ConcreteProductA
 class ConcreteProductA extends Product
 {
 }

 // ConcreteProductB
 class ConcreteProductB extends Product
 {
 }

 // Creator
 abstract class Creator
 {
     public abstract Product factoryMethod();
 }

 // Този клас може да има неопределен брой наследници.
 // За създаването на нужните ни обекти можем да напишем следните фабрики: ConcreteCreatorA, ConcreteCreatorB

 // ConcreteCreatorA
 class ConcreteCreatorA extends Creator
 {
     @Override
     public Product factoryMethod()
     {
         return new ConcreteProductA();
     }
 }

 // ConcreteCreatorB
 class ConcreteCreatorB extends Creator
 {
     @Override
     public Product factoryMethod()
     {
         return new ConcreteProductB();
     }
 }

 //Резултат:
 //Created {class ConcreteProductA}
 //Created {class ConcreteProductB}

Perl

START ===== D:\etl\Perl\DesignPatterns\RunFactoryDesignPattern.cmd
perl -w "D:\etl\Perl\DesignPatterns\RunFactoryDesignPattern.pl"

pause
END ================== D:\etl\Perl\DesignPatterns\RunFactoryDesignPattern.cmd

.
START ===== D:\etl\Perl\DesignPatterns\RunFactoryDesignPattern.pl
   use strict; use warnings;

    use GreetFactory;

    my $greeter_n = GreetFactory->instantiate("Repeat", "I am repeating Hello x amount of times \n", 3);
    $greeter_n->greet();

    my $greeter_stamp = GreetFactory->instantiate("Stamp", "The Stamp says Good-bye\n");
    $greeter_stamp->greet();
END ================== D:\etl\Perl\DesignPatterns\RunFactoryDesignPattern.pl

.
START ===== D:\etl\Perl\DesignPatterns\GreetFactory.pm
package GreetFactory;
use strict; use warnings;

# ARHH NO TIME HARDCODING ...
BEGIN{ push @INC, 'D:/etl/Perl/DesignPatterns'; }

    sub instantiate {
				my $class = shift;
				my $requested_type = shift;
				my $location = "Greet/$requested_type.pm";
				my $class = "Greet::$requested_type";

        require $location;

        return $class->new(@_);
    }

    1;
END ================== D:\etl\Perl\DesignPatterns\GreetFactory.pm

.
START ===== D:\etl\Perl\DesignPatterns\Greet\Repeat.pm
package Greet::Repeat;

sub new {
    my $class    = shift;
    my $self     = {
        greeting => shift,
        repeat   => shift,
    };
    return bless $self, $class;
}

sub greet {
    my $self = shift;
    print ($self->{greeting} x $self->{repeat});
}

1;
END ================== D:\etl\Perl\DesignPatterns\Greet\Repeat.pm

.
START ===== D:\etl\Perl\DesignPatterns\Greet\Stamp.pm
package Greet::Stamp;
use strict; use warnings;

sub new {
				my $class = shift;
				my $greeting = shift;
				return bless \$greeting, $class;
}

sub greet {
				my $greeting = shift;
				my $stamp = timestamp();
				print "$stamp $$greeting";
}

sub timestamp {
 #
 # Purpose: returns the time in yyyymmdd-format
 #
 my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
 #---- change 'month'- and 'year'-values to correct format ----
 $min = "0$min" if ($min < 10);
 $hour = "0$hour" if ($hour < 10);
 $mon = $mon + 1;
 $mon = "0$mon" if ($mon < 10);
 $year = $year + 1900;
 $mday = "0$mday" if ($mday < 10);
 return "$year$mon$mday" . "_" . "$hour$min" . "_" . $sec;
}

1;
END ================== D:\etl\Perl\DesignPatterns\Greet\Stamp.pm