डिझाइन नमुने: सिंगलटन, कारखाना, कारखाना पद्धत, अमूर्त कारखाना

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

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

"आमचा आजचा विषय केवळ मनोरंजक होणार नाही - तो सरळ महाकाव्य असेल."

"आज मी तुम्हाला डिझाईनचे नमुने काय आहेत ते सांगणार आहे. "

"छान! मी त्यांच्याबद्दल खूप ऐकले आहे. मी थांबू शकत नाही!"

"अनुभवी प्रोग्रामरना बरेच वर्ग लिहावे लागतात. परंतु या कामाचा सर्वात कठीण भाग म्हणजे कोणते वर्ग तयार करायचे आणि त्यांच्यामध्ये काम कसे विभाजित करायचे हे ठरवणे."

"त्यांनी असे प्रश्न जितके सोडवले, तितकेच त्यांना समजले की काही उपाय चांगले असतात, तर काही वाईट असतात."

"खराब उपाय सहसा सोडवण्यापेक्षा अधिक समस्या निर्माण करतात. ते खराबपणे वाढवतात, अनेक अनावश्यक मर्यादा निर्माण करतात इ. आणि चांगले उपाय उलट असतात."

"तुम्ही करू शकता असे काही साधर्म्य आहे का?"

"तुम्ही घर बांधत आहात असे समजा. आणि ते कशापासून बनवले जाईल याचा तुम्ही विचार करत आहात. तुम्हाला भिंती, मजला आणि छताची गरज आहे हे तुम्ही ठरवू शकता. परिणामी, तुम्ही सपाट छप्पर असलेले घर बांधता आणि नाही. पाया. अशा घराला तडे जाईल आणि छत फुटेल. हा एक वाईट उपाय आहे."

"याउलट, पाया, भिंती आणि गॅबल छप्पर असलेले घर हा एक चांगला उपाय असेल. जोरदार बर्फवृष्टीमुळे कोणतीही अडचण येत नाही, कारण बर्फ छतावरून सरकतो. आणि माती हलवताना घाबरण्याचे कारण नाही, कारण पाया निश्चित करेल. स्थिरता. आम्ही अशा उपायाला चांगले म्हणू."

"मी बघतो. धन्यवाद."

"ठीक आहे. मग मी चालू ठेवतो."

"कालांतराने, चांगल्या उपायांना डिझाइन पॅटर्न म्हणून ओळखले जाऊ लागले, तर वाईट उपायांना अँटी-पॅटर्न म्हटले गेले."

"डिझाईन पॅटर्न हा प्रश्नाच्या उत्तरासारखा असतो. तुम्ही प्रश्न कधीच ऐकला नसेल तर ते समजणे कठीण आहे."

" नमुन्यांची पहिली श्रेणी म्हणजे निर्मितीचे नमुने. असे नमुने वस्तूंच्या निर्मितीशी संबंधित चांगल्या उपायांचे वर्णन करतात."

"वस्तू तयार करण्यात इतके क्लिष्ट काय आहे?"

"जसे घडते, तेच आम्ही आता एक्सप्लोर करणार आहोत."

सिंगलटन पॅटर्न.

"अनेकदा प्रोग्राम्समध्ये, काही वस्तूंची फक्त एकच प्रत अस्तित्वात असू शकते. उदाहरणार्थ, कन्सोल, लॉगर, कचरा गोळा करणारे इ.."

" वाईट उपाय: कोणतीही वस्तू तयार करू नका - फक्त एक वर्ग तयार करा ज्याच्या सर्व पद्धती स्थिर आहेत."

" चांगला उपाय:  एकच ऑब्जेक्ट तयार करा आणि ते स्थिर व्हेरिएबलमध्ये संग्रहित करा. वर्गाचा दुसरा ऑब्जेक्ट तयार होण्यास प्रतिबंध करा. उदाहरणार्थ:"

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);

"दुसर्‍या शब्दात, आम्ही ऑब्जेक्ट निर्मिती व्यवस्थापित करण्यासाठी एक विशेष वर्ग तयार केला?"

"हो."

"मग हे काय फायदे देते?"

"प्रथम, या वर्गात, आवश्यक डेटासह ऑब्जेक्ट्स सुरू केले जाऊ शकतात."

"दुसरे, आपण इच्छित ऑब्जेक्ट तयार करण्यासाठी आपल्याला पाहिजे तितक्या पद्धतींमध्ये आवश्यक एनम मूल्य पास करू शकता."

"तिसरे, enum फील्डची संख्या वर्गांच्या संख्येशी जुळत नाही. अनेक प्रकारचे वर्ण असू शकतात, परंतु काही वर्ग आहेत."

"उदाहरणार्थ, मॅग आणि वॉरियर एक वर्ग (मानवी) वापरू शकतो, परंतु भिन्न सामर्थ्य आणि जादू गुणधर्मांसह (कन्स्ट्रक्टर युक्तिवाद)."

"ते कसे दिसू शकते ते येथे आहे (स्पष्टतेसाठी, मी गडद एल्व्ह देखील जोडले आहेत):"

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);

"वरील उदाहरणात, सहा वेगवेगळ्या प्रकारच्या वस्तू तयार करण्यासाठी आम्ही फक्त तीन वर्ग वापरले आहेत. हे अतिशय सोयीचे आहे. शिवाय, आमच्याकडे हे सर्व तर्क एका वर्गात आणि एका पद्धतीमध्ये केंद्रित आहेत."

"आता समजा आम्ही Ogre साठी वेगळा वर्ग तयार करण्याचा निर्णय घेतला - आम्ही फक्त येथे कोडच्या दोन ओळी बदलतो, आणि अर्धा अनुप्रयोग नाही."

"मी सहमत आहे. हा एक चांगला उपाय आहे."

"आणि मी याबद्दल बोलत आहे: डिझाइन नमुने हे चांगल्या समाधानांचे संग्रह आहेत."

"मला ते कुठे वापरायचे हे मला माहीत असायचे..."

"हो. मी सहमत आहे, तुम्हाला लगेच समजणार नाही. तरीही, माहित नसणे आणि करू शकत नाही यापेक्षा जाणून घेणे आणि करू शकत नाही हे अधिक चांगले आहे. या पॅटर्नबद्दल तुमच्यासाठी आणखी एक उपयुक्त लिंक येथे आहे: फॅक्टरी पॅटर्न "

"ओह, थँक्स."

" अमूर्त कारखाना नमुना."

"कधीकधी जेव्हा तुमच्याकडे भरपूर वस्तू असतात, तेव्हा कारखान्यांसाठी कारखाना तयार करण्याची कल्पना स्वतःच सुचते. अशा कारखान्याला अमूर्त कारखाना म्हणतात ."

"याची कुठे गरज पडेल?!"

"समजा तुमच्याकडे एकसारख्या वस्तूंचे अनेक गट आहेत. हे उदाहरणासह दाखवणे सोपे आहे."

"आता, समजा तुमच्या खेळात तीन शर्यती आहेत: मानव, पर्या आणि भुते. आणि समतोल राखण्यासाठी, प्रत्येक शर्यतीत योद्धा, धनुर्धारी आणि जादूगार असतात. एक खेळाडू फक्त तो किंवा ती ज्या शर्यतीसाठी खेळत आहे त्याच्याशी संबंधित वस्तू तयार करू शकतो. गेममध्ये. ते कोडमध्ये कसे दिसेल ते येथे आहे:"

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);

"वरील उदाहरणात, आमच्याकडे एक वर्ग आहे जो वेगवेगळ्या वंशांच्या (सैन्य) दरम्यानच्या लढायांचे अनुकरण करतो. तुम्हाला फक्त दोन आर्मी ऑब्जेक्ट्स पास करणे आवश्यक आहे. वर्ग स्वतः त्यांचा वापर करून विविध सैन्ये तयार करतो आणि विजेता ओळखण्यासाठी त्यांच्यामध्ये आभासी लढाया आयोजित करतो. ."

"मी पाहतो. धन्यवाद. खरोखर एक मनोरंजक दृष्टीकोन."

"तुम्ही काय म्हणता याची पर्वा न करता एक चांगला उपाय."

"हो."

"या विषयावर आणखी एक चांगला दुवा आहे:  अमूर्त कारखाना नमुना "