डिज़ाइन पैटर्न: सिंगलटन, फ़ैक्टरी, फ़ैक्टरी विधि, अमूर्त फ़ैक्टरी

"हाय, अमीगो!"

"हाय, बिलाबो!"

"हमारा विषय आज केवल दिलचस्प नहीं होगा - यह सर्वथा महाकाव्य होगा।"

"आज मैं आपके पास जा रहा हूँ कि डिज़ाइन पैटर्न क्या हैं। "

"अच्छा! मैंने उनके बारे में बहुत सुना है। मैं इंतजार नहीं कर सकता!"

"अनुभवी प्रोग्रामर को बहुत सारी कक्षाएं लिखनी पड़ती हैं। लेकिन इस काम का सबसे कठिन हिस्सा यह तय करना है कि कौन सी कक्षाएं बनाई जाएं और उनमें काम कैसे बांटा जाए।"

"जितना अधिक उन्होंने इस तरह के सवालों को हल किया, उतना ही उन्हें एहसास हुआ कि कुछ समाधान अच्छे हैं, जबकि अन्य बुरे हैं।"

"खराब समाधान आमतौर पर हल करने की तुलना में अधिक समस्याएं पैदा करते हैं। वे खराब तरीके से विस्तार करते हैं, कई अनावश्यक सीमाएं बनाते हैं, आदि। और अच्छे समाधान इसके विपरीत होते हैं।"

"क्या आप कुछ सादृश्य बना सकते हैं?"

"मान लीजिए कि आप एक घर बना रहे हैं। और आप सोच रहे हैं कि यह किस चीज से बनेगा। आप तय करें कि आपको दीवारों, फर्श और छत की जरूरत है। नतीजतन, आप एक सपाट छत के साथ एक घर बनाते हैं और नहीं नींव। ऐसे घर में दरार पड़ेगी, और छत टपकेगी। यह एक बुरा उपाय है।"

"इसके विपरीत, नींव, दीवारों और एक विशाल छत वाला एक घर एक अच्छा समाधान होगा। भारी बर्फबारी कोई समस्या नहीं पेश करती है, क्योंकि बर्फ छत से फिसल जाएगी। और मिट्टी बदलने से डरने की कोई बात नहीं है, क्योंकि नींव सुनिश्चित करेगी स्थिरता। हम ऐसे समाधान को अच्छा कहेंगे।"

"अच्छा। धन्यवाद।"

"ठीक है। फिर मैं जारी रखूंगा।"

"समय के साथ, अच्छे समाधानों को डिजाइन पैटर्न के रूप में जाना जाने लगा, जबकि बुरे लोगों को विरोधी पैटर्न कहा जाने लगा।"

"एक डिज़ाइन पैटर्न एक प्रश्न के उत्तर की तरह है। यदि आपने कभी प्रश्न नहीं सुना है तो यह समझना मुश्किल है।"

" पैटर्न की पहली श्रेणी सृजनात्मक पैटर्न है। ऐसे पैटर्न वस्तुओं के निर्माण से संबंधित अच्छे समाधानों का वर्णन करते हैं।"

"ऑब्जेक्ट बनाने में इतना जटिल क्या है?"

"जैसा होता है, वैसा ही अब हम तलाशने जा रहे हैं।"

सिंगलटन पैटर्न।

"अक्सर कार्यक्रमों में, कुछ वस्तुओं की केवल एक ही प्रति मौजूद हो सकती है। उदाहरण के लिए, कंसोल, लकड़हारा, कचरा संग्राहक, आदि।"

" खराब समाधान: कोई वस्तु न बनाएँ - बस एक वर्ग बनाएँ जिसकी सभी विधियाँ स्थिर हों।"

" अच्छा समाधान:  एक एकल वस्तु बनाएँ और इसे एक स्थिर चर में संग्रहीत करें। कक्षा की दूसरी वस्तु के निर्माण को रोकें। उदाहरण के लिए:"

class Sun
{
 private static Sun instance;
 public static Sun getInstance()
 {
  if (instance == null)
  instance = new Sun();

  return instance;
 }

 private Sun()
 {
 }
}

Sun sun = Sun.getInstance();

"यह आसान है।"

"सबसे पहले, हम कंस्ट्रक्टर को निजी बनाते हैं। अब इसे केवल हमारी कक्षा के अंदर से ही बुलाया जा सकता है। हमने सूर्य वर्ग के तरीकों को छोड़कर हर जगह सूर्य वस्तुओं के निर्माण को रोक दिया है।"

"दूसरा, इस वर्ग का एक ऑब्जेक्ट केवल getInstance() विधि को कॉल करके प्राप्त किया जा सकता है। न केवल यह एकमात्र तरीका है जो सूर्य वस्तु बना सकता है, यह भी सुनिश्चित करता है कि केवल एक ऐसी वस्तु है।"

"अच्छा ऐसा है।"

"जब आप सोचते हैं, «अब, मैं वास्तव में ऐसा कैसे करूंगा?», एक पैटर्न कहता है, «आप यह कोशिश कर सकते हैं - यह सबसे अच्छे समाधानों में से एक है।»"

"धन्यवाद। अब चीजें स्पष्ट होने लगी हैं।"

"आप  यहां इस पैटर्न के बारे में भी पढ़ सकते हैं ।"

फैक्टरी पैटर्न।

"यहां एक ऐसी स्थिति है जिसका प्रोग्रामर बहुत बार सामना करते हैं। आपके पास कुछ आधार वर्ग और कई उपवर्ग हैं। उदाहरण के लिए, एक खेल चरित्र वर्ग (गेमपर्सन) और अन्य सभी पात्रों के लिए कक्षाएं जो इसे प्राप्त करते हैं।"

"मान लें कि आपके पास निम्न वर्ग हैं:"

abstract class GamePerson
{
}

class Warrior extends GamePerson
{
}

class Mag extends GamePerson
{
}

class Troll extends GamePerson
{
}

class Elf extends GamePerson
{
}

"सवाल यह है कि हम कैसे लचीले ढंग से और आसानी से इन वर्गों की वस्तुओं के निर्माण का प्रबंधन करते हैं।"

"यदि यह समस्या आपको दूर की कौड़ी लगती है, तो कल्पना करें कि खेल में आपको दर्जनों तलवारें और ढालें, सैकड़ों जादू मंत्र और हजारों राक्षस बनाने की आवश्यकता है। आप यहाँ वस्तु निर्माण के लिए एक सुविधाजनक दृष्टिकोण के बिना नहीं कर सकते। "

" कारखाना पैटर्न एक अच्छा समाधान प्रदान करता है।"

"सबसे पहले, हमें एक एनम बनाने की जरूरत है जिसके मूल्य विभिन्न वर्गों के अनुरूप हों।"

"दूसरा, एक विशेष फ़ैक्टरी वर्ग बनाएँ जिसमें स्थैतिक विधियाँ हों जो एक एनम मान के आधार पर वस्तुएँ बनाएँ।"

"उदाहरण के लिए:"

public enum PersonType
{
 UNKNOWN,
 WARRIOR,
 MAG,
 TROLL,
 ELF,
}

public class PersonFactory
{
 public static GamePerson createPerson(PersonType personType)
 {
  switch(personType)
  {
   WARRIOR:
   return new Warrior();
   MAG:
   return new Mag();
   TROLL:
   return new Troll();
   ELF:
   return new Elf();
   default:
   throw new GameException();
  }
 }
}

GamePerson person = PersonFactory.createPerson(PersonType.MAG);

"दूसरे शब्दों में, हमने वस्तु निर्माण के प्रबंधन के लिए एक विशेष वर्ग बनाया है?"

"हां।"

"तो यह क्या लाभ प्रदान करता है?"

"सबसे पहले, इस वर्ग में, वस्तुओं को आवश्यक डेटा के साथ प्रारंभ किया जा सकता है।"

"दूसरा, आप वांछित ऑब्जेक्ट बनाने के लिए जितना चाहें उतना तरीकों के बीच आवश्यक एनम वैल्यू पास कर सकते हैं।"

"तीसरा, एनम फ़ील्ड की संख्या को कक्षाओं की संख्या से मेल नहीं खाना है। कई प्रकार के वर्ण हो सकते हैं, लेकिन कुछ वर्ग।"

"उदाहरण के लिए, एक मैग एंड वारियर एक वर्ग (मानव) का उपयोग कर सकता है, लेकिन अलग-अलग ताकत और जादू गुणों (निर्माता तर्क) के साथ।"

"यहाँ यह कैसा दिख सकता है (स्पष्टता के लिए, मैंने डार्क एल्व्स भी जोड़े हैं):"

public enum PersonType
{
 UNKNOWN,
 WARRIOR,
 MAG,
 TROLL,
 ELF,
 DARK_ELF
}

public class PersonFactory
{
 public static GamePerson createPerson(PersonType personType)
 {
  switch(personType)
  {
   WARRIOR:
   return new Human(10, 0); // Strength, magic
   MAG:
   return new Human(0, 10); // Strength, magic
   TROLL:
   OGR:
   return new Troll();
   ELF:
   return new Elf(true); // true – good, false – evil
   DARK_ELF:
   return new Elf(false); // true – good, false – evil
   default:
   throw new GameException();
  }
 }
}

GamePerson person = PersonFactory.createPerson(PersonType.MAG);

"ऊपर के उदाहरण में, हमने छह अलग-अलग प्रकार की वस्तुओं को बनाने के लिए सिर्फ तीन वर्गों का उपयोग किया। यह बहुत सुविधाजनक है। इसके अलावा, हमारे पास यह सारा तर्क एक वर्ग और एक विधि में केंद्रित है।"

"अब मान लीजिए कि हम ओग्रे के लिए एक अलग वर्ग बनाने का फैसला करते हैं - हम यहां कोड की कुछ पंक्तियों को बदलते हैं, न कि आधे आवेदन को।"

"मैं सहमत हूँ। यह एक अच्छा समाधान है।"

"और यही मैं बात कर रहा हूं: डिजाइन पैटर्न अच्छे समाधानों का संग्रह हैं।"

"मैं यह भी चाहता हूं कि मुझे पता हो कि उनका उपयोग कहां करना है ..."

"हां। मैं सहमत हूं, आप तुरंत समझ नहीं पाएंगे। फिर भी, यह जानना बेहतर है और न जानने और न करने में सक्षम होने से बेहतर है। यहां आपके लिए इस पैटर्न के बारे में एक और उपयोगी लिंक है: फैक्टरी पैटर्न "

"ओह धन्यवाद।"

" एब्स्ट्रैक्ट फैक्ट्री पैटर्न।"

"कभी-कभी जब आपके पास बहुत सारी वस्तुएं होती हैं, तो कारखानों के लिए एक कारखाना बनाने का विचार स्वयं सुझाता है। ऐसे कारखाने को एक अमूर्त कारखाना कहा जाता है ।"

"इसकी आवश्यकता कहाँ होगी ?!"

"मान लीजिए कि आपके पास समान वस्तुओं के कई समूह हैं। उदाहरण के साथ दिखाना आसान है।"

"अब, मान लें कि आपके खेल में तीन दौड़ें हैं: मनुष्य, कल्पित बौने और राक्षस। और संतुलन के लिए, प्रत्येक दौड़ में योद्धा, तीरंदाज और जादूगर हैं। एक खिलाड़ी केवल उस दौड़ से संबंधित वस्तुओं का निर्माण कर सकता है जिसके लिए वह खेल रहा है। खेल में। यहां बताया गया है कि यह कोड में कैसा दिखेगा:"

class Warrior
{
}
class Archer
{
}
class Mag
{
}

class HumanWarrior extends Warrior
{
}

class HumanArcher extends Archer
{
}

class HumanMag extends Mag
{
}

class ElfWarrior extends Warrior
{
}

class ElfArcher extends Archer
{
}

class ElfMag extends Mag
{
}

class DaemonWarrior extends Warrior
{
}

class DaemonArcher extends Archer
{
}

class DaemonMag extends Mag
{
}

और अब दौड़ बनाते हैं, या हम उन्हें सेना भी कह सकते हैं।

abstract class Army
{
 public Warrior createWarrior();
 public Archer createArcher();
 public Mag createMag();
}

class HumanArmy extends Army
{
 public Warrior createWarrior()
 {
  return new HumanWarrior();
 }
 public Archer createArcher()
 {
  return new HumanArcher();
 }
 public Mag createMag()
 {
  return new HumanMag();
 }
}

class ElfArmy extends Army
{
 public Warrior createWarrior()
 {
  return new ElfWarrior();
 }
 public Archer createArcher()
 {
  return new ElfArcher();
 }
 public Mag createMag()
 {
  return new ElfMag();
 }
}

class DaemonArmy extends Army
{
 public Warrior createWarrior()
 {
  return new DaemonWarrior();
 }
 public Archer createArcher()
 {
  return new DaemonArcher();
 }
 public Mag createMag()
 {
  return new DaemonMag();
 }
}

"लेकिन आप इसका उपयोग कैसे करते हैं?"

"आप कार्यक्रम में कहीं भी सेना, योद्धा, तीरंदाज और दाना वर्गों का उपयोग कर सकते हैं, और आवश्यक वस्तुओं को बनाने के लिए - बस वांछित सेना उपवर्ग का एक वस्तु पास करें।"

"उदाहरण के लिए:"

Army humans = new HumanArmy();
Army daemons = new DaemonArmy();

Army winner = FightSimulator.simulate(humans, daemons);

"उपर्युक्त उदाहरण में, हमारे पास एक वर्ग है जो विभिन्न जातियों (सेनाओं) के बीच लड़ाई का अनुकरण करता है। आपको केवल दो सेना वस्तुओं को पारित करने की आवश्यकता है। विजेता की पहचान करने के लिए वर्ग स्वयं उन्हें विभिन्न सैनिकों को बनाने और उनके बीच आभासी लड़ाई आयोजित करने के लिए उपयोग करता है। "

"ठीक है। धन्यवाद। वास्तव में एक दिलचस्प दृष्टिकोण।"

"आप जो भी कहते हैं, उसके बावजूद एक अच्छा समाधान।"

"हां।"

"यहाँ विषय पर एक और अच्छा लिंक है:  सार कारखाना पैटर्न "