Abstract factory pattern and its PHP implementation

The Abstract Factory pattern is a creational pattern that provides a way to encapsulate a set of separate factories with the same theme. Its essence is to "provide interfaces to create a series of related or independent objects without specifying the specific classes of these objects."

The abstract factory pattern provides an interface for creating system-related or interdependent objects without specifying their concrete classes.

Main roles in the Abstract Factory pattern

Abstract Factory role: It declares the interface for creating abstract product objects

Concrete Factory (Concrete Factory) role: Implements the operation of creating product objects

Abstract Product (Abstract Product) Role: declares the interface of a type of product

Concrete Product role: implements the interface defined by the abstract product role

This is similar to the factory method pattern. We no longer only need one burger, but maybe 4 burgers and 2 chicken wings. , we still told the waiter that the waiter belongs to the concrete factory, the abstract product is the food that McDonald's can sell, and the specific product is the food we ask the waiter for.

Applicability

When a system is created, assembled and represented independently of its products.

When a system is to be configured by one of multiple product series.

It is necessary to emphasize the design of a series of related product objects for joint use.

Provide a product class library and only want to display their interfaces rather than their implementations.

Class Diagram

Instance

<?php
class Button{}
class Border{}
class MacButton extends Button{}
class WinButton extends Button{}
class MacBorder extends Border{}
class WinBorder extends Border{}
interface AbstractFactory {
    public function CreateButton();
    public function CreateBorder();
}
class MacFactory implements AbstractFactory{
    public function CreateButton(){ return new MacButton(); }
    public function CreateBorder(){ return new MacBorder(); }
}
class WinFactory implements AbstractFactory{
    public function CreateButton(){ return new WinButton(); }
    public function CreateBorder(){ return new WinBorder(); }
}
?>

In this example, the factory class implements a set of factory methods. If you want to add new functions, you can add a new interface and let the new factory class implement this interface without modifying the existing factory class.

Advantages and Disadvantages

Advantages

Separates specific categories

Makes it easy to add or replace product families

Conducive to product consistency

Disadvantages

Difficult to support new types of products. This is because the AbstractFactory interface determines the collection of products that can be created. Supporting new types of products requires extending the factory access interface, resulting in changes to the AbstractFactory class and all its subclasses.