design-patterns - شرح - انماط التصميم في هندسة البرمجيات pdf




ما هو الفرق الأساسي بين مصنع وأنماط مصنع الملخص؟ (14)

ما هو الفرق الأساسي بين مصنع وأنماط مصنع الملخص؟


مصدر هذه المعلومات مأخوذة من: http://java.dzone.com/news/intro-design-patterns-abstract

مصنع مجردة مقابل طريقة المصنع

يتم تنفيذ طرق مصنع Abstract كطرق مصنع. يقوم كل من نمط المصنع المجرد ونمط أسلوب المصنع بفصل نظام العميل عن فئات التنفيذ الفعلية من خلال الأنواع التجريدية والمصانع. تقوم طريقة المصنع بإنشاء كائنات عبر الوراثة حيث يقوم مصنع Abstract بإنشاء عناصر من خلال التركيب.

يتكون نمط المصنع التجريدي من AbstractFactory ، ConcreteFactory ، AbstractProduct ، ConcreteProduct والعميل.

كيفية التنفيذ

يمكن تنفيذ نمط مصنع المجردة باستخدام نمط مصنع الأسلوب ، نمط النموذج أو نمط Singleton. يمكن تنفيذ الكائن ConcreteFactory باعتباره Singleton كما هو مطلوب واحد فقط مثيل كائن ConcreteFactory.

نمط مصنع الأسلوب هو نسخة مبسطة من نمط مصنع مجردة. نمط مصنع الأسلوب هو المسؤول عن إنشاء المنتجات التي تنتمي إلى عائلة واحدة ، بينما يتعامل نمط Abstract Factory مع العديد من عائلات المنتجات.

تستخدم طريقة المصنع واجهات وفئات مجردة لفصل العميل عن فئة المولد والمنتجات الناتجة. يحتوي مصنع Abstract على مولد عبارة عن حاوية للعديد من طرق المصانع ، إلى جانب واجهات تفصل بين العميل والمولد والمنتجات.

متى تستخدم نمط أسلوب المصنع

استخدم نمط Factory Factory عندما تكون هناك حاجة لفصل عميل من منتج معين يستخدمه. استخدم أسلوب Factory لتخلي عميل مسؤول عن إنشاء وتكوين حالات منتج.

متى تستخدم نمط مصنع الملخص

استخدم نمط Factory Abstract عندما يجب فصل العملاء عن فئات المنتجات. مفيدة بشكل خاص لتكوين البرنامج وتعديله. كما يمكن لنمط مصنع Abstract أن يفرض قيودًا حول الفئات التي يجب استخدامها مع الآخرين. قد يكون هناك الكثير من العمل لجعل مصانع الخرسانة الجديدة.

أمثلة:

مثال مصنع مجردة 1

هذه المواصفات للأقراص لإعداد أنواع مختلفة من المعكرونة في صانع المعكرونة هو مصنع Abstract ، وكل قرص محدد هو مصنع. جميع المصانع (أقراص صانع المعكرونة) ترث خصائصها من المصنع المجرد. يحتوي كل قرص فردي على معلومات حول كيفية إنشاء المعكرونة ، ولا يقوم صانع المعكرونة بذلك.

مثال مصنع الملخص 2:

يتوافق جهاز الختم مع مصنع Abstract ، حيث أنه عبارة عن واجهة لعمليات تقوم بإنشاء كائنات منتجات مجردة. تتوافق القوالب مع مصنع الخرسانة ، حيث أنها تنتج منتجًا ملموسًا. كل فئة جزء (هود ، باب ، وما إلى ذلك) يتوافق مع المنتج المجرد. أجزاء محددة (أي ، باب جانبي السائق لـ 99 كامري) يتوافق مع منتجات الخرسانة.

مثال طريقة المصنع:

تتوافق شركة الألعاب مع الخالق ، نظرًا لأنها قد تستخدم المصنع لإنشاء كائنات منتجات. يقابل تقسيم شركة الألعاب التي تصنع نوعًا معينًا من الألعاب (الحصان أو السيارة) ConcreteCreator.


نمط مصنع الملخص

  • توفير واجهة لإنشاء عائلات من الكائنات ذات الصلة أو التابعة دون تحديد فئات الخرسانة الخاصة بهم.

  • نمط مصنع مجردة مشابه جدا لنمط أسلوب المصنع. فرق واحد بين الاثنين أنه مع نمط "مصنع Abstract" ، يفوض فئة مسؤولية إنشاء كائن إلى كائن آخر عبر تكوين بينما يستخدم نمط "أسلوب المصنع" الوراثة ويعتمد على فئة فرعية لمعالجة إنشاء الكائن المطلوب.

  • في الواقع ، يستخدم الكائن المفوض بشكل متكرر أساليب المصنع لتنفيذ إنشاء مثيل!

نمط المصنع

  • أنماط المصنع هي أمثلة على الأنماط الإبداعية

  • أنماط إبداعية تجريد عملية إنشاء كائن الكائن. إنها تخفي كيف يتم إنشاء الكائنات وتساعد على جعل النظام العام مستقلاً عن كيفية إنشاء الكائنات وتكوينها.

  • تركز أنماط الفئات المبتكرة على استخدام الميراث لتقرير الكائن الذي يتم استنساخه Factory Method

  • تركز أنماط إبداعية كائن على تفويض instantiation إلى كائن آخر "مصنع Abstract"

المرجع: مصنع مقابل مصنع مجردة


بالتعريف يمكننا سحب الاختلافات بين اثنين:

المصنع: يتم استخدام واجهة لإنشاء كائن ، ولكن الفئة الفرعية تقرر أي فئة لتكوين. يتم إنشاء كائن عند الحاجة.

مصنع مجردة: نمط مصنع مجردة بمثابة مصنع فائقة الذي يخلق مصانع أخرى. في نمط Factory Abstract تكون الواجهة مسؤولة عن إنشاء مجموعة من الكائنات ذات الصلة أو الكائنات التابعة دون تحديد فئات الخرسانة الخاصة بها.

لذلك ، في التعاريف المذكورة أعلاه ، يمكننا التركيز على فرق معين. وهذا هو ، نمط المصنع هو المسؤول عن إنشاء الكائنات و Abstract Factory مسؤولة عن إنشاء مجموعة من الكائنات ذات الصلة ؛ من الواضح على حد سواء من خلال واجهة.

نمط المصنع:

public interface IFactory{
  void VehicleType(string n);
 }

 public class Scooter : IFactory{
  public void VehicleType(string n){
   Console.WriteLine("Vehicle type: " + n);
  }
 }

 public class Bike : IFactory{
  public void VehicleType(string n) {
  Console.WriteLine("Vehicle type: " + n);
  }
 }

 public interface IVehicleFactory{
  IFactory GetVehicleType(string Vehicle);
 }

 public class ConcreteVehicleFactory : IVehicleFactory{
 public IFactory GetVehicleType(string Vehicle){
   switch (Vehicle){
    case "Scooter":
     return new Scooter();
    case "Bike":
     return new Bike();
    default:
    return new Scooter();
  }
 }

 class Program{
  static void Main(string[] args){
   IVehicleFactory factory = new ConcreteVehicleFactory();
   IFactory scooter = factory.GetVehicleType("Scooter");
   scooter.VehicleType("Scooter");

   IFactory bike = factory.GetVehicleType("Bike");
   bike.VehicleType("Bike");

   Console.ReadKey();
 }
}

نمط مصنع مجردة:

interface IVehicleFactory{
 IBike GetBike();
 IScooter GetScooter();
}

class HondaFactory : IVehicleFactory{
     public IBike GetBike(){
            return new FZS();
     }
     public IScooter GetScooter(){
            return new FZscooter();
     }
 }
class HeroFactory: IVehicleFactory{
      public IBike GetBike(){
            return new Pulsur();
     }
      public IScooter GetScooter(){
            return new PulsurScooter();
     }
}

interface IBike
    {
        string Name();
    }
interface IScooter
    {
        string Name();
    }

class FZS:IBike{
   public string Name(){
     return "FZS";
   }
}
class Pulsur:IBike{
   public string Name(){
     return "Pulsur";
   }
}

class FZscooter:IScooter {
  public string Name(){
     return "FZscooter";
   }
}

class PulsurScooter:IScooter{
  public string Name(){
     return "PulsurScooter";
   }
}

enum MANUFACTURERS
{
    HONDA,
    HERO
}

class VehicleTypeCheck{
        IBike bike;
        IScooter scooter;
        IVehicleFactory factory;
        MANUFACTURERS manu;

        public VehicleTypeCheck(MANUFACTURERS m){
            manu = m;
        }

        public void CheckProducts()
        {
            switch (manu){
                case MANUFACTURERS.HONDA:
                    factory = new HondaFactory();
                    break;
                case MANUFACTURERS.HERO:
                    factory = new HeroFactory();
                    break;
            }

      Console.WriteLine("Bike: " + factory.GetBike().Name() + "\nScooter: " +      factory.GetScooter().Name());
        }
  }

class Program
    {
        static void Main(string[] args)
        {
            VehicleTypeCheck chk = new VehicleTypeCheck(MANUFACTURERS.HONDA);
            chk.CheckProducts();

            chk= new VehicleTypeCheck(MANUFACTURERS.HERO);
            chk.CheckProducts();

            Console.Read();
        }
    }

تحافظ كل من Factory Method and Abstract Factory على العملاء المنفصلين عن الأنماط الخرسانية. كلاهما يخلقان كائنات ، لكن طريقة Factory تستخدم الوراثة بينما تستخدم تركيبة Abstract Factory التجميعي.

يتم توارث Factory Method في الفئات الفرعية لإنشاء الكائنات الملموسة (المنتجات) في حين يوفر Abstract Factory واجهة لخلق عائلة من المنتجات ذات الصلة ، وتحدد فئة فرعية من هذه الواجهة كيفية إنشاء المنتجات ذات الصلة.

ثم يتم تمرير هذه الفئات الفرعية عند إنشاء مثيل إلى فئات المنتجات حيث يتم استخدامها كنوع مجرد. غالباً ما يتم تنفيذ المنتجات ذات الصلة في Abstract Factory باستخدام Factory Method .


طريقة المصنع هي طريقة غير ثابتة تقوم بارجاع فئة أساسية أو نوع واجهة والتي يتم تنفيذها في تسلسل هرمي لتمكين تكوين متعدد الأشكال. يجب تحديد / تنفيذ طريقة المصنع بواسطة فئة واحدة أو أكثر من الفئات الفرعية للفئة. الطبقة والطبقة الفرعية تعمل كل المصانع. ومع ذلك ، نحن لا نقول أن طريقة المصنع هي مصنع. مصنع Abstract هو واجهة لإنشاء أسر الكائنات ذات الصلة أو التابعة دون تحديد فئات الخرسانة الخاصة بهم.

تم تصميم المصانع المجردة لتكون قابلة للاستبدال في وقت التشغيل ، لذلك قد يتم تكوين نظام لاستخدام أداة محددة وملموسة لمصنع Abstract. كل مصنع مجردة هو مصنع ، وإن لم يكن كل مصنع هو مصنع مجردة. أحيانًا تتطور الطبقات التي هي مصانع ، وليس مصانع مجردة ، إلى مصانع مجردة عند الحاجة إلى دعم إنشاء عدة عائلات من الكائنات ذات الصلة أو التابعة.


كثير من الناس سوف يشعرون بالدهشة ربما ، لكن هذا السؤال غير صحيح . إذا كنت تسمع هذا السؤال خلال مقابلة ، فأنت بحاجة إلى مساعدة الشخص الذي يجري المقابلة في فهم أين هو الارتباك.

دعونا نبدأ من حقيقة أنه لا يوجد نمط ملموس يسمى "المصنع" فقط. هناك نمط يسمى "مصنع مجردة" ، وهناك نمط يسمى "طريقة المصنع".

إذن ماذا يعني "المصنع" بعد ذلك؟ واحد مما يلي (يمكن اعتبار كل شيء صحيحًا ، اعتمادًا على نطاق المرجع):

  • بعض الناس يستخدمونه كاسم مستعار (اختصار) لـ " مصنع مجردة ".
  • بعض الناس يستخدمونه كاسم مستعار (اختصار) لـ " Factory Method ".
  • بعض الناس يستخدمونه كاسم أكثر عمومية لجميع أنماط المصنع / الإبداع. على سبيل المثال "مصنع مجردة" و "طريقة المصنع" هي مصانع.

ولسوء الحظ ، يستخدم العديد من الأشخاص "المصنع" للدلالة على نوع آخر من المصانع ، التي تنشئ المصانع أو المصانع (أو واجهاتها). استنادا إلى نظريتهم:

يطبق المنتج IProduct ، الذي يتم إنشاؤه من قبل المصنع ، والذي ينفذ IFactory ، الذي تم إنشاؤه بواسطة AbstractFactory.

لفهم مدى سكون هذا ، دعنا نواصل معادلاتنا:

AbstractFactory تنفذ IAbstractFactory ، الذي تم إنشاؤه من قبل ... AbstractAppstractFactory ؟؟؟

أرجو أن ترى هذه النقطة. لا تربك ، ورجاء لا تخترع الأشياء التي لا وجود لها من أجل العقل.

-

ملاحظة : مصنع للمنتجات هو AbstractFactory ، ومصنع للمصانع Abstract ستكون مجرد مثال آخر من AbstractFactory كذلك.


مثال / سيناريو لمصنع الملخص

أنا أعيش في مكان تمطر فيه الأمطار في فصل الشتاء ، والثلوج في الشتاء وحارة ومشمسة في الصيف. أحتاج إلى نوع مختلف من الملابس لحماية نفسي من العناصر. للقيام بذلك ، أذهب إلى المتجر بالقرب من منزلي وأطلب الملابس / المواد لحماية نفسي. يعطيني حارس المتجر العنصر المناسب حسب البيئة وعمق جيبي. البنود التي يعطيني هي من نفس المستوى من الجودة والسعر. بما أنه مدرك لمعاييري يسهل عليه القيام بذلك. ولكن عندما يأتي رجل ثري من الجانب الآخر من الشارع بنفس المتطلبات ، يحصل على بند باهظ الثمن. شيء واحد ملحوظ هو أن كل العناصر التي يقدمها لي تكمل بعضها البعض في جودة الجودة والمعيار والتكلفة. يمكن للمرء أن يقول أنهم يذهبون مع بعضهم البعض. نفس الشيء مع العناصر التي يحصل عليها هذا الشخص الغني.

لذا من خلال النظر في السيناريو أعلاه ، فأنا أقدر الآن كفاءة حارس المتجر. يمكنني استبدال هذا الدكان بمحل محل. البنود التي نحصل عليها مع عناصر مجردة ولي والغني كعميل منظور. كل ما نحتاجه هو المنتج / البند الذي يناسب احتياجاتنا.

الآن يمكنني أن أرى نفسي أذكر بسهولة متجرًا عبر الإنترنت يوفر مجموعة من الخدمات لعملائها المتعددين. كل عميل ينتمي إلى واحدة من المجموعات الثلاث. عندما يفتح مستخدم مجموعة متميزة الموقع ، فإنه يحصل على واجهة مستخدم رائعة ، وجزء مخصص للتخصيص ، والمزيد من الخيارات في القوائم وما إلى ذلك. يتم عرض مجموعة الميزات نفسها على المستخدم الذهبي ، ولكن الوظائف في القائمة أقل ، وتكون الإعلانات في الغالب ذات صلة ، و UI أقل قليلا. الأخير هو نوع المستخدم الخاص بي ، مستخدم "مجموعة مجانية". أنا فقط خدمت بما فيه الكفاية حتى أنني لا تحصل بالإهانة. واجهة المستخدم هي الحد الأدنى ، والإعلانات بعيدة عن المسار لدرجة أنني لا أعرف ما يأتي في ذلك ، في نهاية المطاف القائمة لديها تسجيل الخروج فقط.

إذا حصلت على فرصة لبناء شيء مثل هذا الموقع ، فسوف أعتبر بالتأكيد نمط مصنع مجردة.

منتجات الملخص: جزء إعلان ، قائمة ، رسام واجهة المستخدم.
مصنع الملخص: تجربة المستخدم في متجر الويب
مصنع Concreate: تجربة مستخدم بريميوم ، تجربة مستخدم ذهبية ، تجربة مستخدم عامة.


مصادر بلدي هي: ، tutorialspoint.com ، programmers.stackexchange.com و CodeProject.com .

Factory Method (تسمى أيضًا Factory ) هي لعميل decouple من تطبيق Interface . لعينة لدينا واجهة Shape مع اثنين من التطبيقات Circle Square . لقد حددنا فئة مصنع بطريقة مصنع مع معلمة محدد مثل Type والتنفيذ الجديد ذو الصلة لواجهة Shape .

يحتوي Abstract Factory على العديد من طرق المصانع أو واجهة المصنع من خلال العديد من عمليات تنفيذ المصانع. للعينة التالية أعلاه ، لدينا واجهة Color مع تطبيقين Red Yellow . لدينا تعريف واجهة ShapeColorFactory مع اثنين من RedCircleFactory و YellowSquareFactory . بعد رمز لتوضيح هذا المفهوم:

interface ShapeColorFactory
{
    public Shape getShape();
    public Color getColor();
}

class RedCircleFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Circle();
    }

    @Override
    public Color getColor() {
        return new Red();
    }
}
class YellowSquareFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Square();
    }

    @Override
    public Color getColor() {
        return new Yellow();
    }
} 

هنا الفرق بين FactoryMethod و AbstractFactory . Factory Method ببساطة إرجاع فئة محددة من واجهة ولكن Abstract Factory إرجاع Abstract Factory factory of factory . بعبارة أخرى ، يعيد Abstract Factory مختلفة من سلسلة من الواجهات.

آمل أن يكون تفسيري مفيدًا.


مصنع الملخص هو واجهة لإنشاء الكائنات ذات الصلة ولكن طريقة المصنع هي طريقة. يتم تنفيذ مصنع مجردة من خلال طريقة المصنع.


مع نمط المصنع ، يمكنك إنتاج تطبيقات ( Apple ، Banana ، Cherry ، إلخ) من واجهة معينة - على سبيل المثال ، IFruit .

مع نمط مصنع Abstract ، يمكنك إنتاج تطبيقات واجهة مصنع معين - على سبيل المثال ، IFruitFactory . كل واحد من هؤلاء يعرف كيف يخلق أنواعًا مختلفة من الفاكهة.


الفرق الأساسي:

Factory: Creates الكائنات دون تعريض منطق إنشاء مثيل للعميل.

طريقة المصنع : تحديد واجهة لإنشاء كائن ، ولكن السماح للفئة الفرعية بتحديد الفئة التي تريد إنشاءها. يتيح الأسلوب Factory تأجيل التذييل للفئة إلى الفئات الفرعية

مصنع مجردة : يوفر واجهة لخلق عائلات من الكائنات ذات الصلة أو تعتمد دون تحديد فئات الخرسانة.

Abstract يستخدم نموذج FormFactory تكوينًا لتفويض مسئولية إنشاء كائن إلى فصل آخر بينما يستخدم نمط أسلوب المصنع الوراثة ويعتمد على فئة مشتقة أو فئة فرعية لإنشاء كائن

من مقالات oodesign :

الرسم البياني لفئة Factory :

مثال: StaticFactory

 public class ShapeFactory {

   //use getShape method to get object of type shape 
   public static Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }     
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();

      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();

      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }

      return null;
   }
}

غير تنفيذ مصنع غير ساكنة FactoryMethod مثال متاح في هذا المنصب:

أنماط التصميم: مصنع مقابل مصنع طريقة مقابل مصنع مجردة

وقت الاستخدام: يحتاج العميل فقط إلى فصل دراسي ولا يهتم بأي تنفيذ ملموس يتم الحصول عليه.

طريقة مصنع الطبقة digaram:

وقت الاستخدام: لا يعرف العميل ما هي الطبقات الملموسة التي سيُطلب منك إنشاؤها في وقت التشغيل ، ولكنه يريد فقط الحصول على فصل يؤدي المهمة.

رسم توضيحي لفن المعمل من dzone

متى يتم الاستخدام: عندما يضطر نظامك إلى إنشاء عدة عائلات من المنتجات أو إذا كنت تريد توفير مكتبة لمنتجات دون الكشف عن تفاصيل التنفيذ.

أمثلة التعليمات البرمجية المصدر في المقالات أعلاه جيدة جداً لفهم المفاهيم بشكل واضح.

أسئلة SE ذات الصلة مع التعليمات البرمجية المثال:

نمط المصنع. متى تستخدم طرق المصنع؟

اختلافات:

  1. يتم في الغالب تنفيذ فصول المصنع التجريبية باستخدام أساليب المصنع ، ولكن يمكن تنفيذها أيضًا باستخدام Prototype
  2. تبدأ التصاميم باستخدام طريقة المصنع (أقل تعقيدا ، وأكثر قابلية للتخصيص ، وتتكاثر الفئات الفرعية) وتتطور نحو الأنماط الإبداعية الأخرى (أكثر مرونة وأكثر تعقيدا) حيث هناك حاجة إلى مزيد من المرونة.
  3. عادة ما يتم استدعاء أساليب المصنع داخل أساليب القوالب.

مقالات مفيدة أخرى:

factory_method من المصدر

abstract_factory من sourcemaking

abstract-factory-design-pattern من journaldev


تمديد الإجابة John Feminella:

Apple ، Banana ، Cherry بتنفيذ FruitFactory ولديها طريقة تسمى Create والتي تكون مسؤولة فقط عن إنشاء Apple أو Banana أو Cherry. انتهيت ، مع طريقة Factory الخاص بك.

الآن ، أنت تريد Create سلطة خاصة من الفواكه الخاصة بك وهناك يأتي مصنع الملخص الخاص بك. يعرف المصنع التجريبي كيفية إنشاء سلطتك الخاصة من التفاح والموز والكرز.

public class Apple implements Fruit, FruitFactory {
    public Fruit Create() {
        // Apple creation logic goes here
    }
}

public class Banana implements Fruit, FruitFactory {
    public Fruit Create() {
        // Banana creation logic goes here
    }
}

public class Cherry implements Fruit, FruitFactory {
    public Fruit Create() {
        // Cherry creation logic goes here
    }
}

public class SpecialSalad implements Salad, SaladFactory {
    public static Salad Create(FruitFactory[] fruits) {
        // loop through the factory and create the fruits.
        // then you're ready to cut and slice your fruits 
        // to create your special salad.
    }
}

I think we can understand the difference between these two by seeing a Java8 example code:

  interface Something{}

  interface OneWhoCanProvideSomething {
     Something getSomething();
  }

  interface OneWhoCanProvideCreatorsOfSomething{
     OneWhoCanProvideSomething getCreator();
  }


public class AbstractFactoryExample {

    public static void main(String[] args) {
        //I need something
        //Let's create one
        Something something = new Something() {};

        //Or ask someone (FACTORY pattern)
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeA = () -> null;
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeB = () -> null;

        //Or ask someone who knows soemone who can create something (ABSTRACT FACTORY pattern)
        OneWhoCanProvideCreatorsOfSomething oneWhoCanProvideCreatorsOfSomething = () -> null;

        //Same thing, but you don't need to write you own interfaces
        Supplier<Something> supplierOfSomething = () -> null;
        Supplier<Supplier<Something>> supplierOfSupplier = () -> null;
    }

}

Now the question is which way of creation should you use and why: The first way (no pattern, just plain constructor): creating by yourself is not a good idea, you have to do all the work, and your client code is tied to the particular implementation.

The second way (using Factory pattern): provides you the benefit that you can pass any type of implementation, which can provide different type of something based on some condition (maybe a parameter passed to creational method).

The third way (using Abstract Factory pattern): This gives you more flexibility. You can find different types of creators of something based on some condition (maybe a parameter passed).

لاحظ أنه يمكنك دائمًا التخلص من نمط المصنع من خلال الجمع بين شرطين معًا (مما يزيد من تعقيد الشفرات بشكل طفيف ، والاقتران) ، أعتقد أن هذا هو السبب في أننا نادراً ما نرى حالات استخدام الحياة الحقيقية لنمط مصنع Abstract.


//Abstract factory - Provides interface to create factory of related products
interface PizzaIngredientsFactory{    
   public Dough createDough(); //Will return you family of Dough
   public Clam createClam();   //Will return you family of Clam
   public Sauce createSauce(); //Will return you family of Sauce
}

class NYPizzaIngredientsFactory implements PizzaIngredientsFactory{

   @Override
   public Dough createDough(){
      //create the concrete dough instance that NY uses
      return doughInstance;
   }

   //override other methods
} 

يتم بالفعل توفير تعريفات كتاب النص عن طريق إجابات أخرى. ظننت أنني سأقدم مثالاً على ذلك أيضًا.

إذاً ، فإن PizzaIngredientsFactory هنا عبارة عن مصنع تجريدي حيث يوفر طرقًا لإنشاء عائلة من المنتجات ذات الصلة.

لاحظ أن كل طريقة في مصنع الملخص هي طريقة مصنع في حد ذاتها. مثل createDough() هو في حد ذاته طريقة مصنع سيتم توفير تطبيقات ملموسة من خلال الفئات الفرعية مثل NYPizzaIngredientsFactory . لذا ، فإن استخدام كل موقع مختلف يمكن أن يخلق أمثلة لمكونات خرسانية تنتمي إلى موقعه.

طريقة المصنع

يوفر مثال التنفيذ الملموس

في المثال:
- createDough() - يوفر تنفيذ ملموس للعجين. إذن هذه طريقة مصنع

مصنع مجردة

يوفر واجهة لخلق عائلة من الكائنات ذات الصلة

في المثال:
- PizzaIngredientsFactory هو مصنع مجردة لأنها تتيح إنشاء مجموعة من الكائنات ذات الصلة مثل Dough ، Clams ، Sauce . لإنشاء كل عائلة من الكائنات ، فإنها توفر طريقة مصنع.

مثال من أنماط التصميم Head First







factory-method