वारसा

1. पेगासस

OOP चे तिसरे तत्व सखोलपणे पाहू : वारसा . हा एक अतिशय मनोरंजक विषय आहे जो तुम्ही अनेकदा वापराल. असुरक्षित लोकांसाठी, प्रोग्रामिंग जादूपासून वेगळे करता येत नाही. चला तर मग एका मनोरंजक साधर्म्याने सुरुवात करूया...;

समजा तुम्ही एक विझार्ड आहात ज्याला उडणारा घोडा तयार करायचा आहे. एकीकडे, तुम्ही पेगाससचे जादू करण्याचा प्रयत्न करू शकता. परंतु निसर्गात पेगासी अस्तित्वात नसल्यामुळे हे खूप कठीण होईल. तुम्हाला स्वतःला खूप काही करावे लागेल. घोडा घेणे आणि त्याचे पंख लावणे खूप सोपे आहे.

प्रोग्रामिंगमध्ये, या प्रक्रियेला "वारसा" म्हणतात. समजा तुम्हाला खूप क्लिष्ट क्लास लिहायचा आहे. सुरवातीपासून कोड लिहिण्यासाठी बराच वेळ लागतो आणि नंतर त्रुटी शोधण्यासाठी बर्याच काळासाठी सर्वकाही तपासण्यासाठी. कठीण मार्गाने का जावे? असा वर्ग आधीच अस्तित्वात आहे की नाही हे पाहणे चांगले.

समजा तुम्हाला एक वर्ग सापडला आहे ज्याच्या पद्धती तुम्हाला आवश्यक असलेल्या 80% कार्यक्षमतेची अंमलबजावणी करतात. त्याचे पुढे काय करायचे? तुम्ही त्याचा कोड तुमच्या वर्गात कॉपी करू शकता. परंतु या सोल्यूशनमध्ये अनेक तोटे आहेत:

1. तुम्‍हाला आढळलेला वर्ग कदाचित आधीच बायकोडमध्‍ये संकलित केलेला असू शकतो आणि तुम्‍हाला कदाचित त्‍याच्‍या सोर्स कोडमध्‍ये प्रवेश नसेल.
2. वर्गाचा सोर्स कोड उपलब्ध आहे, परंतु तुम्ही अशा कंपनीसाठी काम करता जिच्यावर दुसर्‍याच्या कोडच्या अगदी 6 ओळी वापरल्याबद्दल काही अब्जांचा खटला भरला जाऊ शकतो. आणि मग तुमचा नियोक्ता तुमच्यावर खटला भरेल.
3. मोठ्या प्रमाणात कोडची अनावश्यक डुप्लिकेशन. याव्यतिरिक्त, जर बाह्य वर्गाच्या लेखकाला त्यात बग सापडला आणि त्याचे निराकरण केले, तरीही तुमच्याकडे बग असेल.

एक अधिक मोहक उपाय आहे, आणि त्याला मूळ वर्गाच्या कोडमध्ये कायदेशीर प्रवेश मिळण्याची आवश्यकता नाही. Java मध्ये, तुम्ही त्या वर्गाला तुमच्या वर्गाचे पालक म्हणून घोषित करू शकता. ते तुमच्या स्वतःच्या कोडमध्ये त्या वर्गासाठी कोड जोडण्यासारखे असेल. तुमचा वर्ग सर्व डेटा आणि पालक वर्गाच्या सर्व पद्धती पाहतील. उदाहरणार्थ, आपण हे करू शकता: आम्हाला "घोडा" वारसा मिळतो आणि नंतर "पेगासस" मिळविण्यासाठी "पंख" जोडतो.

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

डिसेंडंट क्लास घोषित करताना तुम्हाला हेच लिहावे लागेल. तसे, एक वर्ग फक्त एक वर्ग वारसा घेऊ शकतो.

चित्रात, आपण पाहतो की एका गायीला डुक्कराचा वारसा मिळाला आहे, ज्याला कोंबडीचा वारसा मिळाला आहे, ज्याला अंडी वारशाने मिळाली आहे. फक्त एक पालक! असा वारसा नेहमीच तर्कसंगत नसतो. परंतु जेव्हा तुमच्याकडे फक्त डुक्कर असते आणि तुम्हाला खरोखर गायीची गरज असते, तेव्हा प्रोग्रामर अनेकदा डुक्करातून गाय बनवण्याच्या आग्रहाचा प्रतिकार करू शकत नाहीत.

Java मध्ये एकाधिक वारसा नाही: वर्ग दोन वर्गांना वारसा देऊ शकत नाही. प्रत्येक वर्गात फक्त एकच पालक वर्ग असू शकतो. जर कोणताही पालक वर्ग निर्दिष्ट केला नसेल, तर पालक वर्ग आहे Object.

ते म्हणाले, जावामध्ये इंटरफेसचा एकाधिक वारसा आहे. यामुळे समस्या थोडी कमी होते. आम्ही थोड्या वेळाने इंटरफेसबद्दल बोलू, परंतु आत्तासाठी वारसा शोधणे सुरू ठेवूया.