వియుక్త తరగతులు

"హలో, అమిగో! మా దగ్గర ఆకర్షణీయమైన కొత్త అంశం ఉంది."

"ఈ రోజు కేవలం మనోహరమైన అంశాల రోజు!"

"ఎందుకు, ధన్యవాదాలు!"

"మీకు స్వాగతం."

" చదరంగం ముక్కల కోసం అన్ని తరగతులను సులభతరం చేయడానికి మేము చెస్ ఐటెమ్ బేస్ క్లాస్‌ను ఎప్పుడు ప్రవేశపెట్టామని గుర్తుంచుకోవాలా ?"

"అవును."

"ఇప్పుడు ప్రతి ముక్క స్క్రీన్‌పై భాగాన్ని రెండరింగ్ చేసే పద్ధతిని కలిగి ఉందని ఊహించండి. మీరు పద్ధతిని కాల్ చేయండి మరియు ముక్క దాని ప్రస్తుత కోఆర్డినేట్‌ల వద్ద ఆకర్షిస్తుంది. ఈ పద్ధతిని బేస్ క్లాస్‌కి తరలించడం సహాయకరంగా ఉంటుందా?"

"అవును." నేను పాలిమార్ఫిజం గురించి తెలుసుకున్న తర్వాత, అన్ని ముక్కల రకంతో సంబంధం లేకుండా రెండర్ పద్ధతిని పిలవగలను. ఇలాంటిది ఏదైనా:"

class ChessBoard
{
  public void drawAllChessItems()
  {
  //draw them regardless of their type.
  ArrayList <ChessItem> items = new ArrayList<ChessItem>();
  items.add(new King());
  items.add(new Queen());
  items.add(new Bishop());

  //draw them regardless of their type.
  for (ChessItem item: items)
  {
   item.draw();
  }
 }
}

"బాగా చేసారు. సరిగ్గా. మరియు చెస్ ఐటమ్ క్లాస్ లోనే డ్రా పద్ధతి ద్వారా ఏమి చేస్తారు?"

"నాకు తెలియదు. చదరంగంలో అలాంటి పావు లేదు. మరియు దానికి దృశ్యమాన ప్రాతినిధ్యం లేదు."

"ఖచ్చితంగా. మరియు ఒక చెస్ ఐటమ్ వస్తువును సృష్టించడం సమంజసం కాదు. అలాంటి చదరంగం ముక్క లేదు. ఇది కేవలం ఒక సంగ్రహణ మాత్రమే —మనం సౌలభ్యం కోసం తయారు చేసిన తరగతి. ఆ విధంగా OOPలో సంగ్రహణ పని చేస్తుంది: మేము అన్ని ముఖ్యమైన వాటిని తరలించాము (భాగస్వామ్యం చేయబడింది అన్ని ముక్కల ద్వారా) డేటా మరియు మెథడ్స్‌ను బేస్ క్లాస్‌గా మార్చాము , కానీ మేము నిర్దిష్ట చెస్ ముక్కలకు సంబంధించిన తరగతుల్లో వాటి తేడాలను ఉంచాము."

దీని కోసం జావా ప్రత్యేక తరగతి రకాన్ని కలిగి ఉంది: వియుక్త తరగతి . వియుక్త తరగతుల గురించి గుర్తుంచుకోవలసిన మూడు విషయాలు ఇక్కడ ఉన్నాయి.

1) ఒక నైరూప్య తరగతి వాటిని అమలు చేయకుండా పద్ధతులను ప్రకటించవచ్చు. ఇటువంటి పద్ధతిని వియుక్త పద్ధతి అంటారు.

 public abstract class ChessItem
{
 public int x, y; //coordinates
 private int value; //the piece's "value"

 public int getValue() //an ordinary method, returns value
 {
   return value;
 }

 public abstract void draw(); //abstract method. There is no implementation.

}

2) ఒక వియుక్త పద్ధతి నైరూప్య కీవర్డ్‌తో గుర్తించబడింది .

ఒక తరగతికి ఒక వియుక్త పద్ధతి ఉంటే, ఆ తరగతి కూడా అబ్‌స్ట్రాక్ట్‌తో గుర్తు పెట్టబడుతుంది .

3) మీరు వియుక్త తరగతి వస్తువులను సృష్టించలేరు. అలా చేయడానికి ప్రయత్నిస్తున్న కోడ్ కంపైల్ చేయబడదు.

ChessItem item = new ChessItem();
item.draw();

ChessItem item = new Queen();
item.draw();

4) మీ తరగతి ఒక వియుక్త తరగతిని వారసత్వంగా పొందినట్లయితే, మీరు వారసత్వంగా వచ్చిన అన్ని వియుక్త పద్ధతులను భర్తీ చేయాలి, అంటే మీరు వాటిని అమలు చేయాలి. లేకపోతే, మీ తరగతిని కూడా వియుక్తంగా ప్రకటించాల్సి ఉంటుంది. క్లాస్‌లో అమలు చేయని ఒక పద్ధతిని నేరుగా క్లాస్‌లో ప్రకటించినట్లయితే లేదా మాతృ తరగతి నుండి వారసత్వంగా పొందినట్లయితే, తరగతి వియుక్తంగా పరిగణించబడుతుంది.

"అయితే ఇవన్నీ ఎందుకు అవసరం? మనకు వియుక్త తరగతులు ఎందుకు అవసరం? బదులుగా సాధారణ తరగతులను ఉపయోగించడం సాధ్యం కాదా? మరియు వియుక్త పద్ధతులకు బదులుగా, కర్లీ బ్రాకెట్లను తెరవడం మరియు మూసివేయడం వంటి ఖాళీ అమలులను సృష్టించలేమా?"

"మీరు చేయగలరు. కానీ ఈ పరిమితులు మాడిఫైయర్ లాంటివి . డేటాకు ప్రత్యక్ష ప్రాప్యతను ఉద్దేశపూర్వకంగా నిరోధించడానికి privateమేము మాడిఫైయర్‌ని ఉపయోగిస్తాము , తద్వారా ఇతర ప్రోగ్రామర్లు మరియు వారి తరగతులు మా పద్ధతులను ఉపయోగిస్తాయి."privatepublic

అదే వియుక్త తరగతికి వర్తిస్తుంది. క్లాస్‌ని ఎవరు రాసినా, క్లాస్‌కి సంబంధించిన ఇన్‌స్టాన్స్‌లను సృష్టించడం ఎవరికీ ఇష్టం ఉండదు. దీనికి విరుద్ధంగా, రచయిత అతని లేదా ఆమె నైరూప్య తరగతి యొక్క నైరూప్య పద్ధతులు వారసత్వంగా మరియు భర్తీ చేయబడాలని ఆశించారు.

"మన జీవితాలను ఈ విధంగా ఎందుకు క్లిష్టతరం చేయాలనుకుంటున్నామో నాకు ఇప్పటికీ అర్థం కాలేదు."

"ఈ ఫీచర్ యొక్క ప్రయోజనం పెద్ద ప్రాజెక్ట్‌లలో స్పష్టంగా కనిపిస్తుంది. మీకు ఎక్కువ తరగతులు ఉంటే, మీరు వారి పాత్రలను మరింత స్పష్టంగా వివరించాలి. మీరు దీన్ని చేయడం వల్ల కలిగే ప్రయోజనాన్ని చూస్తారు మరియు త్వరలో. ప్రతి ఒక్కరూ దీని ద్వారా వెళ్ళాలి."

3

టాస్క్

జావా కోర్, స్థాయి, పాఠం

లాక్ చేయబడింది

Code entry

Sometimes you don't need to think, you just need to hammer it out! As paradoxical as it may seem, sometimes your fingers will "remember" better than your conscious mind. That's why while training at the secret CodeGym center you will sometimes encounter tasks that require you to enter code. By entering code, you get used to the syntax and assimilate some material. What's more, you combat laziness.

తెరవండి