డిజైన్ నమూనాలు: సింగిల్టన్, ఫ్యాక్టరీ, ఫ్యాక్టరీ పద్ధతి, వియుక్త కర్మాగారం

"హాయ్, అమిగో!"

"హాయ్, బిలాబో!"

"ఈరోజు మా అంశం కేవలం ఆసక్తికరంగా ఉండదు - ఇది స్పష్టమైన ఇతిహాసం అవుతుంది."

"ఈరోజు నేను మీకు డిజైన్ నమూనాలు ఏమిటో తెలియజేస్తున్నాను. "

"కూల్! నేను వారి గురించి చాలా విన్నాను. నేను వేచి ఉండలేను!"

"అనుభవజ్ఞులైన ప్రోగ్రామర్లు చాలా తరగతులు వ్రాయవలసి ఉంటుంది. కానీ ఈ ఉద్యోగంలో అత్యంత కష్టతరమైన భాగం ఏమిటంటే, ఏ తరగతులను సృష్టించాలో మరియు వాటిలో పనిని ఎలా విభజించాలో నిర్ణయించడం."

"వారు అలాంటి ప్రశ్నలను ఎంత ఎక్కువగా పరిష్కరించారో, కొన్ని పరిష్కారాలు మంచివి, మరికొన్ని చెడ్డవి అని వారు గ్రహించారు."

"చెడు పరిష్కారాలు సాధారణంగా అవి పరిష్కరించే దానికంటే ఎక్కువ సమస్యలను సృష్టిస్తాయి. అవి పేలవంగా విస్తరించడం, అనేక అనవసరమైన పరిమితులను సృష్టించడం మొదలైనవి. మరియు మంచి పరిష్కారాలు దీనికి విరుద్ధంగా ఉంటాయి."

"మీరు చేయగల సారూప్యత ఏదైనా ఉందా?"

"మీరు ఇంటిని నిర్మిస్తున్నారని అనుకుందాం. మరియు అది దేనితో నిర్మించబడుతుందని మీరు ఆలోచిస్తున్నారు. మీకు గోడలు, నేల మరియు పైకప్పు అవసరం అని మీరు నిర్ణయించుకుంటారు. ఫలితంగా, మీరు ఫ్లాట్ రూఫ్‌తో ఇంటిని నిర్మిస్తారు మరియు లేదు. పునాది. అలాంటి ఇల్లు పగుళ్లు ఏర్పడుతుంది మరియు పైకప్పు లీక్ అవుతుంది. ఇది చెడ్డ పరిష్కారం."

"దీనికి విరుద్ధంగా, పునాది, గోడలు మరియు గేబుల్ పైకప్పుతో కూడిన ఇల్లు మంచి పరిష్కారంగా ఉంటుంది. భారీ హిమపాతం ఎటువంటి సమస్య ఉండదు, ఎందుకంటే మంచు పైకప్పు నుండి జారిపోతుంది. మరియు నేలలు మారడం వలన భయపడాల్సిన పని లేదు, ఎందుకంటే పునాది నిర్ధారిస్తుంది. స్థిరత్వం. మేము అలాంటి పరిష్కారాన్ని మంచిగా పిలుస్తాము."

"నేను చూస్తున్నాను. ధన్యవాదాలు."

"సరే. అప్పుడు నేను కంటిన్యూ చేస్తాను."

"కాలక్రమేణా, మంచి పరిష్కారాలను డిజైన్ నమూనాలు అని పిలుస్తారు, అయితే చెడు వాటిని వ్యతిరేక నమూనాలు అని పిలుస్తారు."

"డిజైన్ ప్యాటర్న్ అనేది ప్రశ్నకు సమాధానం లాంటిది. మీరు ఆ ప్రశ్నను ఎప్పుడూ వినకపోతే అర్థం చేసుకోవడం కష్టం."

" మొదటి వర్గం నమూనాలు సృష్టి నమూనాలు. ఇటువంటి నమూనాలు వస్తువుల సృష్టికి సంబంధించిన మంచి పరిష్కారాలను వివరిస్తాయి."

"వస్తువులను సృష్టించడంలో సంక్లిష్టత ఏమిటి?"

"ఇది జరిగినప్పుడు, మేము ఇప్పుడు అన్వేషించబోతున్నాము."

సింగిల్టన్ నమూనా.

"తరచుగా ప్రోగ్రామ్‌లలో, కొన్ని వస్తువుల యొక్క ఒకే కాపీ మాత్రమే ఉంటుంది. ఉదాహరణకు, కన్సోల్, లాగర్, చెత్త సేకరించేవాడు మొదలైనవి."

" చెడు పరిష్కారం: ఏ వస్తువులు సృష్టించవద్దు — కేవలం అన్ని పద్ధతులు స్థిరంగా ఉండే తరగతిని సృష్టించండి."

" మంచి పరిష్కారం:  ఒకే వస్తువును సృష్టించి, దానిని స్టాటిక్ వేరియబుల్‌లో నిల్వ చేయండి. తరగతి యొక్క రెండవ ఆబ్జెక్ట్‌ని సృష్టించడాన్ని నిరోధించండి. ఉదాహరణకు:"

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
{
}

"ఈ తరగతుల వస్తువుల సృష్టిని మనం సరళంగా మరియు సౌకర్యవంతంగా ఎలా నిర్వహించగలము అనేది ప్రశ్న."

"ఈ సమస్య మీకు చాలా దూరం అనిపించినట్లయితే, గేమ్‌లో మీరు డజన్ల కొద్దీ కత్తులు మరియు షీల్డ్‌లు, వందల కొద్దీ మాయా మంత్రాలు మరియు వేలాది రాక్షసులను సృష్టించాలని ఊహించుకోండి. ఇక్కడ వస్తువును సృష్టించడానికి అనుకూలమైన విధానం లేకుండా మీరు చేయలేరు. "

" ఫ్యాక్టరీ నమూనా మంచి పరిష్కారాన్ని అందిస్తుంది."

"మొదట, మేము వివిధ తరగతులకు అనుగుణంగా ఉండే విలువలను సృష్టించాలి."

"రెండవది, enum విలువ ఆధారంగా ఆబ్జెక్ట్(ల)ని సృష్టించే స్టాటిక్ మెథడ్(లు)ని కలిగి ఉన్న ప్రత్యేక ఫ్యాక్టరీ క్లాస్‌ని సృష్టించండి."

"ఉదాహరణకి:"

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 విలువను పద్ధతుల మధ్య పాస్ చేయవచ్చు."

"మూడవది, enum ఫీల్డ్‌ల సంఖ్య తరగతుల సంఖ్యకు సరిపోలనవసరం లేదు. అనేక రకాల అక్షరాలు ఉండవచ్చు, కానీ కొన్ని తరగతులు ఉండవచ్చు."

"ఉదాహరణకు, ఒక Mag & Warrior ఒక తరగతిని (మానవుడు) ఉపయోగించవచ్చు, కానీ విభిన్న బలం మరియు మాయా లక్షణాలతో (కన్స్ట్రక్టర్ వాదనలు)."

"ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది (స్పష్టత కోసం, నేను డార్క్ దయ్యాలను కూడా జోడించాను):"

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

"పై ఉదాహరణలో, మేము వివిధ జాతుల (సైన్ల) మధ్య యుద్ధాలను అనుకరించే తరగతిని కలిగి ఉన్నాము. మీరు కేవలం రెండు ఆర్మీ వస్తువులను పాస్ చేయాలి. విజేతను గుర్తించడానికి వివిధ దళాలను సృష్టించడానికి మరియు వారి మధ్య వర్చువల్ యుద్ధాలను నిర్వహించడానికి తరగతి స్వయంగా వాటిని ఉపయోగిస్తుంది. ."

"నేను చూస్తున్నాను. ధన్యవాదాలు. నిజంగా ఆసక్తికరమైన విధానం."

"మీరు ఏమి చెప్పినా మంచి పరిష్కారం."

"అవును."

"ఈ అంశంపై మరొక మంచి లింక్ ఇక్కడ ఉంది:  వియుక్త ఫ్యాక్టరీ నమూనా "