వారసత్వం. వారసత్వం యొక్క ప్రయోజనాలు

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

తెలియని వారికి, ప్రోగ్రామింగ్ మాయాజాలం లాంటిది. కాబట్టి నేను ఒక సారూప్యతతో ప్రారంభిస్తాను…

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

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

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

1) మీరు కనుగొన్న తరగతి ఇప్పటికే బైట్‌కోడ్‌లో కంపైల్ చేయబడి ఉండవచ్చు. మీరు దాని సోర్స్ కోడ్‌కి యాక్సెస్ కలిగి ఉండకపోవచ్చు.

2) మీరు తరగతికి సంబంధించిన సోర్స్ కోడ్‌ని కలిగి ఉండవచ్చు, కానీ మీరు వేరొకరి కోడ్‌లోని 6 లైన్‌లను కూడా ఉపయోగిస్తే కొన్ని బిలియన్ల కోసం దావా వేయబడే కంపెనీలో కూడా పని చేయవచ్చు. ఆపై వారు మీపై దావా వేస్తారు.

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

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

"చాలా ఆసక్తికరం. దయచేసి కొనసాగండి."

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

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

"మనం చదరంగం ప్రోగ్రాం వ్రాస్తున్నామని అనుకుందాం. చెస్ ముక్కలకు క్లాసులు కావాలి. మీరు ఏ క్లాసులను సూచిస్తారు, అమిగో?"

"కింగ్, క్వీన్, బిషప్, నైట్, రూక్ మరియు బంటు."

"చాలా బాగుంది. మీరు ఏమీ మిస్ కాలేదు."

"మరియు మీరు ఈ తరగతులలో ఏ డేటాను నిల్వ చేయాలని సూచిస్తారు?"

"ప్రతి ముక్క యొక్క బోర్డు స్థానం (x మరియు y) మరియు విలువ. అన్నింటికంటే, కొన్ని ముక్కలు ఇతరులకన్నా విలువైనవి."

"మరియు ఈ తరగతుల మధ్య తేడాలు ఏమిటి?"

"వారు పావులు కదిపే విధానంలో విభేదిస్తారు. వారి ప్రవర్తనలో."

"అవును. మీరు వాటిని ఇలా తరగతులుగా నిర్వచించవచ్చు:"

class King
{
int x;
int y;
int worth;
void kingMove()
{
//code that defines,
//how the king moves
}
}

class Queen
{
int x;
int y;
int worth;
void queenMove()
{
//code that defines,
//how the queen moves
}
}

class Rook
{
int x;
int y;
int worth;
void rookMove()
{
//code that defines,
//how the rook moves
}
}

class Knight
{
int x;
int y;
int worth;
void knightMove()
{
//code that defines,
//how the knight moves
}
}

class Bishop
{
int x;
int y;
int worth;
void bishopMove()
{
//code that defines,
//how the bishop moves
}
}

class Pawn
{
int x;
int y;
int worth;
void pawnMove()
{
//code that defines,
//how the pawn moves
}
}

"అవును, నేను సరిగ్గా అలా వ్రాస్తాను."

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

class King extends ChessItem
{
void kingMove()
{
//code that defines,
//how the king moves
}
}

class Queen extends ChessItem
{
void queenMove()
{
//code that defines,
//how the queen moves
}
}

class Rook extends ChessItem
{
void rookMove()
{
//code that defines,
//how the rook moves
}
}

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

class Knight extends ChessItem
{
void knightMove()
{
//code that defines,
//how the knight moves
}
}

class Bishop extends ChessItem
{
void bishopMove()
{
//code that defines,
//how the bishop moves
}
}

class Pawn extends ChessItem
{
void pawnMove()
{
//code that defines,
//how the pawn moves
}
}

"ఎంత ఆసక్తికరంగా!"

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

"కాబట్టి మీరు తరగతిని వారసత్వంగా పొందేందుకు ఏమి చేయాలి?"

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

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

"అయితే నేను రెండు తరగతుల నుండి వారసత్వంగా పొందాలనుకుంటే? నేను చేయగలిగినది ఏదైనా ఉందా?!"

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

"నేను చూస్తున్నాను. మరియు ఇంటర్‌ఫేస్ అంటే ఏమిటి?"

"నేను మీకు ఇంటర్‌ఫేస్‌ల గురించి రేపు చెబుతాను. ప్రస్తుతానికి, వారసత్వాన్ని పరిశోధించడాన్ని కొనసాగిద్దాం."