איך אתה זוכר את ההבדל בין דפוס מופשט של מפעל לדפוס שיטת מפעל בדפוסי עיצוב?


תשובה 1:

דפוס עיצוב מפעל:

  • זה נופל תחת תבנית עיצוב יצירתי. תבנית מפעל אומרת שיצירת אובייקטים תטופל על ידי כיתה אחרת באמצעות סוג הקלט.

יתרונות:

  • זה מאפשר צימוד רופף.

מתי להשתמש בתבנית עיצוב מפעל?

  • דפוס עיצוב מפעל משמש כשיש לנו סופר-על עם מספר תת-כיתות ובהתבסס על הקלט, עלינו להחזיר אחת מתת-המחלקה. דוגמה: אם מסעדה מגישה אוכל טבעוני, אוכל שאינו טבעוני ואוכל איטלקי. התייחסו ל- VegFood, NonVegFood ו- ItalianFood כאל שלוש כיתות שהמעמד העל שלהן הוא מזון. אם לקוח ישאל "Veg", אז שיטת Factory הייתה מחזירה את הכיתה "VegFood".

דוגמא:

שלב 1: צור כיתה מופשטת "אוכל" שיש בה שני משתנים הנקראים "billPerPerson" ו- "פריטים".

 אוכל מופשט ציבורי

{
    BillPerPerson כפול מוגן;
    פריטי סט מוגנים;

    אוכל ציבורי (חשבונית כפולה פרספרסון)

    {
        this.billPerPerson = billPerPerson;
        this.items = HashSet חדש <> ();
    }

    getBill כפול ציבורי ()

    {
        החזר billPerPerson;

    }

    getItems ציבורי הגדר ()
    {
        פריטי החזרה;
    }
}

שלב 2: צור שיעורים קונקרטיים המרחיבים את הכיתה המופשטת "אוכל"

VegFood בכיתה ציבורית מאריך אוכל
{
    VegFood ציבורי ()

    {
        סופר (100);
        items.add ("בטלה");
        items.add ("דוסה");
        items.add ("ואדה");
    }
}

NonVegFood בכיתה ציבורית מרחיבה אוכל
{
    NonVegFood ציבורית ()
    {
        סופר (120);
        items.add ("Biriyani");
        items.add ("עוף 65");
    }
}

שלב 3: צור FoodServer שהוא כיתת מפעל ליצירת אובייקט לבטון בהתבסס על המידע:

אוכל ציבורי בכיתה

{
    אוכל אוכל סטטי ציבורי getFood (מחרוזת מזון סוג)

    {
        אם (foodType.equals ("טבע"))
        {
            להחזיר VegFood חדש ();
        }
        אחר אם (foodType.equals ("לא טבעוני"))
        {
            להחזיר NonVegFood חדש ();
        }
        אחר
        {
            System.out.println ("אנחנו לא מגישים" + foodType);
            להחזיר null;
        }
    }
}

שלב 4: המחלקה העיקרית "לקוח" להשיג את המזון הנדרש על בסיס סוג המזון.

לקוח בכיתה ציבורית
{
    main static void public (מחרוזת [] טענות)
    {
        Food customer1Food = FoodServer.getFood ("טבע");
        System.out.println ("לקוח 1");
        System.out.println ("פריטים:" + customer1Food.getItems (). ToString ());
        System.out.println ("Bill:" + customer1Food.getBill ());
        Food customer2Food = FoodServer.getFood ("לא טבעוני");
        System.out.println ("לקוח 1");
        System.out.println ("פריטים:" + customer2Food.getItems (). ToString ());
        System.out.println ("Bill:" + customer2Food.getBill ());
    }
}

דפוס עיצוב מפעל מופשט:

  • זה נופל תחת תבנית עיצוב יצירתי. הוא מספק ממשק ליצירת משפחות של חפצים קשורים או תלויים מבלי לציין את מחלקות הבטון שלהם. מופשטים דפוסים של מפעל הוא מפעל סופר שיחזיר את המפעל הטוב ביותר על סמך הקלט. זה משמש כמפעל של מפעלים זה מופשט מהלקוח לדעת מאיזה מפעל יוחזר.

דוגמא לחיים האמיתיים:

  • קחו למשל מפעל גדול שמייצר סבון. המפעל הזה לא ייצור את כל הדברים הנדרשים לסבון. היו לו הרבה מפעלי משנה שייצרו "בר סבון", "עטיפת סבון", וכו '. הכל היה מורכב על ידי המפעל הראשי.

מתי להשתמש בתבנית עיצוב מפעל מופשט?

  • הלקוח צריך להיות בלתי תלוי באופן בו נוצרים אובייקטים ואילו נוצר אובייקט כיתה. הדבר מועיל כאשר צריך ליצור אובייקט ממשפחת שיעורים.

הערה: זה עשוי להיות מבלבל אז אנא צפו בסרטונים שהטמתי בסוף דף זה.

דוגמא:

שלב 1:

  • צור ממשק בשם "קורס".
קורס ממשק ציבורי
{
    מחרוזת ציבורית getCourseName ();
}

שלב 2:

  • צור שיעורים קונקרטיים המיישמים ממשק "קורס".
תכנות בשיעור ציבורי קורס משלים את הקורס
{
    @ Override
    מחרוזת ציבורית getCourseName ()
    {
       להחזיר את "ג'אווה";
    }
}

קורס שאינו מתכנת לשיעור ציבורי מיישם את הקורס
{
    @ Override
    מחרוזת ציבורית getCourseName ()
    {
        להחזיר "DSP";
    }
}

שלב 3:

  • צור ממשק בשם "מקור".
מקור ממשק ציבורי
{
    מחרוזת ציבורית getSourceName ();
}

שלב 4:

  • צור מחלקות קונקרטיות המיישמות ממשק "מקור".
מחלקה ציבורית לא מקוונת מיישמת את המקור
{
    @ Override
    מחרוזת ציבורית getSourceName ()
    {
        להחזיר את "ספרים";
    }
}

המחלקה הציבורית מיישמת מקור
{
    @ Override
    מחרוזת ציבורית getSourceName ()
    {
        להחזיר את "YouTube";
    }
}

שלב 5:

  • צור שיעור מופשט "SourceCourseFactory".
שיעור מופשט ציבורי SourceCourseFactory
{
    מקור מופשט ציבורי getSource (מחרוזת sourceType);
    
    מופשט ציבורי קורס getCourse (מחרוזת כמובן סוג);
}

שלב 6:

  • צור כיתת מפעל "CourseFactory" המרחיבה את "SourceCourseFactory"
קורס ציבורי בשיעור ציבורי מרחיב את SourceCourseFactory
{
    @ Override
    מקור ציבורי getSource (מחרוזת sourceType)
    {
        להחזיר null;
    }

    @ Override
    קורס קורס ציבורי getCourse (קורס מיתרים)
    {
        if (courseType.equalsIgnoreCase ("תכנות"))
        {
            להחזיר את ProgrammingCourse ();
        }
        אחרת אם (courseType.equalsIgnoreCase ("לא תכנות"))
        {
            להחזיר את NonProgrammingCourse ();
        }
        אחר
        {
            להחזיר null;
        }
    }
}

שלב 7:

  • צור מחלקת מפעל "SourceFactory" המרחיבה את "SourceCourseFactory"
המחלקה הציבורית SourceFactory מרחיבה את SourceCourseFactory
{

    @ Override
    מקור ציבורי getSource (מחרוזת sourceType)
    {
        if (sourceType.equalsIgnoreCase ("מקוון"))
        {
            להחזיר חדש באינטרנט ();
        }
        אחרת אם (sourceType.equalsIgnoreCase ("לא מקוון"))
        {
            להחזיר לא מקוון חדש ();
        }
        אחר
        {
            להחזיר null;
        }
    }

    @ Override
    קורס קורס ציבורי getCourse (קורס מיתרים)
    {
       להחזיר null;
    }
    
}

שלב 8:

  • צור מחלקה ראשית שקוראת למחלקה של מפעל תקציר כדי להשיג את האובייקט הכיתתי של Factory ואז היא משתמשת באובייקט זה לביצוע פעולות אחרות.
 דוגמה ציבורית
{
    main static void public (מחרוזת [] טענות)
    {
        קורס SourceCourseFactory = FactoryCreator.getSourceCourseFactory ("קורס");

        System.out.println (course.getCourse ("תכנות"). GetCourseName ());

        SourceCourseFactory source = FactoryCreator.getSourceCourseFactory ("מקור");
        System.out.println (source.getSource ("מקוון"). GetSourceName ());

    }
}