Was sind die Unterschiede zwischen den Entwurfsmustern Abstract Factory und Factory?

Question

Ich weiß, dass es viele Beiträge über die Unterschiede zwischen diesen beiden Mustern gibt, aber es gibt ein paar Dinge, die ich nicht finden kann.

Aus dem, was ich gelesen habe, sehe ich, dass die Fabrik-Methode Muster ermöglicht es Ihnen zu definieren, wie ein einzelnes konkretes Produkt zu schaffen, sondern versteckt die Umsetzung aus dem Client, wie sie ein generisches Produkt sehen wird. Meine erste Frage bezieht sich auf die abstrakte Fabrik. Erlaubt sie die Erstellung von Familien konkreter Objekte (die von der verwendeten Fabrik abhängen können) und nicht nur eines einzelnen konkreten Objekts? Gibt die abstrakte Fabrik nur ein sehr großes Objekt zurück oder viele Objekte, je nachdem, welche Methoden Sie aufrufen?

Meine letzten beiden Fragen beziehen sich auf ein einziges Zitat, das ich nicht ganz verstehe und das ich an zahlreichen Stellen gesehen habe:

Ein Unterschied zwischen den beiden ist, dass mit dem abstrakten Fabrikmuster, eine Klasse die Verantwortung für die Objektinstanziierung an ein anderes Objekt durch Komposition delegiert, während das Factory Methoden-Muster Vererbung verwendet und eine Unterklasse für die gewünschte gewünschten Objektinstanziierung.

Ich verstehe, dass das Factory-Methodenmuster eine Creator-Schnittstelle hat, die den ConcreteCreator wissen lässt, welches ConcreteProduct er instanziieren soll. Ist es das, was mit der Verwendung von Vererbung zur Handhabung der Objektinstanziierung gemeint ist?

Wie genau delegiert das Muster der abstrakten Fabrik die Verantwortung für die Instanziierung eines Objekts über die Komposition an ein anderes Objekt, um sich auf dieses Zitat zu beziehen? Was ist damit gemeint? In meinen Augen sieht es so aus, als ob das Abstract Factory-Muster auch die Vererbung nutzt, um den Konstruktionsprozess durchzuführen, aber auch hier bin ich noch dabei, etwas über diese Muster zu lernen.

Für jede Hilfe, insbesondere bei der letzten Frage, wäre ich sehr dankbar.

Answer 1

Viele der bisherigen Antworten enthalten keine Codevergleiche zwischen Abstract Factory und Factory Method Pattern. Das Folgende ist mein Versuch, es anhand von Java zu erklären. Ich hoffe, es hilft jemandem, der eine einfache Erklärung braucht.

Als GoF sagt treffend: Abstract Factory bietet eine Schnittstelle zur Erstellung von Familien verwandter oder abhängiger Objekte, ohne deren konkrete Klassen zu spezifizieren ihrer konkreten Klassen.

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 2

Meine Schlussfolgerung: es gibt keinen Unterschied . Warum? Weil ich keine Rechtfertigung dafür sehen kann, andere Objekte als Fabriken mit Fabrikmethoden auszustatten - andernfalls kommt es zu einer Verletzung des Grundsatzes der Trennung der Verantwortung. Außerdem sehe ich keinen Unterschied zwischen einer Fabrik mit einer einzigen Fabrikmethode und einer Fabrik mit mehreren Fabrikmethoden: Beide erzeugen "Familien verwandter Objekte", es sei denn, jemand kann beweisen, dass eine Familie mit nur einem Mitglied keine Familie ist. Oder eine Sammlung, die ein einziges Objekt enthält, ist keine Sammlung.