নকশার প্যাটার্নস: বিমূর্ত কারখানা বনাম কারখানা পদ্ধতি

Question

দ্রষ্টব্য: প্রশ্নগুলি পোস্টের শেষে রয়েছে।

আমি অ্যাবস্ট্রাক্ট ফ্যাক্টরী বনাম কারখানার পদ্ধতি সম্পর্কিত অন্যান্য স্ট্যাকওভারফ্লো থ্রেড পড়েছি । আমি প্রতিটি প্যাটার্নের উদ্দেশ্য বুঝতে পারি। তবে আমি সংজ্ঞা নিয়ে পরিষ্কার নই।

কারখানা পদ্ধতি কোনও অবজেক্ট তৈরির জন্য একটি ইন্টারফেস সংজ্ঞায়িত করে, তবে সাবক্লাসগুলি সিদ্ধান্ত নিতে দেয় যে কোনটি ইনস্ট্যান্ট করতে হবে ate একটি কারখানার পদ্ধতি ক্লাসগুলিকে উপক্লাসে ইনস্ট্যান্টেশনকে পিছিয়ে দেয়।

বিপরীতে, একটি বিমূর্ত কারখানা তাদের কংক্রিটের ক্লাসগুলি নির্দিষ্ট না করে সম্পর্কিত বা নির্ভরশীল বস্তুর পরিবার তৈরি করার জন্য একটি ইন্টারফেস সরবরাহ করে।

- জন ফেমেনেলা

সারাংশ কারখানার খুব অনুরূপ কারখানার পদ্ধতি । আমি আমার বক্তব্য চিত্রিত করার জন্য কয়েকটি ইউএমএল ক্লাস আঁটিয়েছি।

বিঃদ্রঃ:

• ডায়াগ্রামটি www.yuml.com থেকে এসেছে যাতে তারা পুরোপুরি ভিত্তিক নয়। তবে এটি একটি নিখরচায় পরিষেবা :)।
• চিত্রগুলি নিখুঁত হতে পারে না। আমি এখনও জিওএফ ডিজাইনের ধরণগুলি শিখছি ।

কারখানার পদ্ধতি:

বিমূর্ত কারখানা (কেবলমাত্র 1 জন সদস্য):

বিমূর্ত কারখানা (আরও সদস্য):

প্রশ্নাবলী:

1. যদি অ্যাবস্ট্রাক্ট ফ্যাক্টরিতে কেবলমাত্র একজন স্রষ্টা এবং একটি পণ্য থাকে তবে এটি কি এখনও বিমূর্ত কারখানার ধরণ? (দুর্ভিক্ষ তৈরির জন্য একটি ইন্টারফেস)
2. পারি কারখানার পদ্ধতি জমাটবদ্ধ স্রষ্টা একটি ইন্টারফেস থেকে তৈরি করা বা এটি একটি বর্গ থেকে হতে আছে? (ক্লাসগুলি সাবক্লাসে ইনস্ট্যান্টেশনগুলি পিছিয়ে দেয়)
3. যদি অ্যাবস্ট্রাক্ট ফ্যাক্টরিতে কেবল একটি স্রষ্টা এবং একটি পণ্য থাকতে পারে তবে অ্যাবস্ট্রাক্ট ফ্যাক্টরি এবং কারখানার পদ্ধতির মধ্যে কেবলমাত্র পার্থক্য যে প্রাক্তনটির জন্য স্রষ্টা একটি ইন্টারফেস এবং পরবর্তীটির স্রষ্টা একটি শ্রেণি?

Comments

দ্রষ্টব্য: আমি যখন ইন্টারফেসটি উল্লেখ করি তখন আমি একটি জাভা ইন্টারফেসের শর্তাবলী (বিমূর্ত ভার্চুয়াল পদ্ধতি সহ বিমূর্ত শ্রেণি) সম্পর্কে আরও ভাবছিলাম। বিমূর্ত কারখানা এবং বিভিন্ন ভাষায় কারখানার পদ্ধতির মধ্যে কোনও পার্থক্য উপস্থিত থাকলে নির্দ্বিধায় নির্দ্বিধায়।

এখানে একটি প্রাথমিক পার্থক্য:

— স্ট্যাকওভারফ্লো /

Answer 1

আশাকরি এটা সাহায্য করবে. এটি বিভিন্ন ধরণের কারখানার বর্ণনা দেয়। আমি আমার রেফারেন্স হিসাবে হেড ফার্স্ট ডিজাইনের প্যাটার্ন ব্যবহার করেছি। আমি ডায়াগ্রামে yuml.me ব্যবহার করেছি ।

স্ট্যাটিক কারখানা

স্ট্যাটিক পদ্ধতি সহ এমন একটি শ্রেণি যা বিভিন্ন উপজাতের পণ্য উত্পাদন করে।

সরল কারখানা

এমন একটি শ্রেণী যা বিভিন্ন ধরণের পণ্য উত্পাদন করতে পারে। (এটি স্ট্যাটিক কারখানার চেয়ে ভাল new

কারখানার পদ্ধতি

এর ধরণের সাথে সম্পর্কিত এক ধরণের পণ্য উত্পাদন করতে একটি পদ্ধতি রয়েছে। (এটি একটি সরল কারখানার চেয়ে ভাল কারণ ধরণটি উপ-শ্রেণীর কাছে মুলতুবি করা হয়েছে))

বিমূর্ত কারখানা

সম্পর্কিত একটি পরিবার উত্পাদন করে। এটি কারখানার পদ্ধতির চেয়ে লক্ষণীয়ভাবে পৃথক কারণ এটির একাধিক পদ্ধতি এটি উত্পাদন করে। (আরও জটিল বাস্তব জীবনের উদাহরণের জন্য এটি পরবর্তী চিত্রটি উল্লেখ করা জটিল)।

.NET ফ্রেমওয়ার্ক থেকে উদাহরণ

ডিবিএফ্যাক্টরিজপ্রভাইডার একটি সরল কারখানা কারণ এটির উপ-প্রকার নেই। ডিবিফ্যাক্টরিপ্রোভাডার একটি বিমূর্ত কারখানা কারণ এটি সম্পর্কিত বিভিন্ন ডাটাবেস অবজেক্ট যেমন সংযোগ এবং কমান্ড অবজেক্ট তৈরি করতে পারে।

Comments

স্ট্যাটিক ফ্যাক্টরি এবং সিম্পল ফ্যাক্টরির মধ্যে পার্থক্য কি খাঁটিভাবে যে ক্রিয়েটপ্রোডাক্ট পদ্ধতিটি আলাদা শ্রেণীর মধ্যে বসে?

— পিটার ও'ক্যালাহান

এটি কী পরিষ্কার হবে না যদি ফ্যাক্টরি পদ্ধতির ক্ষেত্রে কেবল Product(বিমূর্ত হিসাবে) এবং তারপরে Product1এবং Product2পুত্র হিসাবে থাকতেন? এটি বিন্দুতে সহায়তা করবে যে ফ্যাক্টরি পদ্ধতিটি কেবল একটি পণ্য তৈরি সম্পর্কে, যেখানে অ্যাবস্ট্রাক্ট ফ্যাক্টরি কম-বেশি পরিবারে একত্রিত হয়ে ফ্যাক্টরি পদ্ধতির একগুচ্ছ হয়।

— lllllll

Answer 2

দুটি নিদর্শন অবশ্যই সম্পর্কিত!

নিদর্শন মধ্যে পার্থক্য সাধারণত অভিপ্রায়।

অভিপ্রায় এর কারখানার পদ্ধতি "একটি বস্তু তৈরি করার জন্য একটি ইন্টারফেস নির্ধারণ, কিন্তু উপশ্রেণী সিদ্ধান্ত নিতে instantiate করার বর্গ। কারখানার পদ্ধতি উপশ্রেণী করার জন্য একটি শ্রেণী মুলতবি ইনস্ট্যান্স দেয় যাক।" হয়

অভিপ্রায় এর সারাংশ কারখানার "এর পাশে তাদের কংক্রিট শ্রেণীর উল্লেখ না করে সংশ্লিষ্ট বা নির্ভরশীল বস্তুর পরিবার তৈরি করার জন্য একটি ইন্টারফেস প্রদান করুন।" হয়

বিশুদ্ধভাবে এই উদ্দেশ্যমূলক বিবৃতিগুলির উপর ভিত্তি করে (জিওএফ থেকে উদ্ধৃত) আমি বলব যে ফ্যাক্টরি পদ্ধতিটি এক অর্থে একটি পরিবারের সাথে একটি "অবক্ষয়" বিমূর্ত ফ্যাক্টরি ।

অ্যাবস্ট্রাক্ট ফ্যাক্টরির চেয়ে কারখানার পদ্ধতিটি একটি সহজ চুক্তি হিসাবে সাধারণত এগুলি প্রয়োগের ক্ষেত্রে ভিন্ন হয় ।

এগুলি বাস্তবায়নের ক্ষেত্রেও সম্পর্কিত। জিওএফ বইয়ে যেমন উল্লেখ করা হয়েছে,

অ্যাবস্ট্রাকফ্যাকারি কেবল পণ্য তৈরির জন্য একটি ইন্টারফেস ঘোষণা করে। এগুলি প্রকৃতপক্ষে তৈরি করার জন্য এটি কংক্রিটপ্রডাক্ট সাবক্লাসের। এটি করার সর্বাধিক সাধারণ উপায় হ'ল প্রতিটি পণ্যের জন্য একটি কারখানা পদ্ধতি নির্ধারণ করা।

এই সি 2 উইকি এই বিষয়ে কিছু আকর্ষণীয় আলোচনা আছে।

Comments

আমি মন্তব্য বা ডাউনভোট উভয়ই বুঝতে পারি। তুমি কি বিস্তারিত বলতে পারো?

— ডন রবি

ওয়েল, উত্তর আমার কাছে অলঙ্কৃত বলে মনে হয় ... কোন বাস্তব concreate উদাহরণ ... মাত্রাতিরিক্ত বিস্তৃত ...

— Novalis

Answer 3

দেখে মনে হচ্ছে যে ওপির (সেরা) প্রশ্নের তালিকা উপেক্ষা করা হয়েছে। বর্তমান উত্তরগুলি কেবল পুনরায় সংজ্ঞা প্রদান করে। তাই আমি সংক্ষিপ্তভাবে মূল প্রশ্নগুলির সমাধান করার চেষ্টা করব।

1. যদি অ্যাবস্ট্রাক্ট ফ্যাক্টরিতে কেবলমাত্র একজন স্রষ্টা এবং একটি পণ্য থাকে তবে এটি কি এখনও বিমূর্ত কারখানার ধরণ? (দুর্ভিক্ষ তৈরির জন্য একটি ইন্টারফেস)

কোন । একটি বিমূর্ত কারখানাএকটি "সম্পর্কিত পণ্যের পরিবার" তৈরি করতে অবশ্যই একাধিক পণ্য তৈরি করতে হবে। ক্যানোনিকাল GoF উদাহরণ তৈরি করে ScrollBar()এবং Window()। সুবিধা (এবং উদ্দেশ্য) হ'ল বিমূর্ত কারখানাটি তার একাধিক পণ্য জুড়ে একটি সাধারণ থিম প্রয়োগ করতে পারে।

2. ক্যান কারখানার পদ্ধতি জমাটবদ্ধ স্রষ্টা একটি ইন্টারফেস থেকে তৈরি করা বা এটি একটি বর্গ থেকে হতে আছে? (ক্লাসগুলি সাবক্লাসে ইনস্ট্যান্টেশনগুলি পিছিয়ে দেয়)

প্রথমত, আমাদের অবশ্যই লক্ষ্য রাখতে হবে যে যখন জিওএফ তাদের বইটি লিখেছিল তখন জাভা বা সি # উভয়ই ছিল না। পদটির জিওএফ ব্যবহারইন্টারফেস নির্দিষ্ট ভাষার দ্বারা প্রবর্তিত ইন্টারফেসের সাথে সম্পর্কিত নয়। সুতরাং, কোনও এপিআই থেকে কংক্রিট স্রষ্টা তৈরি করা যেতে পারে। প্যাটার্নটির গুরুত্বপূর্ণ বিষয়টি হ'ল এপিআই তার নিজস্ব ফ্যাক্টরি পদ্ধতি গ্রহণ করে, সুতরাং কেবলমাত্র একটি পদ্ধতির একটি ইন্টারফেস কোনও ফ্যাক্টরি পদ্ধতি হতে পারে না এটি তার বিমূর্ত কারখানা হতে পারে।

3. যদি অ্যাবস্ট্রাক্ট ফ্যাক্টরিতে কেবলমাত্র একজন স্রষ্টা এবং একটি পণ্য থাকতে পারে তবে অ্যাবস্ট্রাক্ট ফ্যাক্টরি এবং এর মধ্যে একমাত্র পার্থক্য কারখানার পদ্ধতির যে প্রাক্তনটির জন্য স্রষ্টা একটি ইন্টারফেস এবং পরবর্তীটির স্রষ্টা একটি শ্রেণি?

উপরের উত্তরগুলি অনুসরণ করে এই প্রশ্নটি আর বৈধ নয়; তবে, আপনি যদি এই ভাবনা ছেড়ে চলে যান যে অ্যাবস্ট্রাক্ট ফ্যাক্টরি এবং কারখানা পদ্ধতির মধ্যে একমাত্র পার্থক্যটি তৈরি পণ্যের সংখ্যা, বিবেচনা করুন যে কোনও ক্লায়েন্ট কীভাবে এই প্রতিটি নিদর্শন গ্রাস করে। একটি বিমূর্ত কারখানা সাধারণত তার ক্লায়েন্টের মধ্যে ইনজেকশনের হয়ে থাকে এবং সংমিশ্রণ / প্রতিনিধি দলের মাধ্যমে প্রার্থিত হয়। একটি কারখানা পদ্ধতি অবশ্যই উত্তরাধিকার সূত্রে প্রাপ্ত হতে হবে। সুতরাং এটি সমস্ত পুরানো রচনা বনাম উত্তরাধিকার বিতর্কে ফিরে আসে।

কিন্তু এই উত্তরগুলি একটি চতুর্থ প্রশ্ন উত্থাপন করেছে!

4. যেহেতু, কেবলমাত্র একটি পদ্ধতির ইন্টারফেস কোনও ফ্যাক্টরি পদ্ধতি হতে পারে না যা এটি অ্যাবস্ট্রাক্ট ফ্যাক্টরি হতে পারে , সুতরাং আমরা কেবল একটি পদ্ধতিতে ক্রিয়েটিভ ইন্টারফেসকে কী বলি?

যদি পদ্ধতিটি স্থিতিশীল হয় তবে এটি সাধারণত স্ট্যাটিক কারখানা বলে । পদ্ধতিটি যদি অচল থাকে তবে এটিকে সাধারণত সিম্পল ফ্যাক্টরি বলা হয় । এগুলির কোনওটিই জিওএফ প্যাটার্ন নয়, তবে বাস্তবে এগুলি আরও বেশি ব্যবহৃত হয়!

Comments

রচনা বনাম উত্তরাধিকার সম্পর্কে, আমি সর্বদা ভাবতাম: কারখানার পদ্ধতি প্যাটার্ন দিয়ে রচনাটি তৈরি করা কি সম্ভব নয়? কোন একটি ক্লায়েন্ট মধ্যে সঠিক কংক্রিট কারখানা রচনা বা ইনজেকশন থেকে বাধা দিতে পারে? বা এই ইতিমধ্যে প্যাটার্ন এর সুযোগ বাইরে কিছু?

— georaldc

জিওআরএলডিসি, জিওএফ থেকে (পৃষ্ঠা 107) " ফ্যাক্টরি পদ্ধতিটি একটি শ্রেণিকে উপশ্রেণীর কাছে ইনস্ট্যান্টেশনকে পিছিয়ে দেয়। " অন্য কথায়, কারখানা পদ্ধতি সংজ্ঞা অনুসারে উত্তরাধিকার ব্যবহার করে।

— jaco0646

Answer 4

আমার মতে, দুটি নিদর্শনগুলির মধ্যে সামান্য পার্থক্য প্রযোজ্যতার উপর নির্ভর করে এবং তাই, ইতিমধ্যে যেমনটি বলা হয়েছে, ইন্টেন্টে ।

আসুন সংজ্ঞাগুলি পুনরুদ্ধার করুন (উইকিপিডিয়া থেকে উভয়)।

বিমূর্ত কারখানা

সম্পর্কিত বা নির্ভরশীল বস্তুর পরিবারগুলি তাদের কংক্রিটের ক্লাসগুলি নির্দিষ্ট না করে তৈরি করার জন্য একটি ইন্টারফেস সরবরাহ করুন ।

কারখানার পদ্ধতি

কোনও অবজেক্ট তৈরির জন্য একটি ইন্টারফেস সংজ্ঞায়িত করুন , তবে ইন্টারফেস প্রয়োগকারী ক্লাসগুলি কোন শ্রেণিটি ইনস্ট্যান্ট করতে হবে তা সিদ্ধান্ত নিতে দিন । কারখানা পদ্ধতিটি একটি শ্রেণিকে সাবক্লাসে স্থগিত করে দেয়।

উভয় নিদর্শন প্রয়োজনীয় দৃষ্টান্ত (রান-টাইম ডিকোপলিং) তৈরি করতে ব্যবহারকারীর অবজেক্টগুলিকে ডিকুয়াল করার অনুমতি দেয় এবং এটিই সাধারণ দিক। উভয় নিদর্শন কোনও নির্দিষ্ট প্রয়োজন অনুসারে কারখানার শ্রেণিবিন্যাস তৈরি করতে দেয় এবং এটি অন্য একটি সাধারণ দিক।

অ্যাবস্ট্রাক্ট ফ্যাক্টরি এক উপ-শ্রেণিতে বিভিন্ন ধরণের দৃষ্টান্ত তৈরি করতে এবং তার বিভিন্ন উপ-শ্রেণিতে সৃজনশীল আচরণের বিশদ বিবরণ দেয়; সাধারণত, কারখানা পদ্ধতিটি কেবলমাত্র এক ধরণের অবজেক্টের তৈরির ঘোষণা দেয় যা উপ-শ্রেণিবদ্ধকরণ পদ্ধতি অনুসারে বিশদযুক্ত হতে পারে। এটাই পার্থক্য।

সংক্ষিপ্ত করে। ধরা যাক যে পণ্যটি তৈরির অবজেক্টগুলির সুপার-ক্লাসটি সংজ্ঞায়িত করে এবং প্রোডাক্টএ এবং প্রোডাক্টবি দুটি পৃথক উপ-শ্রেণী হয়। অতএব, অ্যাবস্ট্রাক্ট ফ্যাক্টরি পদ্ধতিতে দুটি পদ্ধতি থাকবে, ক্রিয়েটপ্রোডাক্টা () এবং ক্রিয়েটপ্রডাক্টবি () যা তার নির্দিষ্ট উপ-শ্রেণিতে বর্ণিত হবে (সৃষ্টি পদক্ষেপের শর্তে): কারখানা সাব-ক্লাসগুলি দুটি সংজ্ঞায়িত শ্রেণির জন্য সৃষ্টির পদক্ষেপগুলিকে বিশদভাবে জানায় সৃষ্টির অধীনে বস্তুর।

উপরোক্ত উদাহরণ অনুসারে, কারখানা পদ্ধতিটি বিভিন্নভাবে প্রয়োগ করা হবে, অনেকগুলি কারখানায় প্রোডাক্টএ এবং প্রোডাক্ট বি তৈরির বিমূর্ততা (কারখানার প্রতি এক পদ্ধতি), এবং নির্মাণের পদক্ষেপগুলির আরও বিশেষীকরণটি হায়ারার্কিতে নির্মিত হবে কারণ এটি নির্মিত হয়েছে ।

Answer 5

যদি আমি একটি বিমূর্ত (ইন্টারফেস বা অ্যাবস্ট্রাক্ট বেস ক্লাসের মাধ্যমে রেফারেন্স করা) ফ্যাক্টরি ক্লাস তৈরি করি যা অবজেক্ট তৈরি করতে কেবলমাত্র একটি পদ্ধতি রয়েছে এমন বস্তু তৈরি করে, তবে এটি ফ্যাক্টরি পদ্ধতি হবে ।

যদি অ্যাবস্ট্রাক্ট কারখানায় অবজেক্ট তৈরির জন্য 1 টিরও বেশি পদ্ধতি থাকে তবে এটি একটি বিমূর্ত কারখানা হবে ।

ধরা যাক আমি এমন একটি পরিচালক তৈরি করি যা এমভিসি নিয়ামকের জন্য ক্রিয়াকলাপের প্রয়োজনগুলি পরিচালনা করবে। যদি এর একটি পদ্ধতি থাকে তবে ইঞ্জিন অবজেক্ট তৈরি করতে বলুন যা ভিউ মডেলগুলি তৈরি করতে ব্যবহৃত হবে, তবে এটি ফ্যাক্টরি পদ্ধতির প্যাটার্ন হবে। অন্যদিকে যদি এর দুটি পদ্ধতি থাকে: একটি ভিউ মডেল ইঞ্জিন তৈরি করা এবং অন্যটি অ্যাকশন মডেল ইঞ্জিনগুলি তৈরি করা (বা আপনি যে মডেলটিকে কল করতে চান যেটি অ্যাকশন পদ্ধতিতে গ্রাহক রয়েছে), তবে এটি একটি বিমূর্ত কারখানা হবে।

public ActionResult DoSomething(SpecificActionModel model)
{
    var actionModelEngine = manager.GetActionModelEngine<SpecificActionModel>();
    actionModelEngine.Execute(SpecificActionModelEnum.Value);

    var viewModelEngine = manager.GetViewModelEngine<SpecificViewModel>();
    return View(viewModelEngine.GetViewModel(SpecificViewModelEnum.Value);
}

Answer 6

যদিও, স্ট্যাকওভারফ্লো থেকে লোকেরা অন্যান্য পোস্টগুলিতে একইভাবে প্রশ্নটি নিয়ে বহু বছর হয়ে গেছে (পুরানো ২০০৯ এ গিয়েছে), এখনও আমি যে উত্তর চেয়েছিলাম তা পাইনি।

• বিমূর্ত কারখানার প্যাটার্ন এবং কারখানা পদ্ধতির মধ্যে পার্থক্য
• কারখানা এবং বিমূর্ত কারখানার প্যাটার্নগুলির মধ্যে মূল পার্থক্য কী?

---

সুতরাং আমি ওয়েবের মাধ্যমে কয়েক ঘন্টা গবেষণা করেছি, উদাহরণগুলি পর্যালোচনা করে এই সিদ্ধান্তে পৌঁছেছি, কারখানা পদ্ধতি থেকে অ্যাবস্ট্রাক্ট ফ্যাক্টরির প্রধান পার্থক্যগুলি হ'ল

• অভিপ্রায়: একাত্মতা বা "চেহারা এবং অনুভূতি" : অ্যাবস্ট্রাক্ট ফ্যাক্টরির উদ্দেশ্য হ'ল একই শৈলীর সাথে বস্তুর একটি পরিবারকে গ্রুপ করা (উদাহরণস্বরূপ একই চেহারা এবং অনুভূতি ইউআই উইজেটস, একই স্টাইলের গাড়ির যন্ত্রাংশ, একই ওএস থেকে প্রাপ্ত বস্তু, ইত্যাদি) অ্যাবস্ট্রাক্ট ফ্যাক্টরির অনেকগুলি উদাহরণ "একই চেহারা এবং অনুভূতি" মূল বাক্যাংশ সম্পর্কে উল্লেখ করেছে।
• বৃহত্তর গ্রুপ অবজেক্ট গঠনকারী অবজেক্টস : অ্যাবস্ট্রাক্ট ফ্যাক্টরি একক বস্তু নয়, বৃহত্তর গ্রুপ অবজেক্ট গঠন করে এমন একটি পরিবারকে তৈরি করে।
• পরে একটি নতুন শৈলী যুক্ত করুন : আমরা যদি কারখানার পদ্ধতি ব্যবহার করতে থাকি এবং বিদ্যমান অবকাঠামোতে একটি নতুন সেট স্টাইল যুক্ত করার চেষ্টা করি, তবে এটি বেদনাদায়ক হবে। অ্যাবস্ট্রাক্ট ফ্যাক্টরি দিয়ে, আমাদের কেবলমাত্র একটি নতুন কংক্রিট কারখানা তৈরি করতে হবে যা বিমূর্ত কারখানার শ্রেণি প্রয়োগ করে।

পাল্টা উদাহরণ হবে

• একটি সেডানে ব্যবহৃত স্পোর্টস গাড়ির জন্য গাড়ির অংশ। এই অসঙ্গতি দুর্ঘটনার কারণ হতে পারে।
• বিভিন্ন ওএস জিইউআই উইজেটের একটি উইন্ডোজ-স্টাইল বোতাম। এটি আমার মতো কিছু লোকের ব্যবহারকারীর অভিজ্ঞতাকে আঘাত করা ছাড়া কিছু ভেঙে যাচ্ছে না।
• পরে, আমরা জানতে পারি যে আমাদের সফ্টওয়্যারটি পরবর্তী ওএস আপগ্রেডে চালিত হওয়া দরকার যা সফ্টওয়্যারকে পিছিয়ে রেখে সামঞ্জস্যপূর্ণ সিস্টেম অবজেক্টের বিভিন্ন সেট প্রয়োজন।

সুতরাং, যখন কোনও চূড়ান্ত অবজেক্ট গোষ্ঠীর কোনও অবজেক্ট ব্যতীত একই শৈলী থাকা উচিত এবং আপনি এই "একই শৈলীটি বজায় রেখে" বিশদটি গোপন রাখতে চান, তখন আমাদের বিমূর্ত কারখানাটি ব্যবহার করা উচিত।

Answer 7

যতদূর আমি বুঝতে পারি হে বিমূর্ত কারখানা এবং কারখানা পদ্ধতির সংজ্ঞাগুলি প্রথমটি স্থিতিক প্রসঙ্গে প্রয়োগ করা হয় এবং ইনপুট পরামিতিগুলির উপর ভিত্তি করে অবজেক্ট সরবরাহ করে।

দ্বিতীয়টি ইতিমধ্যে তৈরি করা বস্তু (পরিবার) ব্যবহার করে যা কারখানার পদ্ধতি ইন্টারফেস প্রয়োগ করে। ফ্যাক্টরি পদ্ধতিটি মূল বস্তুর সাথে সম্পর্কিত সুনির্দিষ্ট উদাহরণ তৈরি করে তবে এটি কোনটিই নয়।

সুতরাং এটি সাধারণত উভয় নিদর্শন একসাথে ব্যবহারের দিকে পরিচালিত করে যেখানে প্রথম পদক্ষেপে আপনি কিছু সাধারণ অবজেক্ট তৈরি করেন যা সম্পর্কিত অবজেক্টগুলির পরিবার বর্ণনা করে। এটিকে স্ট্যাটিক পদ্ধতি getInstance ("আমার পরিবারের নাম") পদ্ধতি দ্বারা বলা হয়। এই জাতীয় getInstance পদ্ধতির বাস্তবায়ন সিদ্ধান্ত নেয় যে কোন পরিবারিক আইটেমটি তৈরি করা হবে।

তারপরে আমি নতুন তৈরি করা পারিবারিক বস্তুতে ক্রিয়েটপ্রডাক্ট () পদ্ধতিটি কল করি এবং পারিবারিক বিষয় নির্ভর করে নতুন পণ্যটি ফিরে আসবে।

দেখে মনে হচ্ছে এই নিদর্শনগুলি একে অপরকে সহযোগিতা করে।

অন্য কথায় অ্যাবস্ট্রাক্ট ফ্যাক্টরিটি "WHAT" তৈরি হবে এবং ফ্যাক্টরি পদ্ধতিটি "কীভাবে" তৈরি হবে তার দিকে দৃষ্টি নিবদ্ধ করে।

Answer 8

আপনাকে কেবল মনে রাখতে হবে যে একটি বিমূর্ত কারখানাটি এমন একটি কারখানা যা একাধিক কারখানা ফিরতে পারে । সুতরাং আপনার যদি অ্যানিমাল স্পেসিজ ফ্যাক্টরি থাকে তবে এটি ফ্যাক্টরিগুলি এভাবে ফিরতে পারে:

মামলফ্যাক্টরি, বার্ডফ্যাক্টরি, ফিশফ্যাক্টরি, সরীসৃপ কারখানা। এখন আপনার কাছে অ্যানিমালস্পেসফ্যাক্টরি থেকে একটি কারখানা রয়েছে, তারা নির্দিষ্ট অবজেক্টস তৈরি করতে কারখানার প্যাটার্নটি ব্যবহার করে। উদাহরণস্বরূপ, কল্পনা করুন যে আপনি এই অ্যানিম্যাল ফ্যাক্টরি থেকে একটি সরীসৃপ কারখানা পেয়েছেন, তারপরে আপনি সরীসৃপগুলি যেমন: সাপ, কচ্ছপ, টিকটিকি তৈরি করতে পারেন।

Answer 9

/*
//Factory methods:

//1. Factory Method - Abstract Creator Class



#include <iostream>
#include <string.h>
using namespace std;

const std::string nineNintyCC = std::string("990CC");
const std::string thousandTwoHundredCC = std::string("1200CC");
const std::string ThousandFiveHundredCC = std::string("1500CC");
const std::string fiveThousandCC = std::string("5000CC");

// Product
class Engine
{
    public:
    virtual void packEngine() = 0;  
};

// Concrete products
// concrete product class one
class C990CCEngine: public Engine
{

    public:
    void packEngine()
    {
       cout << "Pack 990CC engine" << endl;   
    }
};

// concrete class Two
class C1200CCEngine: public Engine
{   public:
    void packEngine()
    {
        cout << "pack 1200CC engine" << endl;
    }

};

// Concrete class Three
class C1500CCEngine: public Engine
{
    public:
    void packEngine()
    {
        cout << "Pack 1500CC engine" << endl;
    }

};


// Car Factory:
class CarFactory{
    public:

    virtual Engine* createEngine(const std::string& type) = 0;
};
class Factory: public CarFactory
{
    public:
     Engine *createEngine(const std::string& type)
     {

          if(0 == nineNintyCC.compare(type))
          {    
             return new C990CCEngine;
          }
          else if(0 == thousandTwoHundredCC.compare(type))
          {
             return new C1200CCEngine;
          }
          else if(0 == ThousandFiveHundredCC.compare(type))
          {
             return new C1500CCEngine;
          } 
          else
           {
                 cout << "Invalid factory input" << endl;
             return NULL;
           }
           return NULL;
     }
};

int main()
{

    CarFactory* ptr = new Factory;
    Engine*pEngine =  ptr->createEngine(nineNintyCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    pEngine =  ptr->createEngine(ThousandFiveHundredCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    pEngine =  ptr->createEngine(thousandTwoHundredCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    pEngine = ptr-> createEngine(fiveThousandCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    return 0;
}

*/
/*
//
// interface product
#include <iostream>
#include <string>
using namespace std;

class Engine
{
 public:
 virtual void EngineType() = 0;

};

// concrte product
class AltoEngine: public Engine
{
  public:
  void EngineType()
  {
      cout << "Alto Engine" << endl;
  }
};

//Concrte product
class SwiftEngine : public Engine
{
    public:
    void EngineType()
    {
        cout << "Swift Engine" << endl;    
    }
};

class Body
{
   public:
    virtual void bodyType() = 0;

};

class AltoBody: public Body
{
  public:  
    virtual void bodyType()
    {
        cout << "Alto Car Body" << endl;
    }
};

class SwiftBody : public Body
{
    public:
    void bodyType()
    {
        cout << "SwiftCar Body" << endl;
    }

};


class CarFactory
{
   public:
   virtual Engine* createEngineProduct() = 0;
   virtual Body*   createBodyPoduct() = 0;
};
class AltoCarFactory: public CarFactory
{
    public:
    Engine * createEngineProduct()
    {
        return new AltoEngine;
    }
    Body* createBodyPoduct()
    {
        return new AltoBody;
    }

};

class SwiftCarFactory: public CarFactory
{
    public:
    Engine * createEngineProduct()
    {
        return new SwiftEngine;
    }
    Body* createBodyPoduct()
    {
        return new SwiftBody;
    }

};

int main()
{

    CarFactory* pAltoFactory = new AltoCarFactory;
    Engine* pAltoEngine = pAltoFactory->createEngineProduct();
    pAltoEngine->EngineType();
    Body* pAltoBody = pAltoFactory->createBodyPoduct();
    pAltoBody->bodyType();



    CarFactory* pSwiftFactory = NULL;
    pSwiftFactory = new SwiftCarFactory;
    Engine* pSwiftEngine = pSwiftFactory->createEngineProduct();
    pSwiftEngine->EngineType();
    Body* pSwfitBody = pSwiftFactory->createBodyPoduct();
    pSwfitBody->bodyType();
    delete pAltoBody;
    delete pAltoFactory;
    delete pSwfitBody;
    delete pSwiftFactory;
    return 0;
}
*/

/*

// One more Factory example;

#include <iostream>
#include <string>
using namespace std;

const std::string maruthi = std::string("Maruthi");
const std::string fiat = std::string("Fiat");
const std::string renault = std::string("Renault");
// Interface
class CarEngine
{
 public:
    virtual void engineType() = 0;
};

// Concrete class
class FiatEngine: public CarEngine
{
  public:
  void engineType()
  {
      cout << "Fait Engine Engine" << endl;
  }

};
// ConcreteClass
class RenaultEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Renault Engine" << endl;
    }

};
// Concrete class
class MaruthiEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Maruthi Engine" << endl;
    }
};


// Factory
class CarFactory
{
    public:
    virtual CarEngine* createFactory(const std::string&) = 0;
};

// EngineFactory
class CarEngineFactory : public CarFactory
{
     public:
     CarEngine* createFactory(const std::string&  type)
     {
          if(0 == maruthi.compare(type))
          {
              return new MaruthiEngine;

          }
          else if(0 == fiat.compare(type))
          {
              return  new FiatEngine;
          }
          else if(0 == renault.compare(type))
          {
              return new RenaultEngine;
          }
          else
          {
              cout << "Invalid Engine type" << endl;
              return NULL;
          }
     }

  };

int main()
{
    CarFactory* pCarFactory = new CarEngineFactory;
    CarEngine* pMaruthiCarEngine = pCarFactory->createFactory(maruthi);
    pMaruthiCarEngine->engineType();

    CarEngine* pFiatCarEngine = pCarFactory->createFactory(fiat);
    pFiatCarEngine->engineType();


    CarEngine* pRenaultCarEngine = pCarFactory->createFactory(renault);
    pRenaultCarEngine->engineType();

    return 0;
}


*/


/*

// One more Factory example;

#include <iostream>
#include <string>
using namespace std;

const std::string maruthi = std::string("Maruthi");
const std::string fiat = std::string("Fiat");
const std::string renault = std::string("Renault");


// Interface
class CarEngine
{
 public:
    virtual void engineType() = 0;
};

// Concrete class
class FiatEngine: public CarEngine
{
  public:
  void engineType()
  {
      cout << "Fait Car Engine" << endl;
  }

};

// ConcreteClass
class RenaultEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Renault Car Engine" << endl;
    }

};

// Concrete class
class MaruthiEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Maruthi Car Engine" << endl;
    }
};

// Interface
class CarBody
{
 public:
    virtual void bodyType() = 0;
};

// Concrete class
class FiatBody: public CarBody
{
  public:
  void bodyType()
  {
      cout << "Fait car Body" << endl;
  }

};

// ConcreteClass
class RenaultBody : public CarBody
{
    public:
    void bodyType()
    {
        cout << "Renault Body" << endl;
    }

};

// Concrete class
class MaruthiBody : public CarBody
{
    public:
    void bodyType()
    {
        cout << "Maruthi body" << endl;
    }
};


// Factory
class CarFactory
{
    public:
    virtual CarEngine* createCarEngineProduct() = 0;
    virtual CarBody* createCarBodyProduct() = 0;
};

// FiatFactory
class FaitCarFactory : public CarFactory
{
     public:
     CarEngine* createCarEngineProduct()
     {
        return new FiatEngine; 
     }
     CarBody* createCarBodyProduct()
     {
         return new FiatBody;
     }
};

// Maruthi Factory
class MaruthiCarFactory : public CarFactory
{
     public:
     CarEngine* createCarEngineProduct()
     {
         return new MaruthiEngine;
     }
     CarBody* createCarBodyProduct()
     {
         return new MaruthiBody;
     }

};

// Renault Factory
class RenaultCarFactory : public CarFactory
{
     public:
    CarEngine* createCarEngineProduct()
    {
        return new RenaultEngine;
    }

    CarBody* createCarBodyProduct()
    {
        return new RenaultBody;
    }

};


int main()
{

   // Fiat Factory
   CarFactory* pFiatCarFactory = new FaitCarFactory;
   CarEngine* pFiatEngine = pFiatCarFactory->createCarEngineProduct();
   CarBody*  pFiatBody = pFiatCarFactory->createCarBodyProduct();
   pFiatEngine->engineType();
   pFiatBody->bodyType();

   // Renault Car Factory
    return 0;
}

*/

Answer 10

কারখানার পদ্ধতি প্যাটার্ন হ'ল একটি ক্রিয়েশনাল ডিজাইন প্যাটার্ন যা তৈরি করা হচ্ছে এমন অবজেক্টের সঠিক শ্রেণিটি না দেখিয়ে বস্তু তৈরির সাথে সম্পর্কিত। এই নকশার ধরণটি মূলত একটি শ্রেণিকে উপ-শ্রেণিতে ইনস্ট্যান্টেশনকে পিছিয়ে দিতে দেয় allows

অ্যাবস্ট্রাক্ট ফ্যাক্টরি প্যাটার্নটি কংক্রিটের ক্লাসগুলি উন্মোচন না করে স্বতন্ত্র কারখানার একটি গ্রুপকে এনক্যাপসুলেশন সরবরাহ করে। এই মডেলটিতে, একটি বিমূর্ত কারখানা শ্রেণীর জেনেরিক ইন্টারফেসটি প্রয়োজনীয় কংক্রিট অবজেক্ট তৈরি করতে ব্যবহৃত হয় যাতে তাদের ব্যবহার এবং রচনা থেকে পদার্থের প্রয়োগের বিবরণ পৃথক করে। এই ডিজাইনের ধরণটি জিইউআই অ্যাপ্লিকেশনগুলিতে ব্যাপকভাবে ব্যবহৃত হয় যেখানে অনুরূপ ধরণের জিইউআই উপাদান তৈরি করা দরকার।

গুগলে অনুসন্ধান করার সময় আমি নীচের ব্লগে এসেছি যা উভয় ডিজাইনের প্যাটার্নকে দুর্দান্তভাবে ব্যাখ্যা করেছে। এগুলি দেখুন

http://simpletechtalks.com/factory-design-pattern/

http://simpletechtalks.com/abstract-factory-design-pattern/