मेन्यू

ओवरराइडिंग पूर्वनिर्धारित तरीके जावा में

  • मुख्य
  • अन्य
  • ओवरराइडिंग पूर्वनिर्धारित तरीके जावा में

overriding predefined methods java

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

यह ट्यूटोरियल बताता है कि जावा में पूर्वनिर्धारित विधियों जैसे कि बराबर (), हैशकोड (), ComparTo (), आदि उदाहरणों के साथ ओवरराइड कैसे करें:

हमारे पिछले ट्यूटोरियल में, हमने जावा में रनटाइम पॉलिमॉर्फिज्म पर चर्चा की। जावा में रनटाइम पॉलिमोर्फ़िज्म को ओवरराइडिंग पद्धति का उपयोग करके लागू किया जाता है। ओवरराइडिंग की विधि में उपवर्ग में मूल वर्ग विधि को फिर से परिभाषित करना शामिल है।

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

=> स्क्रैच से जावा सीखने के लिए यहां जाएं।

जावा में पूर्वनिर्धारित तरीकों को ओवरराइड करना

इस ट्यूटोरियल में, हम परिणामों के साथ इन सभी तरीकों के ओवरराइडिंग पर चर्चा करेंगे यदि हम इन तरीकों को ओवरराइड नहीं करते हैं।

आप क्या सीखेंगे:

ओवरराइडिंग बराबर () और हैशकोड () जावा में तरीके

हम दो वस्तुओं की तुलना करने के लिए जावा में बराबर () पद्धति का उपयोग करते हैं। जब ऑब्जेक्ट बराबर नहीं होते हैं और झूठे होते हैं तो यह तरीका सही होता है।

दो वस्तुओं की समानता की तुलना करने के लिए दो तरीकों का उपयोग किया जाता है।

(1) उथला तुलना

उथला तुलना 'java.lang.Object' वर्ग में परिभाषित बराबरी () पद्धति के लिए डिफ़ॉल्ट कार्यान्वयन है। इस कार्यान्वयन के एक हिस्से के रूप में, समान वस्तु () विधि की जांच करेगी कि क्या दो वस्तुओं की तुलना एक ही वस्तु के संदर्भ में की जा रही है।

इसका मतलब यह है कि अगर obj1 और obj2 दो ऑब्जेक्ट हैं, तो समतुल्य () विधि (उथले तुलना) का डिफ़ॉल्ट कार्यान्वयन केवल तभी जांच करेगा कि obj1 और obj2 के संदर्भ एक ही ऑब्जेक्ट से हैं।

उथले तुलना में, कोई डेटा सामग्री की तुलना नहीं की जाती है।

# 2) गहरी तुलना

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

गहरी तुलना का उपयोग करते हुए वस्तुओं की तुलना करने के लिए हम आमतौर पर बराबर () विधि को ओवरराइड करते हैं।

अब निम्नलिखित जावा प्रोग्राम पर विचार करें।

class Complex { private double r, i; //declare real and imaginary component as private public Complex(double r, double i) { //constructor this.r = r; this.i = i; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(5, 10); //c1 object Complex c2 = new Complex(5, 10); //c2 object if (c1 == c2) { System.out.println('Two Complex objects are Equal '); } else { System.out.println('Two Complex objects are not Equal '); } } }

आउटपुट:

ओवरराइडिंग बराबर - आउटपुट

यदि हम उपरोक्त कार्यक्रम के आउटपुट को देखते हैं, तो यह कहता है कि वस्तुएं समान नहीं हैं, भले ही दो वस्तुओं की सामग्री समान हो। ऐसा इसलिए है, क्योंकि जब समानता की जांच की जाती है, तो यह निर्धारित किया जाता है कि क्या दो ऑब्जेक्ट्स c1 और c2 एक ही ऑब्जेक्ट को संदर्भित करते हैं।

जैसा कि कार्यक्रम में देखा गया है c1 और c2 दो अलग-अलग वस्तुएं हैं, इसलिए वे अलग-अलग संदर्भ हैं और इस प्रकार परिणाम होता है।

अब तीसरे संदर्भ c3 को बनाते हैं और इसे निम्नानुसार c1 के समान बनाते हैं:

कॉम्प्लेक्स सी 3 = सी 1;

इस स्थिति में, c3 और c1 एक ही ऑब्जेक्ट को संदर्भित करेंगे, और इसलिए (c3 == c1) सही लौटेगा।

उपरोक्त कार्यक्रम ने जो किया वह उथली तुलना थी। तो हम कैसे जांचें कि क्या दो वस्तुएं एक ही सामग्री-वार हैं?

यहां, हम एक गहरी तुलना के लिए जाते हैं, और इस उद्देश्य के लिए, हम बराबर () विधि को ओवरराइड करते हैं।

निम्न प्रोग्राम बराबरी () विधि के ओवरराइडिंग को दर्शाता है। हम उसी कॉम्प्लेक्स क्लास का उपयोग करते हैं।

class Complex { private double r, i; public Complex(double r, double i) { this.r = r; this.i = i; } // override equals () method to compare two complex objects @Override public boolean equals(Object obj) { // returns true=>object is compared to itself if (obj == this) { return true; } //return false if obj is not an instance of Complex class if (!(obj instanceof Complex)) { return false; } // typecast obj to Complex type Complex c = (Complex) obj; // Compare the contents of two objects and return value return Double.compare(r, c.r) == 0 && Double.compare(i, c.i) == 0; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(5, 10); Complex c2 = new Complex(5, 10); if (c1.equals(c2)) { System.out.println('Complex objects c1 and c2 are Equal '); } else { System.out.println('Complex objects c1 and c2 are not Equal '); } } }

आउटपुट:

आउटपुट - ओवरराइडिंग

etl परीक्षण साक्षात्कार प्रश्न और अनुभवी के लिए उत्तर

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

जावा में, जब भी हम समतुल्य () विधि को ओवरराइड करते हैं, तो हैशकोड () विधि को भी ओवरराइड करने की सलाह दी जाती है। ऐसा इसलिए है क्योंकि अगर हम हैशकोड () विधि को ओवरराइड नहीं करते हैं, तो प्रत्येक ऑब्जेक्ट में अलग-अलग हैशकोड हो सकते हैं।

यह सामान्य वस्तुओं के साथ हस्तक्षेप नहीं कर सकता है, लेकिन हैशटेबल, हैशसेट और हैशपॉप जैसे कुछ हैश-आधारित संग्रह ठीक से काम नहीं कर सकते हैं।

निम्न प्रोग्राम बराबरी () और हैशकोड () तरीके को ओवरराइड करता है।

import java.io.*; import java.util.*; class EqualsHashCode { String name; int id; EqualsHashCode(String name, int id) { this.name = name; this.id = id; } @Override public boolean equals(Object obj) @Override public int hashCode() { // return current object's id as hashCode return this.id; } } class Main { public static void main (String() args) { // create two objects with same state EqualsHashCode e1 = new EqualsHashCode('Java', 1); EqualsHashCode e2 = new EqualsHashCode('Java', 1); //update the objects Map map = new HashMap(); map.put(e1, 'C++'); map.put(e2, 'Python'); //display contents for(EqualsHashCode eh : map.keySet()) { System.out.println(map.get(eh).toString()); } } }

आउटपुट:

हश्माप - आउटपुट

इस कार्यक्रम में, हम एक हैश मैप का उपयोग करते हैं। हमने दोनों बराबर () और हैशकोड () विधियों को ओवरराइड किया है। इसलिए जब हम map.put (e1, 'C ++') कहते हैं, तो यह कुछ बाल्टी स्थान पर हैश करता है। अगला, हम एक map.put (e2, 'पायथन') कहते हैं। इस बार यह उसी बाल्टी को हैश करेगा और पिछले मूल्य को बदल देगा। ऐसा इसलिए है क्योंकि हमने हैशकोड () पद्धति को ओवरराइड कर दिया है।

जावा में ओवरराइडिंग स्टेटिक विधि

क्या हम जावा में स्थिर विधि को ओवरराइड कर सकते हैं?

जहाँ तक जावा में स्थिर विधि को ओवरराइड करने की बात है, इस सवाल का सीधा जवाब है, हम स्थैतिक विधि को ओवरराइड नहीं कर सकते।

स्थिर विधि को क्लास नाम से ही प्रयोग किया जाता है। हमें स्थैतिक विधि को कॉल करने के लिए किसी ऑब्जेक्ट की आवश्यकता नहीं है। इसलिए भले ही हम एक उपवर्ग में एक ही प्रोटोटाइप के साथ एक विधि घोषित करें, हम इसे ओवरराइडिंग नहीं कह सकते। इसके बजाय, हम स्थैतिक विधि की मूल श्रेणी परिभाषा को छिपा रहे हैं।

निम्न जावा प्रोग्राम रनटाइम पर उनके व्यवहार के साथ एक विरासत प्रणाली में स्थिर विधि और गैर-स्थैतिक विधि को दर्शाता है।

class Parent { // Parent class static method cannot be overridden by Child public static void display() { System.out.println('Parent class::static display()'); } // parent class non-static print method to be overridden by Child public void print() { System.out.println('Parent class::non-static print()'); } } // Subclass class Child extends Parent { // static display() method =>hides display() in Parent class public static void display() { System.out.println('Child class:: static display()'); } //overrides print() in Parent class public void print() { System.out.println('Child class::Non-static print()'); } } public class Main { public static void main(String args( )) { Parent new_obj = new Child(); // static methods are call as per the reference type. Since reference type //Parent, this call will execute Parent class's display method new_obj.display(); // here the print () method of Child class is called new_obj.print(); } }

आउटपुट:

स्थैतिक विधि को ओवरराइड करें

प्रोग्राम आउटपुट से, हम निम्नलिखित निष्कर्ष निकाल सकते हैं।

  1. स्थैतिक विधि के लिए कॉल हमेशा संदर्भ के प्रकार के आधार पर किया जाता है। इसलिए जब हम new_obj कहते हैं। प्रदर्शन () उपरोक्त कार्यक्रम में, जैसा कि new_obj संदर्भ प्रकार श्रेणी पैरेंट का है, प्रदर्शन () विधि पैरेंट वर्ग को कहा जाता है।
  2. दूसरी ओर, गैर-स्थैतिक तरीकों को संदर्भ वस्तु की सामग्री के आधार पर कहा जाता है जिसके साथ विधि कहा जाता है। इसलिए उपरोक्त प्रोग्राम में new_obj.print () मेथड में चाइल्ड क्लास की प्रिंट () विधि को कॉल किया जाता है क्योंकि new_obj कंटेंट चाइल्ड क्लास का ऑब्जेक्ट हैं।

यह ऊपर दिए गए कार्यक्रम के आउटपुट की व्याख्या करता है और हमें OOP प्रणाली में स्थिर तरीकों से निपटने के साथ-साथ निम्नलिखित बिंदुओं को भी याद रखना चाहिए।

  • एक स्थिर विधि एक गैर-स्थैतिक आवृत्ति विधि को छिपा नहीं सकती है और एक गैर-स्थैतिक आवृत्ति विधि किसी स्थिर विधि को ओवरराइड नहीं कर सकती है।
  • हम उपवर्ग में पैरेंट क्लास से तरीकों को ओवरलोड कर सकते हैं लेकिन वे न तो ओवरराइड करते हैं और न ही पैरेंट क्लास के तरीकों को छिपाते हैं, बल्कि वे सबक्लास में नए तरीके हैं।

ओवरराइडिंग तुलना () जावा में

हम जानते हैं कि इंटरफ़ेस java.lang.Comparable एक o ComparTo () विधि प्रदान करता है, जिसके उपयोग से हम वस्तुओं को एक प्राकृतिक क्रम में क्रमबद्ध कर सकते हैं जैसे स्ट्रिंग वस्तुओं के लिए शाब्दिक क्रम, पूर्णांक के लिए संख्यात्मक क्रम, आदि।

उपयोगकर्ता-परिभाषित ऑब्जेक्ट या संग्रह में सॉर्टिंग को लागू करने के लिए, हमें संग्रह तत्वों या उपयोगकर्ता-परिभाषित ऑब्जेक्ट को सॉर्ट करने के लिए तुलना () विधि को ओवरराइड करना होगा।

तो एक तुलना () विधि क्या करती है?

यदि किसी ऑब्जेक्ट को ऑर्डर में पास की गई वस्तु से अधिक और करंट ऑब्जेक्ट की निगेटिव वैल्यू गुजरे ऑब्जेक्ट की तुलना में कम है, तो एक तुलना () विधि को पॉजिटिव वैल्यू लौटानी चाहिए। यदि दोनों ऑब्जेक्ट समान हैं, तो तुलना () विधि शून्य वापस आ जाएगी।

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

एक जावा प्रोग्राम लागू करें जो तुलना () विधि से आगे निकल जाए। इस कार्यक्रम में, हम एक कलर क्लास का उपयोग कर रहे हैं, जिसमें दो निजी चर हैं, जैसे नाम और आईडी। हमने प्रत्येक रंग के साथ 'आईडी' को जोड़ा है और हम आईडी के अनुसार रंगों की व्यवस्था करने के लिए तुलना () विधि को ओवरराइड करेंगे।

import java.util.*; //color class class Color implements Comparator, Comparable { private String name; private int id; Color() { } Color(String n, int id) { this.name = n; this.id = id; } public String getColorName() { return this.name; } public int getColorId() { return this.id; } // Overriding the compareTo method @Override public int compareTo(Color c) { return (this.name).compareTo(c.name); } // Overriding the compare method to sort the colors on id @Override public int compare(Color c, Color c1) { return c.id - c1.id; } } public class Main { public static void main(String args()) { // List of Colors List list = new ArrayList(); list.add(new Color('Red', 3)); list.add(new Color('Green', 2)); list.add(new Color('Blue', 5)); list.add(new Color('Orange', 4)); list.add(new Color('Yellow', 1)); Collections.sort(list); // Sorts the array list System.out.println('The list of colors:'); for(Color c: list) // print the sorted list of colors System.out.print(c.getColorName() + ', '); // Sort the array list using comparator Collections.sort(list, new Color()); System.out.println(' '); System.out.println('The sorted list of colors:'); for(Color c: list) // print the sorted list of colors as per id System.out.print(c.getColorId() + ':' + c.getColorName() + ' , '); }

आउटपुट:

ओवरराइडिंग तुलना

उपरोक्त आउटपुट में, हम पहले रंगों की सूची और फिर रंगों की क्रमबद्ध सूची प्रदर्शित करते हैं। कार्यक्रम में, हमने तुलना () और तुलना () विधियों को ओवरराइड किया है।

ओवरराइड स्ट्रिंग () जावा में विधि

विधि method toString () 'जावा में किसी ऑब्जेक्ट के स्ट्रिंग प्रतिनिधित्व को लौटाता है। लेकिन जब हमारे पास उपयोगकर्ता-परिभाषित ऑब्जेक्ट होते हैं, तो यह विधि अलग तरीके से व्यवहार कर सकती है।

उदाहरण के लिए,निम्नलिखित कार्यक्रम पर विचार करें।

class Complex { private double r, i; public Complex(double r, double i) { this.r = r; this.i = i; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(5, 20); //create complex class Object //print the contents of complex number System.out.println('Complex number contents: ' + c1); } }

आउटपुट:

ओवरराइड करना

जैसा कि इस कार्यक्रम में दिखाया गया है हम कॉम्प्लेक्स क्लास ऑब्जेक्ट प्रदर्शित कर रहे हैं जिसे हमने पहले परिभाषित किया है। हालाँकि, दिखाया गया आउटपुट सामग्री नहीं है, बल्कि यह गूढ़ है।

आउटपुट एक वर्ग नाम दिखाता है, जिसके बाद shows @ 'वर्ण और फिर ऑब्जेक्ट का हैशकोड होता है। यह ऑब्जेक्ट क्लास के स्ट्रींग () विधि द्वारा मुद्रित डिफ़ॉल्ट आउटपुट है।

यदि हम उचित आउटपुट चाहते हैं, तो हमें अपने आवेदन में स्ट्रोस्ट्रिंग () विधि को ओवरराइड करना होगा।

निम्न जावा प्रोग्राम दिखाता है कि कॉम्प्लेक्स ऑब्जेक्ट की सामग्री को प्रिंट करने के लिए स्ट्रैस्ट्रिंग () पद्धति को ओवरराइड कैसे करें।

class Complex { private double r, i; public Complex(double r, double i) { this.r = r; this.i = i; } //override toString () method to return String representation of complex number @Override public String toString() { return String.format(r + ' + i ' + i); } } public class Main { public static void main(String() args) { Complex c1 = new Complex(10, 15); System.out.println('Complex Number contents: ' + c1); } }

आउटपुट:

जटिल परियोजना

उपरोक्त कार्यक्रम से पता चलता है कि दिए गए प्रारूप (वास्तविक + i * काल्पनिक) में जटिल ऑब्जेक्ट की सामग्री को वापस करने के लिए toString () विधि ओवरराइड की गई है।

सामान्य तौर पर, जब हम प्रिंट () या प्रिंटलाइन () का उपयोग करके क्लास ऑब्जेक्ट को प्रदर्शित करना चाहते हैं, तब हमेशा स्ट्रीडिंग () विधि को ओवरराइड करने की सलाह दी जाती है ताकि हमें उचित आउटपुट मिले।

बार बार पूछे जाने वाले प्रश्न

Q # 1) == जावा के बजाय .equals का उपयोग क्यों करें?

उत्तर: हम आदिम प्रकारों जैसे कि इंट, चार, बूलियन, आदि की तुलना करने के लिए like == का उपयोग करते हैं। हम वस्तुओं (पूर्वनिर्धारित या उपयोगकर्ता द्वारा परिभाषित) की तुलना करने के लिए बराबर () का उपयोग करते हैं। हम आम तौर पर दो वस्तुओं की तुलना करने के लिए बराबरी () विधि को ओवरराइड करते हैं और बराबरी का रिटर्न मान () ओवरराइड कोड पर निर्भर करता है।

Q # 2) हैशकोड () और समतुल्य () किसके लिए उपयोग किया जाता है?

उत्तर: जावा में, दो वस्तुओं की समानता की तुलना करने के लिए बराबर () विधि का उपयोग किया जाता है। हैशकोड () विधि ऑब्जेक्ट का हैशकोड लौटाती है। जबकि समतुल्य () पद्धति का उपयोग अधिकांश वस्तुओं के साथ उनकी समानता का परीक्षण करने के लिए किया जाता है, हैशकोड का उपयोग ज्यादातर हैशटेबल, हैशपॉप, हैशसेट, आदि जैसे हैश संग्रह में किया जाता है।

Q # 3) क्या हम ओवरराइड विधि की तर्क सूची बदल सकते हैं?

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

क्यू # 4) हम स्ट्रींग () से क्यों आगे निकल जाते हैं?

उत्तर: जब toString () विधि को ओवरराइड किया जाता है, तो हम उस ऑब्जेक्ट के मूल्यों को वापस कर सकते हैं जिसके लिए बहुत अधिक कोड लिखे बिना toString () विधि को ओवरराइड किया जाता है। जब हम किसी ऑब्जेक्ट को प्रिंट करते हैं तो java कंपाइलर toString () विधि को लागू करता है।

क्यू # 5) क्या होगा यदि आप स्ट्रीटिंग () विधि को ओवरराइड नहीं करेंगे?

उत्तर: यदि हम toString () पद्धति को ओवरराइड नहीं करते हैं, तो हमें ऑब्जेक्ट के गुणों या स्थिति के बारे में कोई जानकारी नहीं मिलेगी। हमें नहीं पता होगा कि वास्तव में वस्तु के अंदर क्या है। इसलिए सभी वर्गों को स्ट्रीस्टिंग () पद्धति को ओवरराइड करना चाहिए।

इसका कारण यह है कि StString () पद्धति का डिफ़ॉल्ट कार्यान्वयन स्ट्रिंग प्रतिनिधित्व प्रदर्शित करता है लेकिन जब हम ऑब्जेक्ट पर डिफ़ॉल्ट toString () कार्यान्वयन का उपयोग करते हैं तो हमें ऑब्जेक्ट की सामग्री नहीं मिलेगी।

निष्कर्ष

इस ट्यूटोरियल में, हमने कुछ पूर्वनिर्धारित जावा विधियों को ओवरराइड करने पर चर्चा की और हमने यह भी देखा कि हमें उन्हें ओवरराइड करने की आवश्यकता क्यों है।

जब हम वस्तुओं के साथ व्यवहार करते हैं, तो समतुल्य (), तुलना (), और स्ट्रिंग () जैसी विधियों का डिफ़ॉल्ट कार्यान्वयन सही जानकारी नहीं दे सकता है। इसलिए हम ओवरराइडिंग के लिए जाते हैं।

=> यहाँ जावा शुरुआती गाइड पर एक नज़र रखना।

अनुशंसित पाठ

^