Quelles sont les différences entre les patrons de conception Abstract Factory et Factory ?

Question

Je sais qu'il existe de nombreux articles sur les différences entre ces deux modèles, mais il y a quelques éléments que je ne trouve pas.

D'après ce que j'ai lu, je vois que le modèle de méthode factory permet de définir comment créer un seul produit concret, tout en cachant l'implémentation au client, qui verra un produit générique. Ma première question concerne l'usine abstraite. Son rôle est-il de vous permettre de créer des familles d'objets concrets (qui peuvent dépendre de la fabrique spécifique que vous utilisez) plutôt qu'un seul objet concret ? La fabrique abstraite ne renvoie-t-elle qu'un seul très gros objet ou plusieurs objets en fonction des méthodes que vous appelez ?

Mes deux dernières questions portent sur une seule citation que je n'arrive pas à comprendre entièrement et que j'ai vue à de nombreux endroits :

Une différence entre les deux est que avec le modèle Abstract Factory, une classe délègue la responsabilité de l'instanciation d'un objet à un autre objet via la composition, alors que le modèle Factory Method utilise l'héritage et s'appuie sur une sous-classe pour gérer la l'instanciation de l'objet souhaité.

Si j'ai bien compris, le modèle de méthode d'usine possède une interface Creator qui fait que le ConcreteCreator est chargé de savoir quel ConcreteProduct instancier. Est-ce cela que signifie l'utilisation de l'héritage pour gérer l'instanciation des objets ?

Maintenant, en ce qui concerne cette citation, comment exactement le modèle Abstract Factory délègue-t-il la responsabilité de l'instanciation de l'objet à un autre objet via la composition ? Qu'est-ce que cela signifie ? À mes yeux, il semble que le modèle Abstract Factory utilise également l'héritage pour effectuer le processus de construction, mais là encore, je suis toujours en train d'apprendre à connaître ces modèles.

Toute aide, en particulier pour la dernière question, serait grandement appréciée.

Answer 1

Usine abstraite : Une fabrique de fabriques ; une fabrique qui regroupe les fabriques individuelles mais liées/dépendantes sans spécifier leurs classes concrètes. Exemple de fabrique abstraite

Usine : Il fournit un moyen de déléguer la logique d'instanciation aux classes filles. Exemple de modèle d'usine

Answer 2

Permettez-moi de le dire précisément. La plupart des réponses ont déjà expliqué, fourni des diagrammes et des exemples également.

Donc ma réponse serait juste une phrase. Mes propres mots : "Un modèle de fabrique abstraite ajoute une couche abstraite sur de multiples implémentations de méthodes de fabrique. Cela signifie qu'une usine abstraite contient ou composite un ou plusieurs modèles de méthode d'usine"

Answer 3

Beaucoup de réponses précédentes ne fournissent pas de comparaisons de code entre l'Abstract Factory et le Factory Method pattern. Ce qui suit est ma tentative d'explication via Java. J'espère que cela aidera quelqu'un qui a besoin d'une explication simple.

Comme GoF dit avec justesse : L'usine abstraite fournit une interface pour créer des familles d'objets liés ou dépendants sans spécifier leurs classes concrètes.

public class Client {
    public static void main(String[] args) {
        ZooFactory zooFactory = new HerbivoreZooFactory();
        Animal animal1 = zooFactory.animal1();
        Animal animal2 = zooFactory.animal2();
        animal1.sound();
        animal2.sound();

        System.out.println();

        AnimalFactory animalFactory = new CowAnimalFactory();
        Animal animal = animalFactory.createAnimal();
        animal.sound();
    }
}

---

public interface Animal {
    public void sound();
}

public class Cow implements Animal {

    @Override
    public void sound() {
        System.out.println("Cow moos");
    }
}

public class Deer implements Animal {

    @Override
    public void sound() {
        System.out.println("Deer grunts");
    }

}

public class Hyena implements Animal {

    @Override
    public void sound() {
        System.out.println("Hyena.java");
    }

}

public class Lion implements Animal {

    @Override
    public void sound() {
        System.out.println("Lion roars");
    }

}

---

public interface ZooFactory {
    Animal animal1();

    Animal animal2();
}

public class CarnivoreZooFactory implements ZooFactory {

    @Override
    public Animal animal1() {
        return new Lion();
    }

    @Override
    public Animal animal2() {
        return new Hyena();
    }

}

public class HerbivoreZooFactory implements ZooFactory {

    @Override
    public Animal animal1() {
        return new Cow();
    }

    @Override
    public Animal animal2() {
        return new Deer();
    }

}

---

public interface AnimalFactory {
    public Animal createAnimal();
}

public class CowAnimalFactory implements AnimalFactory {

    @Override
    public Animal createAnimal() {
        return new Cow();
    }

}

public class DeerAnimalFactory implements AnimalFactory {

    @Override
    public Animal createAnimal() {
        return new Deer();
    }

}

public class HyenaAnimalFactory implements AnimalFactory {

    @Override
    public Animal createAnimal() {
        return new Hyena();
    }

}

public class LionAnimalFactory implements AnimalFactory {

    @Override
    public Animal createAnimal() {
        return new Lion();
    }

}

Answer 4

Abstract factory design pattern with realtime example : qu'est-ce qu'un abstract factory design pattern ? Il est similaire au factory method design pattern. nous devons utiliser ce pattern lorsque nous avons plusieurs factories. il y aura un regroupement de factories défini dans ce pattern. factory method pattern est un sous-ensemble de abstract factory design pattern. Ils ont les mêmes avantages que les factory patterns. abstract factory repose sur la composition d'objets alors que le factory method traite de l'héritage. factory design pattern en java avec un exemple en temps réel : qu'est-ce que le factory design pattern ? il est surtout utilisé en programmation orientée objet. C'est l'un des modèles de création. Il s'agit de créer des instances. Les clients créeront l'objet sans être exposés à la logique de création de l'objet. Il est largement utilisé dans différents frameworks, par exemple le framework Spring. Nous utilisons ce modèle lorsque la classe ne connaît pas les objets d'une autre qu'elle doit créer. Exemple en temps réel : lorsque notre voiture tombe en panne sur la route. Nous devons informer le réparateur du type de véhicule que nous utilisons afin qu'il ait les outils nécessaires pour effectuer la réparation. Selon nos indications, le réparateur résoudra le problème et nous permettra de reprendre la route. Il existe quelques méthodes intégrées qui utilisent ces modèles, par exemple la méthode getInstance() de la classe JavaUtilcalendar. Avec l'aide de getInstance(), nous pouvons obtenir des objets chaque fois que nous exécutons cette méthode. Javautilcalendar : getInstance() est une méthode qui renvoie un objet. https://trendydevx.com/factory-design-pattern-in-java-with-realtime-example/