когда нужно заморачиваться с паттерном Abstract Factory?

Перечень паттернов можно найти здесь.

Что такое паттерн проектирования Abstract Factory?

Привет! Если вы хоть раз задумывались о том, как сделать свой код более гибким и расширяемым, то наверняка слышали про паттерны проектирования. Сегодня мы поговорим об одном из них – Abstract Factory (Абстрактная Фабрика). Звучит страшно? Давай разбираться вместе!

В общем-то, это не так сложно, как кажется. Представьте себе ситуацию: вы разрабатываете игру с разными типами персонажей – эльфы, орки, гномы. У каждого типа свои особенности – оружие, броня, умения. И вот вам нужно создавать этих персонажей в большом количестве. Писать кучу if-ов для определения типа и создания нужных объектов? Это не очень красиво и уж точно не масштабируемо. Вот тут-то на помощь и приходит Abstract Factory!


Что же это за зверь такой – Abstract Factory?

Abstract Factory — это паттерн проектирования, который предоставляет интерфейс для создания семейств связанных или зависимых объектов, не указывая их конкретные классы. Звучит как заклинание, правда? Позвольте объяснить.

Вместо того чтобы напрямую создавать объекты (например, ElfWeapon, OrcArmor), мы создаем фабрики, которые знают, какие именно объекты нужно создать для каждого типа персонажа. Каждая фабрика отвечает за создание целого семейства объектов – оружия, брони, умений и так далее.

А знаете что? Это как если бы у вас была кондитерская с разными отделами: один делает торты, другой — пирожные, третий — печенье. Вы не ходите в каждый отдел отдельно, а обращаетесь к общей фабрике (кондитерской), которая уже знает, какие сладости вам нужны.


Зачем вообще это нужно?

Хороший вопрос! Вот несколько причин:

  • Гибкость: Легко добавлять новые типы персонажей и их соответствующие объекты, не меняя существующий код. Просто создаете новую фабрику – и все!
  • Расширяемость: Можно легко расширить функциональность, добавляя новые семейства объектов (например, добавить магических существ).
  • Изоляция: Код становится более изолированным и независимым от конкретных классов объектов. Это упрощает тестирование и поддержку.

Пример из жизни: как это работает?

Представим себе простую игру с эльфами и орками. У каждого типа персонажа есть оружие и броня. Пример на Python:

class Weapon:
    def __init__(self, name):
        self.name = name

class Armor:
    def __init__(self, type):
        self.type = type

# Абстрактная фабрика
class AbstractFactory:
    def create_weapon(self):
        raise NotImplementedError

    def create_armor(self):
        raise NotImplementedError

# Фабрика для эльфов
class ElfFactory(AbstractFactory):
    def create_weapon(self):
        return Weapon("Эльфийский лук")

    def create_armor(self):
        return Armor("Кожаная броня")

# Фабрика для орков
class OrcFactory(AbstractFactory):
    def create_weapon(self):
        return Weapon("Оркский топор")

    def create_armor(self):
        return Armor("Железная броня")

# Клиентский код
def create_character(factory):
    weapon = factory.create_weapon()
    armor = factory.create_armor()
    print(f"Оружие: {weapon.name}, Броня: {armor.type}")

elf_factory = ElfFactory()
orc_factory = OrcFactory()

create_character(elf_factory) # Оружие: Эльфийский лук, Броня: Кожаная броня
create_character(orc_factory) # Оружие: Оркский топор, Броня: Железная броня

Видите? Мы не пишем if-ы для определения типа персонажа. Просто создаем нужную фабрику и получаем соответствующие объекты. Честно говоря, это гораздо элегантнее!


Swift

protocol Weapon {
    var name: String { get }
}

protocol Armor {
    var type: String { get }
}

protocol AbstractFactory {
    func createWeapon() -> Weapon
    func createArmor() -> Armor
}

class ElfWeapon: Weapon {
    let name = "Эльфийский лук"
}

class OrcWeapon: Weapon {
    let name = "Оркский топор"
}

class ElfArmor: Armor {
    let type = "Кожаная броня"
}

class OrcArmor: Armor {
    let type = "Железная броня"
}

class ElfFactory: AbstractFactory {
    func createWeapon() -> Weapon {
        return ElfWeapon()
    }

    func createArmor() -> Armor {
        return ElfArmor()
    }
}

class OrcFactory: AbstractFactory {
    func createWeapon() -> Weapon {
        return OrcWeapon()
    }

    func createArmor() -> Armor {
        return OrcArmor()
    }
}

func createCharacter(factory: AbstractFactory) {
    let weapon = factory.createWeapon()
    let armor = factory.createArmor()
    print("Оружие: \(weapon.name), Броня: \(armor.type)")
}

let elfFactory = ElfFactory()
let orcFactory = OrcFactory()

createCharacter(factory: elfFactory) // Оружие: Эльфийский лук, Броня: Кожаная броня
createCharacter(factory: orcFactory) // Оружие: Оркский топор, Броня: Железная броня

В Swift мы используем протоколы для определения интерфейсов Weapon и Armor, а также протокол AbstractFactory. Это позволяет нам создавать гибкие и расширяемые типы.


Java

interface Weapon {
    String getName();
}

interface Armor {
    String getType();
}

interface AbstractFactory {
    Weapon createWeapon();
    Armor createArmor();
}

class ElfWeapon implements Weapon {
    @Override
    public String getName() {
        return "Эльфийский лук";
    }
}

class OrcWeapon implements Weapon {
    @Override
    public String getName() {
        return "Оркский топор";
    }
}

class ElfArmor implements Armor {
    @Override
    public String getType() {
        return "Кожаная броня";
    }
}

class OrcArmor implements Armor {
    @Override
    public String getType() {
        return "Железная броня";
    }
}

class ElfFactory implements AbstractFactory {
    @Override
    public Weapon createWeapon() {
        return new ElfWeapon();
    }

    @Override
    public Armor createArmor() {
        return new ElfArmor();
    }
}

class OrcFactory implements AbstractFactory {
    @Override
    public Weapon createWeapon() {
        return new OrcWeapon();
    }

    @Override
    public Armor createArmor() {
        return new OrcArmor();
    }
}

public class Main {
    public static void createCharacter(AbstractFactory factory) {
        Weapon weapon = factory.createWeapon();
        Armor armor = factory.createArmor();
        System.out.println("Оружие: " + weapon.getName() + ", Броня: " + armor.getType());
    }

    public static void main(String[] args) {
        ElfFactory elfFactory = new ElfFactory();
        OrcFactory orcFactory = new OrcFactory();

        createCharacter(elfFactory); // Оружие: Эльфийский лук, Броня: Кожаная броня
        createCharacter(orcFactory); // Оружие: Оркский топор, Броня: Железная броня
    }
}

В Java мы используем интерфейсы Weapon и Armor, а также интерфейс AbstractFactory. Обратите внимание на использование ключевого слова implements для реализации интерфейсов.


JavaScript

class Weapon {
  constructor(name) {
    this.name = name;
  }

  getName() {
    return this.name;
  }
}

class Armor {
  constructor(type) {
    this.type = type;
  }

  getType() {
    return this.type;
  }
}

class AbstractFactory {
  createWeapon() {
    throw new Error('Method not implemented.');
  }

  createArmor() {
    throw new Error('Method not implemented.');
  }
}

class ElfFactory extends AbstractFactory {
  createWeapon() {
    return new Weapon("Эльфийский лук");
  }

  createArmor() {
    return new Armor("Кожаная броня");
  }
}

class OrcFactory extends AbstractFactory {
  createWeapon() {
    return new Weapon("Оркский топор");
  }

  createArmor() {
    return new Armor("Железная броня");
  }
}

function createCharacter(factory) {
  const weapon = factory.createWeapon();
  const armor = factory.createArmor();
  console.log(`Оружие: ${weapon.getName()}, Броня: ${armor.getType()}`);
}

const elfFactory = new ElfFactory();
const orcFactory = new OrcFactory();

createCharacter(elfFactory); // Оружие: Эльфийский лук, Броня: Кожаная броня
createCharacter(orcFactory); // Оружие: Оркский топор, Броня: Железная броня

В JavaScript мы используем классы Weapon и Armor, а также класс AbstractFactory. Обратите внимание на использование ключевого слова extends для наследования классов. Также стоит отметить, что в JavaScript нет строгой типизации, поэтому мы можем использовать любые типы данных.


Что общего?

Во всех трех примерах мы видим одну и ту же структуру:

  • Абстрактные продукты: Интерфейсы или классы Weapon и Armor.
  • Абстрактная фабрика: Интерфейс или класс AbstractFactory.
  • Конкретные фабрики: Классы ElfFactory и OrcFactory, которые реализуют интерфейс AbstractFactory и создают конкретные объекты.

Этот паттерн позволяет нам создавать семейства связанных объектов, не указывая их конкретные классы. Это делает наш код более гибким и расширяемым. Честно говоря, это очень полезно в больших проектах!


Когда стоит задуматься об Abstract Factory?

  • Когда у вас есть семейства связанных объектов, которые должны быть согласованы друг с другом.
  • Когда вы хотите избежать жесткой зависимости от конкретных классов объектов.
  • Когда вам нужно легко добавлять новые типы объектов и их семейства.

Но! Не стоит использовать этот паттерн без необходимости. Если у вас всего несколько типов объектов и они не связаны между собой, то проще обойтись без Abstract Factory. Иногда простота – лучшее решение.


В заключение

Abstract Factory — это мощный инструмент для создания гибкого и расширяемого кода. Он позволяет вам легко добавлять новые типы объектов и их семейства, не меняя существующий код. Но помните: как и любой другой паттерн проектирования, его нужно использовать с умом! Иначе можно только усложнить себе жизнь.

Надеюсь, теперь вы немного лучше понимаете, что такое Abstract Factory и когда он может быть полезен. А вы знали, что этот паттерн часто используется в игровых движках? Подумайте об этом!


Будет интересно

Nikulux в Telegram

Статьи, архивы материалов, скоро ещё и мемы

(= Подписаться =)