विरासत

1. पेगासस

आइए OOP के तीसरे सिद्धांत : वंशानुक्रम पर गहराई से नज़र डालें । यह एक बहुत ही रोचक विषय है जिसका आप अक्सर उपयोग करेंगे। शुरुआती लोगों के लिए, प्रोग्रामिंग जादू से अप्रभेद्य है। तो चलिए शुरू करते हैं एक दिलचस्प उपमा से...;

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

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

मान लीजिए कि आपको एक ऐसा वर्ग मिलता है, जिसकी विधियाँ आपके लिए आवश्यक कार्यक्षमता का 80% लागू करती हैं। आप इसके साथ आगे क्या करते हैं? आप इसके कोड को अपनी कक्षा में कॉपी कर सकते हैं। लेकिन इस समाधान में कई कमियां हैं:

1. आपको जो वर्ग मिल रहा है वह पहले से ही बायटेकोड में संकलित हो सकता है, और हो सकता है कि आपके पास इसके स्रोत कोड तक पहुंच न हो।
2. वर्ग का स्रोत कोड उपलब्ध है, लेकिन आप एक ऐसी कंपनी के लिए काम करते हैं, जिस पर किसी और के कोड की 6 पंक्तियों का उपयोग करने के लिए कुछ बिलियन का मुकदमा किया जा सकता है। और फिर आपका नियोक्ता आप पर मुकदमा करेगा।
3. बड़ी मात्रा में कोड का अनावश्यक दोहराव। इसके अतिरिक्त, यदि किसी बाहरी वर्ग के लेखक को इसमें कोई बग मिलता है और उसे ठीक करता है, तब भी आपके पास बग रहेगा।

एक और अधिक सुरुचिपूर्ण समाधान है, और इसे मूल वर्ग के कोड तक कानूनी पहुंच प्राप्त करने की आवश्यकता नहीं है। जावा में, आप बस उस वर्ग को अपनी कक्षा के जनक के रूप में घोषित कर सकते हैं। यह उस वर्ग के कोड को अपने कोड में जोड़ने के बराबर होगा। आपकी कक्षा सभी डेटा और मूल वर्ग के सभी तरीकों को देखेगी। उदाहरण के लिए, आप यह कर सकते हैं: हम "घोड़ा" प्राप्त करते हैं और फिर "पेगासस" प्राप्त करने के लिए "पंख" जोड़ते हैं

2. सामान्य आधार वर्ग

विरासत का उपयोग अन्य उद्देश्यों के लिए भी किया जा सकता है। मान लीजिए कि आपके पास दस वर्ग हैं जो बहुत समान हैं। उनके पास समान डेटा और तरीके हैं। आप एक विशेष आधार वर्ग बना सकते हैं, डेटा (और संबंधित विधियों) को इस आधार वर्ग में स्थानांतरित कर सकते हैं, और उन दस वर्गों को वंशज घोषित कर सकते हैं। दूसरे शब्दों में, प्रत्येक वर्ग में संकेत मिलता है कि इसका मूल वर्ग यह आधार वर्ग है।

जिस तरह अमूर्तता के फायदे केवल साइड एनकैप्सुलेशन के साथ सामने आते हैं, उसी तरह बहुरूपता का उपयोग करते समय वंशानुक्रम के फायदे भी बहुत बढ़ जाते हैं। लेकिन आप इसके बारे में थोड़ी देर बाद जानेंगे। आज हम वंशानुक्रम के उपयोग के कई उदाहरण देखेंगे।

शतरंज के टुकड़े

मान लीजिए कि हम एक प्रोग्राम लिख रहे हैं जो मानव उपयोगकर्ता के साथ शतरंज खेलता है। तदनुसार, हमें टुकड़ों का प्रतिनिधित्व करने के लिए कक्षाओं की आवश्यकता है। वे कौन से वर्ग होंगे?

यदि आपने कभी शतरंज खेला है, तो स्पष्ट उत्तर राजा, रानी, ​​​​बिशप, नाइट, रूक और प्यादा है।

लेकिन कक्षाओं को अभी भी प्रत्येक टुकड़े के बारे में जानकारी संग्रहीत करने की आवश्यकता होगी। उदाहरण के लिए, एक्स और वाई निर्देशांक, और टुकड़े का मूल्य। आखिरकार, कुछ टुकड़े दूसरों की तुलना में अधिक मूल्यवान होते हैं।

इसके अलावा, टुकड़े अलग-अलग चलते हैं, जिसका अर्थ है कि कक्षाएं अलग-अलग व्यवहार लागू करेंगी। यहां बताया गया है कि आप उन्हें कक्षाओं के रूप में कैसे परिभाषित कर सकते हैं:

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।

उस ने कहा, जावा में इंटरफेस की एकाधिक विरासत है। इससे समस्या थोड़ी कम हो जाती है। हम थोड़ी देर बाद इंटरफेस के बारे में बात करेंगे, लेकिन अभी के लिए विरासत का पता लगाना जारी रखें।