تصف هذه المقالة نموذج المصنع لنمط تصميم جافا. شاركه للرجوع إليه ، على النحو التالي:
1. مصنع بسيط
دعونا نفكر في سؤال أولاً. عندما نكتب البرامج ، سيكون هناك مثل هذا الموقف. يحتاج الكائن A إلى استدعاء طريقة الكائن B. في هذا الوقت ، عادةً ما نستخدم الكلمة الرئيسية الجديدة لإنشاء مثيل B ثم استدعاء طريقة المثيل B. إن عيب هذا النهج هو أن طريقة الفئة A تستدعي مباشرة اسم فئة الفئة B (تسمى هذه الطريقة أيضًا اقترانًا متصلاً). بمجرد أن يحتاج النظام إلى إعادة بيعه: عندما تحتاج الفئة C إلى استخدامها بدلاً من الفئة B ، يتعين على البرنامج تعديل رمز الفئة A. إذا كانت 100 أو 10،000 فئة في التطبيق مرمّزًا بشاقًا ، فيجب تعديل 100 أو 10000 مكان ، وهو أمر فظيع للغاية.
بالنظر إلى هذه المشكلة من منظور آخر: بالنسبة لكائن ما بالفعل ، فإنه يحتاج فقط إلى استدعاء طريقة الكائن B ، ولا يهتم بعملية تنفيذ وإنشاء الكائن B للكائن B ، فكر في ترك الفئة B تنفيذ واجهة IB ، في حين أن الفئة A تحتاج فقط إلى ربط الفئة A بالفئة A ، وهو أمر لا يستخدم بشكل مباشر ، ويتوقع أن يكون هناك طريقة AB التي تتميز بالشكل الأول ، والتي تستخدمها ، وهي عبارة عن طراز A. استدعاء مصنع ibfactory للحصول على مثيلات IB. من خلال التصميم أعلاه: إذا كنت بحاجة إلى استخدام الفئة C بدلاً من الفئة B ، فأنت بحاجة فقط إلى السماح للفئة C بتنفيذ واجهة IB وإعادة كتابة رمز التنفيذ لإنشاء مثيل IB في مصنع Ibfactory ، بحيث يمكن للمصنع إنشاء مثيل C. تسمى طريقة التصميم هذه لتسليم كائنات فئة متعددة إلى فئات المصنع لتوليد نمط المصنع البسيط.
هنا هو رمز نمط المصنع البسيط:
/*** وضع المصنع البسيط* الواجهة الشائعة التي تتطلب مثيلات كائن المنتج المصنع* واجهة نمط الشعر* Author Administrator**/Hair Interface Hair {/*** ارسم Hairstyle*/public void draw () ؛}/*** Hairstribution Hairstribution* @Author Administrator**/public lefthair lefthair lefriements {void public () System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- * */public class Righthair ينفذ الشعر {Override public void draw () { System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Administrator */Public Class Hairtest {public static void (args []كما ترون ، إذا كنت ترغب في تغيير الجري الذي تم إنشاؤه في Hairtest إلى Righthair ، فأنت بحاجة فقط إلى تعديل تنفيذ طريقة Gethair في Hairfactory.
ميزة استخدام وضع المصنع البسيط هي أنه يفصل المتصل الكائن وعملية إنشاء الكائن. عندما يحتاج متصل الكائن إلى كائن ، يمكنه طلبه مباشرة من المصنع ، وبالتالي تجنب المتصل الكائن وفئة تنفيذ الكائنات التي يتم ربطها بطريقة شديدة الترميز لتحسين قابلية الصيانة للنظام وقابليتها للتطوير. بالطبع ، يحتوي نموذج المصنع أيضًا على عيب صغير. عند تعديل المنتج ، يجب أيضًا تعديل فئة المصنع وفقًا لذلك. هنا يمكنك استخدام نموذج السياسة لحله. ما يلي هو الرمز.
الواجهة العامة Hairbuilder { / *** اجعل تصفيفة الشعر* @Return* / Public Hair Gethair () ؛) }} الفئة العامة RighthairBuilder تنفذ Hairbuilder {Override Public Hair Gethair () {return new righthair () ؛ }} الفئة العامة HairFactory {Private Hairbuilder Hairbuilder ؛ Hairfactory (Hairbuilder Hairbuilder) {this.hairbuilder = hairbuilder ؛ } public void sethairbuilder (Hairbuilder Hairbuilder) {this.hairbuilder = hairbuilder ؛ } الشعر العام gethair () {return hairbuilder.gethair () ؛ }} class hairtest {public static void main (string [] args) {// hairbuilder builder = new lefthairbuilder () ؛ Builder Builder = جديد Righthairbuilder () ؛ مصنع HairFactory = مصنع جديد (منشئ) ؛ شعر الشعر = المصنع. gethair () ؛ Hair.draw () ؛ }}ميزة هذا النهج هي أنه لا توجد حاجة لتعديل فئة المصنع بعد الآن ، وتجريد منطق الإنشاء في المصنع وفقًا لاستراتيجيات مختلفة. ما هي الأشياء التي يحتاجها البرنامج لإنشاء؟ فقط تمرير المنشئ المقابل في مصنع الشبكة.
2. طريقة المصنع
في نموذج المصنع البسيط ، يستخدم النظام فئة المصنع لإنتاج جميع مثيلات المنتج ، ويقرر فئة المصنع فئة الحالات التي يجب إنتاجها ، أي أن فئة المصنع مسؤولة عن جميع الأحكام المنطقية ، وخلق الحالة وغيرها من الأعمال.
إذا كنت لا ترغب في إصدار أحكام منطقية في فئة المصنع ، يمكن للبرنامج توفير مصانع مختلفة لفئات المنتجات المختلفة ، وتنتج فئات المصنع المختلفة منتجات مختلفة ، دون إصدار أحكام منطقية معقدة في فئة المصنع. هذا يشبه إلى حد ما نموذج المصنع البسيط جنبًا إلى جنب مع نموذج الإستراتيجية أعلاه. الفرق هو أن الأول لديه مصنع واحد فقط ، في حين أن الأخير يتطلب مصانع متعددة. فيما يلي رمز نمط طريقة المصنع.
/*** نمط طريقة المصنع* الواجهة المشتركة المطلوبة لتنفيذها بواسطة مثيلات كائن أنتجتها مصنع* Author Administrator**/public interface person {public void drawperson () ؛ System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Author Administrator */Public Class Womensory Personfactory {Override Public GetPerson () person = factory.getPerson () ؛الميزة النموذجية من هذا النوع هي أنها تنتج منتجاتها المقابلة وفقًا لمصانع مختلفة في رمز العميل ، وليس هناك حاجة لوضع كل المنطق المعقد في فئة المصنع للحكم. هناك عيب واضح في هذا التنفيذ ، وهو أن العميل يقترن بفئة المصنع.
3. مصنع مجردة
باستخدام بنية التصميم أعلاه لطريقة المصنع ، يتم فصل رمز العميل بنجاح عن فئة التنفيذ للكائن المسمى ، لكنه يجلب اقترانًا آخر: يتم اقتران رمز العميل بفئات المصنع المختلفة. لحل مشكلة الاقتران هذه ، فكر في إضافة فئة المصنع لإنشاء مثيلات المصنع وفصل المصنع عن العميل لإنتاج المنتجات. وتسمى طريقة التصميم هذه نموذج المصنع التجريدي. فيما يلي رمز نمط المصنع التجريدي
/*** نمط المصنع التجريدي* مصنع إنتاج personfactory* Author Administrator**/public class personfactoryfactory {public static personfactory getPersonFactory (نوع السلسلة) {if (type.equalsignorecase ("man")) {إرجاع manfactory () ؛ } آخر {return new WomenFactory () ؛ }}}/** * فئة اختبار العميل * Author Administrator * */Public Class Persontest {public static void main (string [] args) {personfactory factory = personfactoryfactory.getPersonFactory ("man") ؛ شخص شخص = مصنع. getPerson () ؛ person.drawperson () ؛ }}لمزيد من المحتوى المتعلق بـ Java ، يمكن للقراء المهتمين بهذا الموقع عرض الموضوعات: "بنية بيانات Java وبرنامج تعليمي الخوارزمية" ، "ملخص Tips Java Operation DOM" ، "ملخص ملف Java ونصائح تشغيل الدليل" و "ملخص نصائح Java Cache Operation Tips"
آمل أن يكون هذا المقال مفيدًا لبرمجة Java للجميع.