Hvordan kan du huske forskellen mellem Abstract Factory-mønster og Factory Method-mønster i designmønstre?


Svar 1:

Fabriksdesignmønster:

  • Det falder ind under Creational Design Pattern.Factory mønster siger, at objektskabelse håndteres af en anden klasse ved hjælp af inputtypen.

Fordele:

  • Det tillader løs kobling.

Hvornår skal man bruge Factory Design Pattern?

  • Fabriksdesignmønster bruges, når vi har en superklasse med flere underklasser, og baseret på input, skal vi returnere en af ​​underklasserne. Eksempel: Hvis en restaurant serverer Veg-mad, ikke-Veg-mad og italiensk mad. Behandl VegFood, NonVegFood og ItalianFood som tre klasser, hvis superklasse er Food.If en kunde spørger "Veg", ville Factory-metoden returnere "VegFood" -klassen.

Eksempel:

Trin 1: Opret en abstrakt klasse "Mad", der har to variabler kaldet "billPerPerson" og "items".

 offentlig abstrakt klasse Mad

{
    beskyttet dobbelt regningPerPerson;
    beskyttede sæt genstande;

    offentlig mad (dobbeltregningPerPerson)

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

    offentlig dobbelt getBill ()

    {
        return billPerPerson;

    }

    public Set getItems ()
    {
        returvarer;
    }
}

Trin 2: Opret konkrete klasser, der udvider den abstrakte klasse "Mad"

offentlig klasse VegFood udvider mad
{
    offentlig VegFood ()

    {
        super (100);
        items.add ( "passivt");
        items.add ( "Dosa");
        items.add ( "Vada");
    }
}

offentlig klasse NonVegFood udvider mad
{
    offentlig NonVegFood ()
    {
        super (120);
        items.add ( "Biriyani");
        items.add ("Kylling 65");
    }
}

Trin 3: Opret en FoodServer, som er en fabriksklasse for at oprette et objekt til beton baseret på informationen:

offentlig klasse FoodServer

{
    offentlig statisk mad GetFood (strengfødetype)

    {
        if (foodType.equals ("veg"))
        {
            returner nyt VegFood ();
        }
        andet hvis (foodType.equals ("ikke veg"))
        {
            returnere nye NonVegFood ();
        }
        andet
        {
            System.out.println ("Vi serverer ikke" + foodType);
            returnere null;
        }
    }
}

Trin 4: Hovedklasse "kunde" for at få den krævede mad baseret på madtypen.

kunde i den offentlige klasse
{
    public static void main (String [] args)
    {
        Food customer1Food = FoodServer.getFood ("veg");
        Println ( "Customer1");
        System.out.println ("Items:" + customer1Food.getItems (). ToString ());
        System.out.println ("Bill:" + customer1Food.getBill ());
        Food customer2Food = FoodServer.getFood ("ikke veg");
        Println ( "Customer1");
        System.out.println ("Elementer:" + customer2Food.getItems (). ToString ());
        System.out.println ("Bill:" + customer2Food.getBill ());
    }
}

Abstrakt fabriksdesignmønster:

  • Det falder ind under Kreativt designmønster. Det giver en grænseflade til oprettelse af familier af relaterede eller afhængige objekter uden at specificere deres konkrete klasser. Abstrakt Fabriksmønstre er en superfabrik, der returnerer den bedste fabrik baseret på input.Den fungerer som en fabrik af fabrikker .Det abstraherer klienten fra at vide, hvilken fabrik der skulle returneres.

Eksempel på det virkelige liv:

  • Overvej en stor fabrik, der fremstiller sæbe. Den fabrik vil ikke fremstille alle de ting, der kræves til sæbe. Det ville have mange underfabrikker, der fremstiller "sæbebar", "sæbeindpakning", osv. Alt ville samles af hovedfabrikken.

Hvornår skal jeg bruge abstrakt fabriksmønster?

  • Klienten skal være uafhængig af, hvordan objekter oprettes, og til hvilken klasseobjekt oprettes. Dette er nyttigt, når der skal oprettes et objekt fra en klasse af klasser.

BEMÆRK: Det kan være forvirrende, så vær opmærksom på de videoer, jeg har indlejret i slutningen af ​​denne side.

Eksempel:

Trin 1:

  • Opret en grænseflade kaldet "Kursus".
offentlig interface Kursus
{
    public String getCourseName ();
}

Trin 2:

  • Opret konkrete klasser, der implementerer "Kursus" -grænsefladen.
offentlig klasse programmeringCourse implementerer kursus
{
    @Override
    public String getCourseName ()
    {
       returnere "Java";
    }
}

offentlig klasse NonProgrammingCourse implementerer Kursus
{
    @Override
    public String getCourseName ()
    {
        returner "DSP";
    }
}

Trin 3:

  • Opret en grænseflade kaldet "Kilde".
offentlig interface kilde
{
    public String getSourceName ();
}

Step4:

  • Opret konkrete klasser, der implementerer "Kilde" -grænsefladen.
offentlig klasse Offline implementerer Kilde
{
    @Override
    public String getSourceName ()
    {
        returnere "Bøger";
    }
}

offentlig klasse Online implementerer Kilde
{
    @Override
    public String getSourceName ()
    {
        returner "YouTube";
    }
}

Trin 5:

  • Opret en abstrakt klasse "SourceCourseFactory".
offentlig abstrakt klasse SourceCourseFactory
{
    offentlig abstrakt kilde getSource (String sourceType);
    
    offentlig abstrakt Kurs getCourse (String courseType);
}

Trin 6:

  • Opret en fabriksklasse "CourseFactory", der udvider "SourceCourseFactory"
public class CourseFactory udvider SourceCourseFactory
{
    @Override
    public source getSource (String sourceType)
    {
        returnere null;
    }

    @Override
    public Course getCourse (String courseType)
    {
        hvis (courseType.equalsIgnoreCase ( "programmering"))
        {
            returnere nyt ProgrammingCourse ();
        }
        andet hvis (courseType.equalsIgnoreCase ("ikke programmering"))
        {
            returnere nye NonProgrammingCourse ();
        }
        andet
        {
            returnere null;
        }
    }
}

Trin 7:

  • Opret en fabriksklasse "SourceFactory", der udvider "SourceCourseFactory"
public class SourceFactory udvider SourceCourseFactory
{

    @Override
    public source getSource (String sourceType)
    {
        hvis (sourceType.equalsIgnoreCase ( "online"))
        {
            returnere nye Online ();
        }
        andet hvis (sourceType.equalsIgnoreCase ("offline"))
        {
            returner ny Offline ();
        }
        andet
        {
            returnere null;
        }
    }

    @Override
    public Course getCourse (String courseType)
    {
       returnere null;
    }
    
}

Trin 8:

  • Opret en hovedklasse, der kalder Abstract Factory-klasse for at få det rigtige Factory-klasseobjekt, og derefter bruger det objektet til at udføre andre andre operationer.
 offentlig klasse EksempelMain
{
    public static void main (String [] args)
    {
        SourceCourseFactory kursus = FactoryCreator.getSourceCourseFactory ("kursus");

        System.out.println (course.getCourse ( "programmering") getCourseName ().);

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

    }
}