WikiSort.ru - Не сортированное

Фабричный метод
	Factory Method
	; Фабричный метод (Factory Method)
Тип	Порождающий
Назначение	Для создания объектов различных типов одним интерфейсом
Плюсы	Создание объектов, независимо от их типов и сложности процесса создания.
Минусы	Даже для одного объекта необходимо создать соответствующую фабрику, что увеличивает код.
Описан в Design Patterns	Да

ПОИСК ПО САЙТУ | о проекте

Фабричный метод (англ. Factory Method также известен как Виртуальный конструктор (англ. Virtual Constructor)) — порождающий шаблон проектирования, предоставляющий подклассам (дочерним классам) интерфейс для создания экземпляров некоторого класса. В момент создания наследники могут определить, какой класс создавать. Иными словами, данный шаблон делегирует создание объектов наследникам родительского класса. Это позволяет использовать в коде программы не специфические классы, а манипулировать абстрактными объектами на более высоком уровне.

Цель

Определяет интерфейс для создания объекта, но оставляет подклассам решение о том, какой класс инстанцировать. Фабричный метод позволяет классу делегировать создание подклассов. Используется, когда:

классу заранее неизвестно, объекты каких подклассов ему нужно создавать.
класс спроектирован так, чтобы объекты, которые он создаёт, специфицировались подклассами.
класс делегирует свои обязанности одному из нескольких вспомогательных подклассов, и планируется локализовать знание о том, какой класс принимает эти обязанности на себя

Структура

Product — продукт
- определяет интерфейс объектов, создаваемых абстрактным методом;
ConcreteProduct — конкретный продукт
- реализует интерфейс Product;
Creator — создатель
- объявляет фабричный метод, который возвращает объект типа Product. Может также содержать реализацию этого метода «по умолчанию»;
- может вызывать фабричный метод для создания объекта типа Product;
ConcreteCreator — конкретный создатель
- переопределяет фабричный метод таким образом, чтобы он создавал и возвращал объект класса ConcreteProduct.

Достоинства

позволяет сделать код создания объектов более универсальным, не привязываясь к конкретным классам (ConcreteProduct), а оперируя лишь общим интерфейсом (Product);
позволяет установить связь между параллельными иерархиями классов.

Недостатки

необходимость создавать наследника Creator для каждого нового типа продукта (ConcreteProduct).

Swift

Пример на языке Swift

protocol Product {
    func getName() -> String
}

class ConcreteProductA: Product {
    func getName() -> String {  return "ConcreteProductA" }
}

class ConcreteProductB: Product {
    func getName() -> String { return "ConcreteProductB" }
}

protocol Creator {
    func factoryMethod() -> Product
}

class ConcreteCreatorA: Creator {
    func factoryMethod() -> Product { return ConcreteProductA() }
}

class ConcreteCreatorB: Creator {
    func factoryMethod() -> Product { return ConcreteProductB() }
}

let creatorA = ConcreteCreatorA()

let creatorB = ConcreteCreatorB()

let creators: [Creator] = [ creatorA, creatorB ]

creators.forEach {
    let product = $0.factoryMethod()
    print(product.getName())
}

Python

Пример на языке Python

#coding: utf-8
"""
Типы строя
"""
class Culture:
    """
    Культура
    """
    def __repr__(self):
        return self.__str__()

class Democracy(Culture):
    def __str__(self):
        return 'Democracy'

class Dictatorship(Culture):
    def __str__(self):
        return 'Dictatorship'

"""
Само правительство
"""
class Government:
    culture = ''
    def __str__(self):
        return self.culture.__str__()

    def __repr__(self):
        return self.culture.__repr__()

    def set_culture(self):
        """
        Задать строй правительству : это и есть наш Фабричный Метод
        """
        raise AttributeError('Not Implemented Culture')

"""
Правительство 1
"""
class GovernmentA(Government):
    def set_culture(self):
        self.culture = Democracy()

"""
Правительство 2
"""
class GovernmentB(Government):
    def set_culture(self):
        self.culture = Dictatorship()

g1 = GovernmentA()
g1.set_culture()
print (str(g1))

g2 = GovernmentB()
g2.set_culture()
print (str(g2))

Java

Пример на языке Java

interface Product { }

class ConcreteProductA implements Product { }

class ConcreteProductB implements Product { }

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

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

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

public class FactoryMethodExample {
    public static void main(String[] args) {
        // an array of creators
        Creator[] creators = {new ConcreteCreatorA(), new ConcreteCreatorB()};
        // iterate over creators and create products
        for (Creator creator: creators) {
            Product product = creator.factoryMethod();
            System.out.printf("Created {%s}\n", product.getClass());
        }
    }
}

Результат работы:

Created {class ConcreteProductA}

Created {class ConcreteProductB}

C++

Пример на языке C++

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

class Product{
public:
  virtual string getName() = 0;
  virtual ~Product() = default;
};

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

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

class Creator{
public: 
  virtual Product* factoryMethod() = 0;
  virtual ~Creator() = default;
};

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

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

int main()
{

  ConcreteCreatorA CreatorA;
  ConcreteCreatorB CreatorB;
  // An array of creators
  Creator*creators[] = {&CreatorA, &CreatorB};
  // Iterate over creators and create products
  for(auto&& creator: creators){
    Product* product=creator->factoryMethod();
    cout << product->getName() << endl;
    delete product;
  }
  return 0;
}

Результат работы:
ConcreteProductA
ConcreteProductB

C#

Пример на языке C#

using System;
using System.Collections.Generic;

namespace Factory
{
    abstract class Product
    {
        public abstract string GetType();
    }

    class ConcreteProductA : Product
    {
        public override string GetType() { return "ConcreteProductA"; }
    }

    class ConcreteProductB : Product
    {
        public override string GetType() { return "ConcreteProductB"; }
    }

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

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

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

    public class MainApp
    {
        public static void Main()
        {
            // an array of creators
            Creator[] creators = { new ConcreteCreatorA(), new ConcreteCreatorB() };
            // iterate over creators and create products
            foreach (Creator creator in creators)
            {
                Product product = creator.FactoryMethod();
                Console.WriteLine("Created {0}", product.GetType());
            }
            // Wait for user
            Console.Read();
        }
    }
}

JavaScript

Пример на языке JavaScript ES5

function Product() {this.getName=null;}
 
function ConcreteProductA() {
    this.getName=function(){return "ConcreteProductA"};
}
 
function ConcreteProductB() {
    this.getName=function(){return "ConcreteProductB"};
}
 
function Creator() {this.factoryMethod=null;}
 
function ConcreteCreatorA() {
    this.factoryMethod=function(){return new ConcreteProductA();};
}
 
function ConcreteCreatorB() {
    this.factoryMethod=function(){return new ConcreteProductB();};
}

ConcreteProductA.prototype = new Product();
ConcreteProductA.prototype.constructor = ConcreteProductA;

ConcreteProductB.prototype = new Product();
ConcreteProductB.prototype.constructor = ConcreteProductB;

ConcreteCreatorA.prototype = new Creator();
ConcreteCreatorA.prototype.constructor = ConcreteCreatorA;

ConcreteCreatorB.prototype = new Creator();
ConcreteCreatorB.prototype.constructor = ConcreteCreatorB;
 
// An array of creators
var creators = [new ConcreteCreatorA,new ConcreteCreatorB];
// Iterate over creators and create products
for (var i=0; i < creators.length; i++) {
    var product = creators[i].factoryMethod();
    console.log( product.getName() );
}

Пример на языке JavaScript ES6

class Product {
    GetName() {}
}

class ConcreteProductA extends Product {
    GetName() {
        return 'ProductA'
    }
}

class ConcreteProductB extends Product {
    GetName() {
        return 'ProductB'
    }
}

class Creator {
    FactoryMethod() {}
}

class ConcreteCreatorA extends Creator {
    FactoryMethod() {
        return new ConcreteProductA()
    }
}

class ConcreteCreatorB extends Creator {
    FactoryMethod() {
        return new ConcreteProductB()
    }
}

// An array of creators
const creators = [ new ConcreteCreatorA(), new ConcreteCreatorB() ]
const products = []

// Iterate over creators and create products
for (let creator of creators) {
    products.push(creator.FactoryMethod().GetName())
}

console.log(products)

Пример на языке TypeScript

interface Product {
    GetName(): string
}

class ConcreteProductA implements Product {
    public GetName() {
        return 'ProductA'
    }
}

class ConcreteProductB implements Product {
    public GetName() {
        return 'ProductB'
    }
}

interface Creator {
    FactoryMethod(): Product
}

class ConcreteCreatorA implements Creator {
    public FactoryMethod() {
        return new ConcreteProductA()
    }
}

class ConcreteCreatorB implements Creator {
    public FactoryMethod() {
        return new ConcreteProductB()
    }
}

// An array of creators
const creators: Creator[] = [ new ConcreteCreatorA(), new ConcreteCreatorB() ]
const products: string[] = []

// Iterate over creators and create products
for (let creator of creators) {
    products.push(creator.FactoryMethod().GetName())
}

console.log(products)

PHP5

Пример на языке PHP

<?php
interface Product{
    public function GetName();
}
 
class ConcreteProductA implements Product{
    public function GetName() { return "ProductA"; }
} 
 
class ConcreteProductB implements Product{
    public function GetName() { return "ProductB"; }
}
 
interface Creator{
    public function FactoryMethod();
} 
 
class ConcreteCreatorA implements Creator{
    public function FactoryMethod() { return new ConcreteProductA(); }
}

class ConcreteCreatorB implements Creator{
    public function FactoryMethod() { return new ConcreteProductB(); }
}

// An array of creators
$creators = array( new ConcreteCreatorA(), new ConcreteCreatorB() );
// Iterate over creators and create products
foreach ($creators as $creator) {
    $products[] = $creator->FactoryMethod()->getName();
}
 
header("content-type:text/plain");
echo var_export($products);
 
?>

PHP5 современный вариант

Сокращенный вариант паттерна, наиболее часто используемый в PHP

<?php
/**
 * Class Animal, со времен первой редакции книги прошло более 20 лет и этот паттерн немного эволюционировал,
 * и теперь всегда используют его сокращенную форму
 */
abstract class Animal
{
    // фабричный метод, который на основе типа возвращает объект
    public static function initial($animal)
    {
        return new $animal();
    }
    abstract public function voice();
}

class Lion extends Animal
{
    public function voice()
    {
        echo 'Rrrrrrrr i\'m the lion <br />' . PHP_EOL;
    }
}

class Cat extends Animal
{
    public function voice()
    {
        echo 'Meow, meow i\'m the kitty <br />' . PHP_EOL;
    }
}

$animal1 = Animal::initial('Lion');
$animal2 = Animal::initial('Cat');

$animal1->voice();
$animal2->voice();

Delphi

Пример на языке Delphi

program FactoryMethod;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type

// Product
TProduct = class(TObject)
public
  function GetName: string; virtual; abstract;
end;

// ConcreteProductA
TConcreteProductA = class(TProduct)
public
  function GetName: string; override;
end;

// ConcreteProductB
TConcreteProductB = class(TProduct)
public
  function GetName: string; override;
end;

// Creator
TCreator = class(TObject)
public
  function FactoryMethod: TProduct; virtual; abstract;
end;

// ConcreteCreatorA
TConcreteCreatorA = class(TCreator)
public
  function FactoryMethod: TProduct; override;
end;

// ConcreteCreatorB
TConcreteCreatorB = class(TCreator)
public
  function FactoryMethod: TProduct; override;
end;

{ ConcreteProductA }
function TConcreteProductA.GetName: string;
begin
  Result := 'ConcreteProductA';
end;

{ ConcreteProductB }
function TConcreteProductB.GetName: string;
begin
  Result := 'ConcreteProductB';
end;

{ ConcreteCreatorA }
function TConcreteCreatorA.FactoryMethod: TProduct;
begin
  Result := TConcreteProductA.Create;
end;

{ ConcreteCreatorB }
function TConcreteCreatorB.FactoryMethod: TProduct;
begin
  Result := TConcreteProductB.Create;
end;

const
  Count = 2;

var
  Creators: array[1..Count] of TCreator;
  Product: TProduct;
  I: Integer;

begin
  // An array of creators
  Creators[1] := TConcreteCreatorA.Create;
  Creators[2] := TConcreteCreatorB.Create;

  // Iterate over creators and create products
  for I := 1 to Count do
  begin
    Product := Creators[I].FactoryMethod;
    WriteLn(Product.GetName);
    Product.Free;
  end;

  for I := 1 to Count do
    Creators[I].Free;

  ReadLn;
end.

Пример на языке Delphi (виртуальные конструкторы)

program FactoryMethod;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type

// Product
TProduct = class(TObject)
private
  SubName : string;
public
  function GetName: string; virtual; abstract;
  function GetFullName: string;
  constructor Create; virtual; abstract;
end;

TProductClass = class of TProduct;

// ConcreteProductA
TConcreteProductA = class(TProduct)
public
  function GetName: string; override;
  constructor Create; override;
end;

// ConcreteProductB
TConcreteProductB = class(TProduct)
public
  function GetName: string; override;
  constructor Create; override;
end;

{ TProduct}
function TProduct.GetFullName: string;
begin
  Result := GetName + ' : ' + SubName;
end;


{ ConcreteProductA }
constructor TConcreteProductA.Create;
begin
  inherited;
  SubName := 'Product A subname';
end;

function TConcreteProductA.GetName: string;
begin
  Result := 'ConcreteProductA';
end;

{ ConcreteProductB }
constructor TConcreteProductB.Create;
begin
  inherited;
  SubName := 'Product B subname';
end;

function TConcreteProductB.GetName: string;
begin
  Result := 'ConcreteProductB';
end;

const
  Count = 2;

var
  Creators: array[1..Count] of TProductClass;
  Product: TProduct;
  I: Integer;

begin
  // An array of creators
  Creators[1] := TConcreteProductA;
  Creators[2] := TConcreteProductB;

  // Iterate over creators and create products
  for I := 1 to Count do
  begin
    Product := Creators[I].Create;
    WriteLn(Product.GetFullName);
    Product.Free;
  end;

  ReadLn;
end.

Action Script 3.0

Пример на языке Action Script 3.0

protected class Creator
{
    protected function factoryMethod():Product { return null; }

    public function someFunction():void
    {
        var _product:Product = factoryMethod();
            _product.doSome();
    }
}

public class ConcreteCreatorA extends Creator
{
    override protected function factoryMethod():Product
    {
        return new ConcreteProductA();
    }
}

public class ConcreteCreatorB extends Creator
{
    override protected function factoryMethod():Product
    {
        return new ConcreteProductB();
    }
}

public interface Product
{
    function doSome():void{}
}

internal class ConcreteProductA implements Product
{
    public function doSome():void{}
}

internal class ConcreteProductB implements Product
{
    public function doSome():void{}
}

//РЕАЛИЗАЦИЯ

public class Main
{
    public function Main()
    {
        var _creatorA:ConcreteCreatorA = new ConcreteCreatorA();
            _creatorA.someFunction();
        var _creatorB:ConcreteCreatorB = new ConcreteCreatorB();
            _creatorB.someFunction();
    }
}

Scala

Пример на языке Scala

abstract class AbstractProduct {

  def getName : String
}

abstract class AbstractCreator {

  def getProduct : AbstractProduct
}

class Beer extends AbstractProduct {

  override def getName: String = "Beer"
}

class Wine extends AbstractProduct {

  override def getName: String = "Wine"
}

class BeerCreator extends AbstractCreator {

  override def getProduct: AbstractProduct = new Beer
}

class WineCreator extends AbstractCreator {

  override def getProduct: AbstractProduct = new Wine
}

object Test {

  private def printProductName(creator: AbstractCreator) : Unit =
    println(creator.getProduct.getName)

  def main(args: Array[String]) : Unit =
    printProductName(new BeerCreator)
    printProductName(new WineCreator)
}

Результат работы:
Created: Wine Created: Beer

Литература

Э. Гамма, Р. Хелм, Р. Джонсон, Дж. Влиссидес. Приемы объектно–ориентированного проектирования. Паттерны проектирования = Design Patterns: Elements of Reusable Object-Oriented Software. — СПб.: «Питер», 2007. — С. 366. — ISBN 978-5-469-01136-1. (также ISBN 5-272-00355-1)

Это заготовка статьи по информатике. Вы можете помочь проекту, дополнив её.

Данная страница на сайте WikiSort.ru содержит текст со страницы сайта "Википедия".

Если Вы хотите её отредактировать, то можете сделать это на странице редактирования в Википедии.

Если сделанные Вами правки не будут кем-нибудь удалены, то через несколько дней они появятся на сайте WikiSort.ru .

Текст в блоке "Читать" взят с сайта "Википедия" и доступен по лицензии Creative Commons Attribution-ShareAlike; в отдельных случаях могут действовать дополнительные условия.

Другой контент может иметь иную лицензию. Перед использованием материалов сайта WikiSort.ru внимательно изучите правила лицензирования конкретных элементов наполнения сайта.

2019-2024
WikiSort.ru - проект по пересортировке и дополнению контента Википедии

Шаблоны проектирования
Основные	Делегирования Интерфейс Неизменяемый объект Функционального дизайна
Порождающие	Абстрактная фабрика Объектный пул Одиночка Отложенная инициализация Прототип Строитель Фабричный метод
Структурные	Адаптер Выделение частного класса данных Декоратор Заместитель Компоновщик Мост Приспособленец Фасад
Поведенческие	Интерпретатор Итератор Команда Наблюдатель Посетитель Посредник Состояние Стратегия Хранитель Null Object Цепочка обязанностей Шаблонный метод
Параллельного программирования	Блокировка с двойной проверкой Однопоточное выполнение Планировщик Производитель-потребитель Активный объект
Архитектурные	Локатор служб
Книги	Design Patterns
Персоналии	Кристофер Александер Эрих Гамма Джон Влиссидес Гради Буч Кент Бек Говард Каннингем Мартин Фаулер Роберт Мартин

Фабричный метод
Factory Method
Фабричный метод (Factory Method)
Тип	Порождающий
Назначение	Для создания объектов различных типов одним интерфейсом
Плюсы	Создание объектов, независимо от их типов и сложности процесса создания.
Минусы	Даже для одного объекта необходимо создать соответствующую фабрику, что увеличивает код.
Описан в Design Patterns	Да