विरासत। वंशानुक्रम के लाभ

"नमस्कार, अमीगो! अब यहाँ एक विषय है जो मुझे लगता है कि आप बहुत उपयोग करेंगे। मैं वंशानुक्रम के बारे में बात कर रहा हूँ। "

बिन बुलाए के लिए, प्रोग्रामिंग जादू की तरह है। तो चलिए एक सादृश्य से शुरू करते हैं...

मान लीजिए कि आप एक जादूगर हैं जो उड़ने वाला घोड़ा बनाना चाहता है। आप एक पेगासस जादू करने की कोशिश कर सकते हैं। लेकिन चूंकि उड़ने वाले घोड़े स्वाभाविक रूप से नहीं होते हैं, आपके लिए वास्तव में कठिन समय होगा। आपके पास करने के लिए बहुत काम होगा। घोड़े के साथ शुरुआत करना और कुछ पंखों को बुलाना बहुत आसान होगा।

प्रोग्रामिंग में, हम इस प्रक्रिया को "विरासत" कहते हैं । मान लीजिए आपको एक बहुत ही जटिल वर्ग लिखने की आवश्यकता है। आप स्क्रैच से कोड लिखने में लंबा समय लगा सकते हैं, और फिर बग खोजने के लिए लंबा परीक्षण कर सकते हैं। लेकिन यह कठिन तरीका क्यों है? चारों ओर देखना और देखना बेहतर है कि क्या आप जिस वर्ग की तलाश कर रहे हैं वह पहले से मौजूद है?

मान लें कि आपको एक ऐसा वर्ग मिल गया है जो आपके लिए आवश्यक कार्यक्षमता का 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
}
}

"बहुत दिलचस्प!"

"बिल्कुल! लाभ विशेष रूप से हजारों विभिन्न वस्तुओं और सैकड़ों वर्गों वाली परियोजनाओं में बड़ा है। इस मामले में, उचित रूप से चुने गए वर्ग न केवल तर्क को सरल बना सकते हैं, बल्कि आवश्यक कोड को दस के कारक से भी कम कर सकते हैं।"

"तो आपको एक वर्ग का वारिस करने के लिए क्या करना होगा?"

"एक वर्ग घोषित करने के बाद, हम ' विस्तार ' कीवर्ड का उपयोग करते हैं , जिसके बाद मूल वर्ग का नाम होता है। आप केवल एक वर्ग से प्राप्त कर सकते हैं। "

तस्वीर एक "गाय" दिखाती है जो एक "सुअर" से विरासत में मिली है। «सुअर» «मुर्गी» से विरासत में मिला है, और «मुर्गी» «अंडे» से विरासत में मिला है। प्रत्येक वर्ग में केवल एक अभिभावक होता है! ऐसी विरासत हमेशा तार्किक नहीं होती है। यदि आपके पास केवल एक सुअर है, लेकिन आपको वास्तव में एक गाय की आवश्यकता है, तो प्रोग्रामर अक्सर "सुअर" से "गाय" बनाने की इच्छा का विरोध नहीं कर सकते हैं।

"लेकिन क्या होगा अगर मैं दो वर्गों से उत्तराधिकारी बनना चाहता हूं? क्या मैं कुछ कर सकता हूं?"

"वास्तव में नहीं। जावा कक्षाएं कार्यान्वयन के एकाधिक वंशानुक्रम का समर्थन नहीं करती हैं: एक वर्ग में केवल एक ही मूल वर्ग हो सकता है। लेकिन प्रकार की कई विरासत है, जिसका अर्थ है कि एक वर्ग एक से अधिक इंटरफ़ेस को लागू कर सकता है। यह समस्या को थोड़ा कम करता है। "

"अच्छा। और इंटरफ़ेस क्या है?"

"मैं आपको इंटरफेस के बारे में कल बताऊंगा। अभी के लिए, विरासत में तल्लीन करना जारी रखें।"