ओवरराइडिंग विधि

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

एडीए
एडीए (प्रोग्रामिंग भाषा) डिफ़ॉल्ट रूप से ओवरराइडिंग पद्धति प्रदान करती है। प्रारम्भिक त्रुटि का पता लगाने के पक्ष में (उदाहरण के लिए एक गलत वर्तनी), यह निर्दिष्ट करना संभव है कि किस पद्धति के वास्तव में ओवरराइडिंग होने की अपेक्षा है, या नहीं। वह संकलक द्वारा जाँच की जाएगी। type T is new Controlled with ......; procedure Op(Obj: in out T; Data: in Integer); type NT is new T with null record; overriding   -- overriding indicator procedure Op(Obj: in out NT; Data: in Integer); overriding   -- overriding indicator procedure Op(Obj: in out NT; Data: in String); -- ^ compiler issues an error: subprogram "Op" is not overriding

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

abstract class Animal

{    public          string Name { get; set; } // Methods public         void   Drink; public virtual void   Eat; public         void   Go; } class Cat : Animal {    public new      string Name { get; set; } // Methods public         void   Drink;  // Warning: hides inherited drink. Use new public override void  Eat;    // Overrides inherited eat. public new     void   Go;     // Hides inherited go. }

एक पद्धति को दूसरे के साथ ओवरराइड करते समय, दो पद्धतियों का प्रारूप संकेत समान होना चाहिए (और समान दृश्यता के साथ)। C # में, क्लास पद्धतियों, अनुक्रमणिका (प्रोग्रामिंग), गुण (प्रोग्रामिंग) और घटनाओं को ओवरराइड किया जा सकता है।

गैर-आभासी या स्थिर पद्धतियों को ओवरराइड नहीं किया जा सकता है। ओवरराइड की गई मूल पद्धति आभासी, अमूर्त या ओवरराइड होनी चाहिए।

पद्धति ओवरराइडिंग के लिए उपयोग किए जाने वाले संशोधक के अतिरिक्त, C # इनहेरिटेड गुण या पद्धति के 'छिपाने' की स्वीकृति देता है। यह एक गुण या पद्धति के समान हस्ताक्षर का उपयोग करके किया जाता है लेकिन संशोधक को जोड़कर किया जाता है।

ऊपर दिए गए उदाहरण में, छिपाने के निम्न कारण होते हैं:

Cat cat = new Cat; cat.Name = …;            // accesses Cat.Name cat.Eat;               // calls Cat.Eat cat.Go;                // calls Cat.Go ((Animal)cat).Name = …;  // accesses Animal.Name! ((Animal)cat).Eat;     // calls Cat.Eat! ((Animal)cat).Go;      // calls Animal.Go!

C ++
C ++ में कीवर्ड नहीं है कि एक सबक्लास जावा में एक पद्धति के सुपरक्लास संस्करण को प्रयुक्त करने के लिए उपयोग कर सकता है जिसे वह ओवरराइड करना चाहता है। इसके अतिरिक्त, पैरेंट या बेस क्लास का नाम स्कोप रिज़ॉल्यूशन संचालक के बाद प्रयोग किया जाता है। उदाहरण के लिए, निम्न कोड दो क्लास (कंप्यूटर विज्ञान), बेस क्लास, और व्युत्पन्न क्लास  प्रस्तुत करता है   क्लास के  पद्धति ओवरराइड करता है ताकि इसकी ऊंचाई को भी प्रिंट किया जा सके। //--- class Rectangle { public: Rectangle(double l, double w) : length_(l), width_(w) {} virtual void Print const; private: double length_; double width_; }; //--- void Rectangle::Print const { // Print method of base class. std::cout << "Length = " << length_ << "; Width = " << width_; } //--- class Box : public Rectangle { public: Box(double l, double w, double h) : Rectangle(l, w), height_(h) {} void Print const override; private: double height_; }; //--- // Print method of derived class. void Box::Print const { // Invoke parent Print method. Rectangle::Print; std::cout << "; Height = " << height_; }
 * 1) include

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

निम्नलिखित कथन (प्रोग्रामिंग) और  वस्तु (कंप्यूटर विज्ञान) प्रकार की वस्तुओं का होगा और उनके संबंधित  पद्धतियों को कॉल करेंगे:

int main(int argc, char** argv) { Rectangle rectangle(5.0, 3.0); // Outputs: Length = 5.0; Width = 3.0 rectangle.Print; Box box(6.0, 5.0, 4.0); // The pointer to the most overridden method in the vtable in on Box::print, // but this call does not illustrate overriding. box.Print; // This call illustrates overriding. // outputs: Length = 6.0; Width = 5.0; Height= 4.0 static_cast(box).Print; } C++11 में, जावा के समान, सुपर क्लास में  घोषित की गई पद्धति को ओवरराइड नहीं किया जा सकता है; साथ ही, एक पद्धति को ओवरराइड घोषित किया जा सकता है ताकि संकलक अवलोकन कर सके कि यह बेस क्लास में पद्धति को ओवरराइड करता है।

डेल्फी
डेल्फी (प्रोग्रामिंग भाषा) में, प्रणाली ओवरराइडिंग निर्देशित ओवरराइड के साथ की जाती है, लेकिन केवल तभी जब किसी प्रणाली को गतिशील या आभासी निर्देश के साथ चिह्नित किया गया हो।

जब आप सुपर-क्लास गतिपद्धति को कॉल करना चाहते हैं तो इनहेरिट किए गए आरक्षित शब्द को कॉल किया जाना चाहिए।

type TRectangle = class private FLength: Double; FWidth: Double; public property Length read FLength write FLength; property Width read FWidth write FWidth; procedure Print; virtual; end; TBox = class(TRectangle) public procedure Print; override; end;

एफिल
एफिल (प्रोग्रामिंग भाषा) में, वेरिएबल (विशेषता) पुनर्परिभाषा C++ और जावा में ओवरराइडिंग पद्धति के अनुरूप है। पुनर्वितरण पुनर्वितरण के रूप में वर्गीकृत सुविधा अनुकूलन के तीन रूपों में से एक है। पुनर्घोषणा में प्रभावकारी भी सम्मिलित है, जिसमें एक विशेषता के लिए एक कार्यान्वयन प्रदान किया जाता है जो बेस क्लास में स्थगित (अमूर्त) था, और अपरिभाषित, जिसमें एक विशेषता जो मूल में प्रभावी (मूर्त) थी, एर क्लास में पुनः स्थगित हो जाती है। जब किसी वेरिएबल को पुनः परिभाषित किया जाता है, तो वेरिएबल का नाम एर क्लास द्वारा रखा जाता है, लेकिन वेरिएबल के गुण जैसे कि इसके हस्ताक्षर, अनुबंध (पूर्व शर्त और शर्त के लिए प्रतिबंधों का सम्मान), और/या कार्यान्वयन एर में अलग होंगे। यदि बेस क्लास में मूल विशेषता, जिसे एर वेरिएबल का प्रीकर्सर प्रभावी है, तो एर में पुनर्परिभाषित विशेषता प्रभावी होगी। यदि पूर्ववर्ती को स्थगित कर दिया गया है, तो एर में विशेषता को स्थगित कर दिया जाएगा।

वेरिएबल को पुनः परिभाषित करने के विचार मे, नीचे दिए गए उदाहरण में के रूप में, स्पष्ट रूप से एर क्लास  वेरिएबल में घोषित किया जाना चाहिए। class THOUGHT feature message -- Display thought message do            print ("I feel like I am diagonally parked in a parallel universe.%N") end end class ADVICE inherit THOUGHT redefine message end feature message -- Precursor do            print ("Warning: Dates in calendar are closer than they appear.%N") end end

क्लास में विशेषता  कार्यान्वयन दिया जाता है जो क्लास  में इसके प्रीकर्सर से भिन्न होता है

क्लास पर विचार करें जो और  दोनों के लिए उदाहरणों का उपयोग करता है:

class APPLICATION create make feature make -- Run application. do            (create {THOUGHT}).message; (create {ADVICE}).message end end

जब तत्काल, क्लास निम्नलिखित आउटपुट उत्पन्न करता है: I feel like I am diagonally parked in a parallel universe. Warning: Dates in calendar are closer than they appear. एक पुनर्परिभाषित सुविधा के अंदर, भाषा कीवर्ड का उपयोग करके सुविधा के प्रीकर्सर तक अभिगम्य प्राप्त की जा सकती है,  के कार्यान्वयन पर विचार करें निम्नानुसार परिवर्तित किया जाता है:

message -- Precursor do            print ("Warning: Dates in calendar are closer than they appear.%N") Precursor end

सुविधा के अनुरोध में का निष्पादन सम्मिलित है, और निम्न आउटपुट उत्पन्न करता है: Warning: Dates in calendar are closer than they appear. I feel like I am diagonally parked in a parallel universe.

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

public void message { System.out.println("I feel like I am diagonally parked in a parallel universe."); } } public class Advice extends Thought { @Override // @Override annotation in Java 5 is optional but helpful. public void message { System.out.println("Warning: Dates in calendar are closer than they appear."); }

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

Thought parking = new Thought; parking.message; // Prints "I feel like I am diagonally parked in a parallel universe." Thought dates = new Advice; // Polymorphism dates.message; // Prints "Warning: Dates in calendar are closer than they appear." संदर्भ हो सकता है public class Advice extends Thought { @Override public void message { System.out.println("Warning: Dates in calendar are closer than they appear."); super.message; // Invoke parent's version of method.

ऐसी पद्धतियाँ हैं जो सबक्लास ओवरराइड नहीं कर सकते हैं। उदाहरण के लिए, जावा में, सुपर क्लास में अंतिम घोषित की गई पद्धति को ओवरराइड नहीं किया जा सकता है। जिन तरीकों को निजी या स्थिर घोषित किया गया है, उन्हें ओवरराइड नहीं किया जा सकता क्योंकि वे पूरी तरह से अंतिम हैं। एक क्लास के लिए यह भी असंभव है कि सुपर क्लास बनने के लिए अंतिम घोषित किया जाए।

कोटलिन
कोटलिन (प्रोग्रामिंग भाषा) में हम इस तरह से एक फ़ंक्शन को ओवरराइड कर सकते हैं (ध्यान दें कि फ़ंक्शन होना चाहिए):

fun main {

val p = Parent(5) val c = Child(6) p.myFun c.myFun } open class Parent(val a : Int) { open fun myFun = println(a) } class Child(val b : Int) : Parent(b) { override fun myFun = println("overrided method") }

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

उदाहरण: class Thought:

def __init__(self) -> None: print("I'm a new object of type Thought!") def message(self) -> None: print("I feel like I am diagonally parked in a parallel universe.") class Advice(Thought): def __init__(self) -> None: super(Advice, self).__init__ def message(self) -> None: print("Warning: Dates in calendar are closer than they appear") super(Advice, self).message t = Thought t.message a = Advice a.message # -- isinstance(t, Thought) isinstance(a, Advice) isinstance(a, Thought)
 * 1) "I'm a new object of type Thought!"
 * 1) "I feel like I am diagonally parked in a parallel universe.
 * 1) "I'm a new object of type Thought!"
 * 1) "Warning: Dates in calendar are closer than they appear"
 * 2) "I feel like I am diagonally parked in a parallel universe.
 * 1) Introspection:
 * 1) True
 * 1) True
 * 1) True

isinstance(a, Advice)
 * 1) True

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

उदाहरण:

class Thought def message puts "I feel like I am diagonally parked in a parallel universe." end end class Advice < Thought alias :super_message :message def message puts "Warning: Dates in calendar are closer than they appear" super end end

यह भी देखें

 * कार्यान्वयन विरासत
 * वंशानुक्रम शब्दार्थ
 * पद्धति अधिभार
 * वस्तु-उन्मुख प्रोग्रामिंग में बहुरूपता
 * टेम्पलेट पद्धति पैटर्न
 * आभासी विरासत
 * एचटीटीपी हेडर फ़ील्ड की सूची#सामान्य गैर-मानक अनुरोध फ़ील्ड|X-HTTP-Method-Override HTTP हैडर

संदर्भ

 * Deitel, H. M & Deitel, P. J.(2001). Java How to Program (4th ed.). Upper Saddle River, NJ: Prentice Hall.
 * Lewis, J. & Loftus, W. (2008). Java: Software Solutions (6th ed.). Boston, MA: Pearson Addison Wesley.
 * Malik, D. S.(2006). C++ Programming: Program Design Including Data Structure. (3rd ed.). Washington, DC: Course Technology.
 * Flanagan, David.(2002).Java in a Nutshell.Retrieved from http://oreilly.com/catalog/9780596002831/preview#preview
 * Meyer, Bertrand (2009). Touch of Class: Learning to Program Well with Objects and Contracts. Springer.

बाहरी संबंध

 * Introduction to O.O.P. Concepts and More by Nirosh L.w.C.
 * Overriding and Hiding Methods by Sun Microsystems