Comportamento atteso dal cliente quando si pensa ai modelli di progettazione?

Sono confuso dal comportamento che dovrei aspettarmi da un cliente quando penso ai modelli di progettazione. Per essere più precisi, sto leggendo il libro Head First Design Patterns, e sulla differenza tra la fabbrica astratta e il modello di metodo di fabbrica, spiega che usando un metodo di fabbrica, non abbiamo il pieno controllo degli "ingredienti" "utilizzato nella" Pizza "prodotta nelle nostre fabbriche. Ecco alcuni snippet di pseudo-codice per chiarire un po 'di più questo esempio forzato:

public abstract class PizzaStore{
  public Pizza orderPizza(string type){
    Pizza pizza = createPizza(type);
    pizza.prepare();
    //...
    pizza.box();
  }
protected abstract Pizza createPizza(string type);
}

Ora ogni sottoclasse ha l'opportunità (responsabilità) di definire il metodo createPizza come preferisce. Anche la pizza è una classe astratta e i clienti la estendono e definiscono le loro pizze come desiderano. Ovviamente non abbiamo il controllo sugli ingredienti usati nelle pizze da coloro che lo estendono.

Ma poi, quando si tratta della fabbrica astratta, questa è l'interfaccia utilizzata per gli ingredienti:

public interface PizzaIngredientFactory {
  public Dough createDough();
  public Sauce createSauce();
  //...
}

ed è così che lo userà un tipo specifico di Pizza:

public class CheesePizza extends Pizza {
  PizzaIngredientFactory ingredientFactory;
  public CheesePizza(PizzaIngredientFactory ingredientFactory)
    this.ingredientFactory = ingredientFactory;
  }
  void prepare() {
    System.out.println(“Preparing “ + name);
    dough = ingredientFactory.createDough();
    sauce = ingredientFactory.createSauce();
    //...
  }

Ora una NYPizzaIngredientFactory può essere inviata a CheesePizza per renderla NYish! Ma ... E se non lo facessero? Come sappiamo che il client del nostro codice userà questo CheesePizza nel metodo createPizza? Penso che non ne abbiamo il controllo. O anche se forniamo una fabbrica astratta e l'utente implementa un metodo di fabbrica e ancora una volta usa i propri ingredienti? Ad esempio, Cosa succede se il cliente crea un ChicagoPizzaStore estendendo il PizzaStore e quindi per implementare il metodo createPizza utilizza un metodo factory? Li abbiamo costretti a usare la nostra fabbrica astratta con ogni mezzo che mi manca?

Possono aggirare usando le fabbriche degli "ingredienti" che abbiamo fabbricato per loro, potrebbero persino non essere a conoscenza di questa caratteristica (fabbrica astratta) che abbiamo fornito per loro a meno che non facciano capolino dal nostro codice. Mi sento perso in questo. Un cliente è colui che usa il nostro codice ma penso che ho bisogno di sapere di più su come dovrei guardarlo e sapere cosa dovrei avere in mente su di loro che conta di più nel caso di modelli di design. (Ci scusiamo per i probabili errori di grammatica inglese, grazie).

Modifica _ Penso che valga anche la pena di menzionare dove iniziò la confusione. È stato dopo aver letto questa frase nel libro: "Come stai assicurarti che ogni franchising stia utilizzando ingredienti di qualità?". In realtà, il modello non sembra un vero vincolo sul client.