Basic difference between Abstract Factory and Factory?

Question

I was taking a look at Manual for PHP and saw an example of implementing the standard Factory.

Example:

class Exemplo
{
    // Método Factory parametrizado
    public static function factory($type)
    {
        if (include_once 'Drivers/' . $type . '.php') {
            $classname = 'Driver_' . $type;
            return new $classname;
        } else {
            throw new Exception ('Driver não encontrado');
        }
    }
}

Exit:

// Carregar um driver MySQL
$mysql = Exemplo::factory('MySQL');

// Carregar um driver SQLite 
$sqlite = Exemplo::factory('SQLite');

In the PHP the Right Way, I saw that, through the Factory, a class simply creates the object you’d like to use.

I have no example of Abstract Factory, but I’ve seen it in a course I’ve done. And it’s got me confused.

I would like to know, as simply as possible, what the differences are between these two Patterns (standards).

Answer 1

The name of Pattern until it is quite significant.

Basically, Abstract Factory is the technique of using a Factory abstracting the knowledge of the concrete implementation of that Factory.

The same way as a Factory has the ability to abstract the concreted implementation of the type it delivers by returning for example an interface instead of returning a class, the default Abstract Factory determines an interface of Factory abstracting the concrete implementation of the Factory which is returned to the consumer of Factory.

Example in pseudo-code

Factory

Factory factory = new Factory();
IObjeto objeto = factory.create();

Abstract Factory

IFactory factory = abstractFactory.create();
IObjeto objeto = factory.create();

In these examples, Iobject and Ifactory are declarations of interfaces and not of types. The type of object that is actually obtained in each of the examples is "unknown" or irrelevant to the consumer.

The concrete implementation of Factory which will be obtained by using the Pattern Abstract Factory will then depend on decisions external to the consumer code of the Factory, and will be determined for example by configuration file, observance of business rules, dependency injection, etc.

Remembering that I mentioned interface in the sense of a contract. Although interface declaration is a fairly common basic resource in object-oriented languages, you do not necessarily need to use this type of statement if it is not required by the language or if there is a nicer way.