वारसा. वारसाचे फायदे

"हॅलो, अमिगो! आता येथे एक विषय आहे जो मला वाटते की तुम्ही खूप वापराल. मी वारसा बद्दल बोलत आहे. "

असुरक्षितांसाठी, प्रोग्रामिंग जादूसारखे आहे. तर मी एका साधर्म्याने सुरुवात करतो...

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

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

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

1) तुम्हाला सापडलेला वर्ग कदाचित आधीच bytecode मध्ये संकलित केलेला असेल. तुम्हाला कदाचित त्याच्या स्रोत कोडमध्ये प्रवेश नसेल.

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

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

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

"खूप मनोरंजक. कृपया पुढे जा."

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

"जसे अॅब्स्ट्रॅक्शनचे फायदे केवळ एन्कॅप्सुलेशनच्या संबंधात खरोखरच प्रकट होतात, त्याचप्रमाणे वारशाचे फायदे बहुरूपतेने वाढवले ​​जातात. पण मी तुम्हाला उद्या त्याबद्दल सांगेन. आज वारशाची काही उदाहरणे पाहू या."

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

"राजा, राणी, बिशप, नाइट, रुक आणि प्यादा."

"खूप छान. तुझी एकही गोष्ट चुकली नाही."

"आणि तुम्ही या वर्गांमध्ये कोणता डेटा संग्रहित करण्याचा सल्ला द्याल?"

"प्रत्येक तुकड्याचे बोर्डचे स्थान (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
}
}

"किती मनोरंजक!"

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

"मग तुम्हाला वर्गाचा वारसा घेण्यासाठी काय करावे लागेल?"

"वर्ग घोषित केल्यानंतर, आम्ही ' extensions ' हा कीवर्ड वापरतो, त्यानंतर पालक वर्गाचे नाव. तुम्ही फक्त एका वर्गाकडून वारसा मिळवू शकता. "

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

"पण मला दोन वर्गातून वारसा हवा असेल तर? मी काही करू शकतो का?!"

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

"मी बघतो. आणि इंटरफेस म्हणजे काय?"

"मी तुम्हाला उद्या इंटरफेसबद्दल सांगेन. आत्तासाठी, वारसा शोधत राहू या."