వారసత్వం

1. పెగాసస్

OOP యొక్క మూడవ సూత్రాన్ని లోతుగా పరిశీలిద్దాం : వారసత్వం . ఇది మీరు తరచుగా ఉపయోగించే చాలా ఆసక్తికరమైన అంశం. ప్రారంభించని వారికి, ప్రోగ్రామింగ్ మ్యాజిక్ నుండి వేరు చేయలేనిది. కాబట్టి ఆసక్తికరమైన సారూప్యతతో ప్రారంభిద్దాం...;

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

ప్రోగ్రామింగ్‌లో, ఈ ప్రక్రియను "వారసత్వం" అంటారు. మీరు చాలా క్లిష్టమైన తరగతిని వ్రాయవలసి ఉందని అనుకుందాం. స్క్రాచ్ నుండి కోడ్ వ్రాయడానికి చాలా సమయం పడుతుంది, ఆపై లోపాల కోసం వెతకడానికి చాలా కాలం పాటు ప్రతిదీ పరీక్షించండి. ఎందుకు కఠినమైన మార్గంలో వెళ్ళాలి? అటువంటి తరగతి ఇప్పటికే ఉందా లేదా అని చూడటం మంచిది.

మీకు అవసరమైన 80% కార్యాచరణను అమలు చేసే ఒక తరగతిని మీరు కనుగొన్నారని అనుకుందాం. దానితో మీరు తర్వాత ఏమి చేస్తారు? మీరు దాని కోడ్‌ని మీ తరగతిలోకి కాపీ చేసుకోవచ్చు. కానీ ఈ పరిష్కారం అనేక లోపాలను కలిగి ఉంది:

1. మీరు కనుగొన్న తరగతి ఇప్పటికే బైట్‌కోడ్‌లో కంపైల్ చేయబడి ఉండవచ్చు మరియు దాని సోర్స్ కోడ్‌కి మీకు యాక్సెస్ ఉండకపోవచ్చు.
2. తరగతి యొక్క సోర్స్ కోడ్ అందుబాటులో ఉంది, కానీ మీరు వేరొకరి కోడ్‌లోని 6 లైన్‌లను కూడా ఉపయోగించినందుకు కొన్ని బిలియన్ల కోసం దావా వేయబడే కంపెనీ కోసం పని చేస్తున్నారు. ఆపై మీ యజమాని మీపై దావా వేస్తారు.
3. పెద్ద మొత్తంలో కోడ్ యొక్క అనవసరమైన నకిలీ. అదనంగా, బాహ్య తరగతి రచయిత దానిలో బగ్‌ని కనుగొని దాన్ని పరిష్కరిస్తే, మీరు ఇప్పటికీ బగ్‌ను కలిగి ఉంటారు.

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

2. సాధారణ బేస్ క్లాస్

వారసత్వాన్ని ఇతర ప్రయోజనాల కోసం కూడా ఉపయోగించవచ్చు. మీకు చాలా సారూప్యమైన పది తరగతులు ఉన్నాయని అనుకుందాం. వారు ఒకే డేటా మరియు పద్ధతులను కలిగి ఉన్నారు. మీరు ప్రత్యేక బేస్ క్లాస్‌ని సృష్టించవచ్చు, డేటాను (మరియు అనుబంధిత పద్ధతులు) ఈ బేస్ క్లాస్‌లోకి తరలించవచ్చు మరియు ఆ పది తరగతులను వారసులుగా ప్రకటించవచ్చు. మరో మాటలో చెప్పాలంటే, ప్రతి తరగతిలో దాని పేరెంట్ క్లాస్ ఈ బేస్ క్లాస్ అని సూచిస్తుంది.

సంగ్రహణ యొక్క ప్రయోజనాలు సైడ్ ఎన్‌క్యాప్సులేషన్‌తో మాత్రమే వెల్లడి చేయబడినట్లే, పాలిమార్ఫిజమ్‌ను ఉపయోగిస్తున్నప్పుడు వారసత్వం యొక్క ప్రయోజనాలు కూడా చాలా మెరుగుపడతాయి. కానీ మీరు దాని గురించి కొంచెం తరువాత నేర్చుకుంటారు. ఈ రోజు మనం వారసత్వాన్ని ఉపయోగించే అనేక ఉదాహరణలను పరిశీలిస్తాము.

చెస్ ముక్కలు

మనం ఒక మానవ వినియోగదారుతో చెస్ ఆడే ప్రోగ్రామ్‌ని వ్రాస్తున్నామని అనుకుందాం. దీని ప్రకారం, ముక్కలను సూచించడానికి మాకు తరగతులు అవసరం. వారు ఏ తరగతులు ఉంటారు?

మీరు ఎప్పుడైనా చెస్ ఆడినట్లయితే, స్పష్టమైన సమాధానం కింగ్, క్వీన్, బిషప్, నైట్, రూక్ మరియు పాన్.

కానీ తరగతులు తాము ఇప్పటికీ ప్రతి ముక్క గురించి సమాచారాన్ని నిల్వ చేయాలి. ఉదాహరణకు, x మరియు y కోఆర్డినేట్‌లు మరియు ముక్క విలువ. అన్ని తరువాత, కొన్ని ముక్కలు ఇతరులకన్నా విలువైనవి.

అదనంగా, ముక్కలు భిన్నంగా కదులుతాయి, అంటే తరగతులు విభిన్న ప్రవర్తనను అమలు చేస్తాయి. మీరు వాటిని తరగతులుగా ఎలా నిర్వచించవచ్చో ఇక్కడ ఉంది:

class King
{
   int x;
   int y;
   int worth;

   void kingMove()
   {
     // Code that decides
     // how to move
     // the king
   }
}

class Queen
{
   int x;
   int y;
   int worth;

   void queenMove()
   {
     // Code that decides
     // how to move
     // the queen
   }
}

class Rook
{
   int x;
   int y;
   int worth;

   void rookMove()
   {
     // Code that decides
     // how to move
     // the rook
   }
}

class Knight
{
   int x;
   int y;
   int worth;

   void knightMove()
   {
     // Code that decides
     // how to move
     // the knight
   }
}

class Bishop
{
   int x;
   int y;
   int worth;

   void bishopMove()
   {
     // Code that decides
     // how to move
     // the bishop
   }
}

class Pawn
{
   int x;
   int y;
   int worth;

   void pawnMove()
   {
     // Code that decides
     // how to move
     // the pawn
   }
}

ఇది చెస్ ముక్కల గురించి చాలా ప్రాచీనమైన వివరణ.

సాధారణ బేస్ క్లాస్

మరియు కోడ్ మొత్తాన్ని తగ్గించడానికి మీరు వారసత్వాన్ని ఎలా ఉపయోగించవచ్చో ఇక్కడ ఉంది. మేము సాధారణ పద్ధతులు మరియు డేటాను సాధారణ తరగతికి తీసుకురాగలము. మేము దానిని పిలుస్తాము ChessItem. ఆబ్జెక్ట్‌లనుChessItem class రూపొందించడంలో అర్థం లేదు , ఎందుకంటే క్లాస్ ఏ చదరంగం ముక్కకు అనుగుణంగా ఉండదు . ఈ తరగతి చాలా ఉపయోగకరంగా ఉంటుందని రుజువు చేస్తుంది:

class King extends ChessItem
{
   void kingMove()
   {
     // Code that decides
     // how to move the king
   }
}

class Queen extends ChessItem
{
   void queenMove()
   {
     // Code that decides
     // how to move the queen
   }
}

class Rook extends ChessItem
{
   void rookMove()
   {
     // Code that decides
     // how to move the rook
   }
}

class ChessItem
{
   int x;
   int y;
   int worth;
}

class Knight extends ChessItem
{
   void knightMove()
   {
     // Code that decides
     // how to move the knight
   }
}

class Bishop extends ChessItem
{
   void bishopMove()
   {
     // Code that decides
     // how to move the bishop
   }
}

class Pawn extends ChessItem
{
   void pawnMove()
   {
     // Code that decides
     // how to move the pawn
   }
}

సారూప్య వస్తువుల కోసం కోడ్‌ను సరళీకృతం చేయడానికి ఇది గొప్ప మార్గం. ప్రాజెక్ట్‌లో వేలాది విభిన్న వస్తువులు మరియు వందలాది తరగతులు ఉన్నప్పుడు ప్రయోజనాలు ప్రత్యేకంగా గుర్తించబడతాయి. కాబట్టి సరిగ్గా ఎంచుకున్న పేరెంట్ (బేస్) తరగతులు మీరు లాజిక్‌ను చాలా సులభతరం చేయడమే కాకుండా, కోడ్‌ను పదిరెట్లు తగ్గించేలా చేస్తాయి.

3. తరగతి వారసత్వం -extends

కాబట్టి తరగతిని వారసత్వంగా పొందేందుకు ఏమి పడుతుంది? ఒక తరగతి మరొక తరగతిని వారసత్వంగా పొందాలంటే, మీరు చైల్డ్ క్లాస్ డిక్లరేషన్ తర్వాత కీవర్డ్‌ని వ్రాసి extends, ఆపై పేరెంట్ క్లాస్ పేరును వ్రాయాలి. ఇది సాధారణంగా ఇలా కనిపిస్తుంది:

class Descendant extends Parent

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

చిత్రంలో, ఒక ఆవు పందిని వారసత్వంగా పొందిందని, అది కోడిని వారసత్వంగా పొందిందని, అది గుడ్డును వారసత్వంగా పొందిందని మనం చూస్తున్నాము. ఒక్క పేరెంట్ మాత్రమే! అటువంటి వారసత్వం ఎల్లప్పుడూ తార్కికం కాదు. కానీ మీ వద్ద ఉన్నది పంది మాత్రమే మరియు మీకు నిజంగా ఆవు అవసరం అయినప్పుడు, ప్రోగ్రామర్లు తరచుగా పంది నుండి ఆవును తయారు చేయాలనే కోరికను అడ్డుకోలేరు.

జావాకు బహుళ వారసత్వం లేదు: ఒక తరగతి రెండు తరగతులను వారసత్వంగా పొందదు. ప్రతి తరగతికి ఒక పేరెంట్ క్లాస్ మాత్రమే ఉంటుంది. పేరెంట్ క్లాస్ ఏదీ పేర్కొనబడకపోతే, పేరెంట్ క్లాస్ Object.

జావా ఇంటర్‌ఫేస్‌ల బహుళ వారసత్వాన్ని కలిగి ఉందని పేర్కొంది. ఇది సమస్యను కొద్దిగా తగ్గిస్తుంది. మేము ఇంటర్‌ఫేస్‌ల గురించి కొంచెం తరువాత మాట్లాడుతాము, కానీ ప్రస్తుతానికి వారసత్వాన్ని అన్వేషించడాన్ని కొనసాగిద్దాం.