Jak si pamatujete rozdíl mezi vzorem abstraktní továrny a vzorem tovární metody v návrhových vzorcích?


Odpověď 1:

Vzor návrhu továrny:

  • Spadá pod Creational Design Pattern.Factory pattern říká, že vytvoření objektu bude řešeno jinou třídou pomocí typu vstupu.

Výhody:

  • Umožňuje volné spojení.

Kdy použít Factory Design Pattern?

  • Vzorec továrního designu se používá, když máme nadtriedu s více podtřídami a na základě vstupů musíme vrátit jednu z podtříd. Příklad: Pokud restaurace podává jídla Veg, Non-Veg a italská jídla. Považujte VegFood, NonVegFood a ItalianFood za tři třídy, jejichž nadřazená třída je Food.If zákazník požádá „Veg“, pak Factory metoda vrátí třídu „VegFood“.

Příklad:

Krok 1: Vytvořte abstraktní třídu „Jídlo“, která má dvě proměnné nazvané „billPerPerson“ a „položky“.

 veřejné abstraktní třída Jídlo

{
    chráněný dvojitý účetPerPerson;
    chráněné sady položek;

    veřejné jídlo (double billPerPerson)

    {
        this.billPerPerson = billPerPerson;
        this.items = new HashSet <> ();
    }

    veřejný double getBill ()

    {
        návrat billPerPerson;

    }

    veřejné set getItems ()
    {
        vrátit věci;
    }
}

Krok 2: Vytvořte konkrétní třídy, které rozšiřují abstraktní třídu „Jídlo“

veřejná třída VegFood rozšiřuje Food
{
    veřejné VegFood ()

    {
        super (100);
        items.add („Idly“);
        items.add („Dosa“);
        items.add ("Vada");
    }
}

public class NonVegFood rozšiřuje Food
{
    veřejné NonVegFood ()
    {
        super (120);
        items.add ("Biriyani");
        items.add („Kuře 65“);
    }
}

Krok 3: Vytvořte FoodServer, což je třída Factory pro vytvoření objektu pro beton na základě informací:

veřejná třída FoodServer

{
    public static Food getFood (String foodType)

    {
        if (foodType.equals ("veg"))
        {
            vrátit nový VegFood ();
        }
        jinak pokud (foodType.equals ("non veg"))
        {
            vrátit nový NonVegFood ();
        }
        jiný
        {
            System.out.println („Nesloužíme“ + foodType);
            návrat null;
        }
    }
}

Krok 4: Hlavní třída „Zákazník“ k získání požadovaného jídla na základě typu potraviny.

zákazník veřejné třídy
{
    public static void main (String [] args)
    {
        Customer customer1Food = FoodServer.getFood ("veg");
        System.out.println („Customer1“);
        System.out.println ("Položky:" + customer1Food.getItems (). ToString ());
        System.out.println ("Bill:" + customer1Food.getBill ());
        Customer customer2Food = FoodServer.getFood ("non veg");
        System.out.println („Customer1“);
        System.out.println ("Položky:" + customer2Food.getItems (). ToString ());
        System.out.println ("Bill:" + customer2Food.getBill ());
    }
}

Abstraktní vzor návrhu továrny:

  • To spadá pod Creational Design Pattern.It poskytuje rozhraní pro vytváření rodin souvisejících nebo závislých objektů bez určení jejich konkrétní třídy.Abstrakt Factory vzory je super továrna, která vrátí nejlepší Factory na základě vstupu.To funguje jako továrna továren . Odebírá klientovi informace o tom, která továrna bude vrácena.

Příklad ze skutečného života:

  • Vezměme si velkou továrnu, která vyrábí mýdlo. Tato továrna nebude vyrábět všechny věci, které jsou pro mýdlo potřebné. Měla by mnoho továren, které by vyráběly „mýdlovou tyčinku“, „obal na mýdlo“ atd. Všechno by bylo sestaveno. hlavní továrnou.

Kdy použít abstraktní tovární návrhový vzor?

  • Klient by měl být nezávislý na tom, jak jsou objekty vytvářeny a pro který je vytvořen objekt třídy. To je užitečné, když je třeba objekt vytvořit z rodiny tříd.

POZNÁMKA: Může to být matoucí, proto si prosím podívejte na videa, která jsem vložil na konec této stránky.

Příklad:

Krok 1:

  • Vytvořte rozhraní s názvem "Kurz".
kurz veřejného rozhraní
{
    public String getCourseName ();
}

Krok 2:

  • Vytvořte konkrétní třídy, které implementují rozhraní kurzu.
veřejná třída ProgrammingCourse realizuje kurz
{
    @Override
    public String getCourseName ()
    {
       návrat "Java";
    }
}

veřejná třída NonProgrammingCourse realizuje kurz
{
    @Override
    public String getCourseName ()
    {
        návrat "DSP";
    }
}

Krok 3:

  • Vytvořte rozhraní s názvem "Zdroj".
veřejné rozhraní Zdroj
{
    public String getSourceName ();
}

Krok 4:

  • Vytvořte konkrétní třídy, které implementují rozhraní „Zdroj“.
veřejná třída Offline implementuje zdroj
{
    @Override
    public String getSourceName ()
    {
        návrat "Knihy";
    }
}

veřejná třída Online implementuje zdroj
{
    @Override
    public String getSourceName ()
    {
        návrat „YouTube“;
    }
}

Krok 5:

  • Vytvořte abstraktní třídu „SourceCourseFactory“.
veřejná abstraktní třída SourceCourseFactory
{
    public abstract Source getSource (String sourceType);
    
    public abstract Course getCourse (String CourseType);
}

Krok 6:

  • Vytvořte Factory Class "CourseFactory", který rozšiřuje "SourceCourseFactory"
public class CourseFactory rozšiřuje SourceCourseFactory
{
    @Override
    public Source getSource (String sourceType)
    {
        návrat null;
    }

    @Override
    public Course getCourse (String CourseType)
    {
        if (courseType.equalsIgnoreCase ("programování"))
        {
            vrátit nový ProgrammingCourse ();
        }
        jinak pokud (courseType.equalsIgnoreCase ("non programming"))
        {
            vrátit nový NonProgrammingCourse ();
        }
        jiný
        {
            návrat null;
        }
    }
}

Krok 7:

  • Vytvořit Factory Class "SourceFactory", který rozšiřuje "SourceCourseFactory"
public class SourceFactory rozšiřuje SourceCourseFactory
{

    @Override
    public Source getSource (String sourceType)
    {
        if (sourceType.equalsIgnoreCase („online“))
        {
            vrátit nový Online ();
        }
        jinak if (sourceType.equalsIgnoreCase ("offline"))
        {
            vrátit nový Offline ();
        }
        jiný
        {
            návrat null;
        }
    }

    @Override
    public Course getCourse (String CourseType)
    {
       návrat null;
    }
    
}

Krok 8:

  • Vytvořte hlavní třídu, která volá abstraktní třídu Factory, abyste získali skutečný objekt třídy Factory, a poté tento objekt použije pro provádění dalších dalších operací.
 veřejná třída ExampleMain
{
    public static void main (String [] args)
    {
        SourceCourseFactory course = FactoryCreator.getSourceCourseFactory ("kurz");

        System.out.println (kurz.getCourse ("programování"). GetCourseName ());

        SourceCourseFactory source = FactoryCreator.getSourceCourseFactory ("source");
        System.out.println (source.getSource ("online"). GetSourceName ());

    }
}