fábrica sencilla vs método de fábrica

O. Shekriladze:

simple de la fábrica:

método de fábrica:

Hola a todos. Busco a la diferencia entre la fábrica simple y método de fábrica .. Sé que la diferencia estructural (imágenes superiores), pero no puedo entender la diferencia en los casos de uso. por ejemplo, esta es la explicación para el método de fábrica:

En el patrón Factory Method vamos a introducir una nueva interfaz llamada 'IMobileFactory' y dos de implementación concreta 'NokiaFactory' y 'IphoneFactory'. Estas clases concretas controlan la creación de objetos.

En mi ejemplo, el cliente quiere un objeto de Nokia. Por lo que los pasos se dan a continuación.

1.The client will load a reference to ‘NokiaFactory’. But Client won’t refer the ‘NokiaFactory’ class directly like the Simple Factory pattern. The client refers the concrete implementation through an interface ‘IMobileFactory’.

2.Then the Client call the ‘CreateMobile()’ method that will return an object of type ‘IMobile’.

3.Here we have to inform the client the concrete implementation to be used through some configuration or parameters.

I can't understand the first step:

But Client won’t refer the ‘NokiaFactory’ class directly like the Simple Factory pattern. The client refers the concrete implementation through an interface ‘IMobileFactory’.

so client writes something like this:

IMobileFactory factory = LoadFactory("NokiaFactory");

so why is that useful and better? what's the benefit? why shouldn't I just write this:

NokiaFactory factory = new NokiaFactory();

or what about that:

IMobileFactory factory = new NokiaFactory();

Nghia Bui :

So your question is about comparing this design #1:

IMobileFactory factory = LoadFactory("NokiaFactory");

to this design #2:

NokiaFactory factory = new NokiaFactory(); // or:
IMobileFactory factory = new NokiaFactory();

As you see the biggest difference is that, while the client in the design #1 does not know about any concrete type like NokiaFactory or IPhoneFactory, the client in the design #2 does.

The downside of knowing about concrete things like NokiaFactory or IPhoneFactory should be well-known. If you want to make changes to these types, for example, you want to add a new method to NokiaFactory and this method is not a part of the IMobileFactory interface, then the client code will be affected unnecessarily. The client does not care about the new method, but its code must be recompiled/redeployed.

UPDATE

To explain more.

For example, a new method named Foo is added to the NokiaFactory class:

class NokiaFactory {
    // old code
    public void Foo() { ... }
}

FooNo es un método de la IMobileFactoryinterfaz, pero se añade a NokiaFactoryporque hay otro cliente que requiere el método, y que el cliente está dispuesto a depender de NokiaFactoryla clase. En otras palabras, ese cliente daría la bienvenida a los cambios de NokiaFactoryclase, pero el primer cliente no lo haría.