View source for ओवरराइडिंग विधि

{{Short description|Language feature in object-oriented programming}}
[[File:Method overriding in subclass.svg|thumb|चित्रण]][[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग|वस्तु उन्मुख प्रोग्रामिंग]] में पद्धति '''ओवरराइडिंग''', एक भाषा सुविधा है जो एक सबक्लास (कंप्यूटर विज्ञान) या चाइल्ड क्लास को एक पद्धति (कंप्यूटर विज्ञान) का एक विशिष्ट कार्यान्वयन प्रदान करने की स्वीकृति देता है जो पहले से ही इसके सुपरक्लास (कंप्यूटर विज्ञान) या पेरेंट क्लास मे से एक द्वारा प्रदान किया गया है। वर्चुअल नेटवर्क इंटरफेस में डेटा-संचालित एल्गोरिथम-निर्धारित पैरामीटर (मानदंड) प्रदान करने के अतिरिक्त,<ref>{{cite journal |last1=Zhang |first1=Jie |title=A novel P2P overridden API for open data communications in WWW |journal=2015 IEEE International Conference on Consumer Electronics-Taiwan |date=2015}}</ref> यह एक विशिष्ट प्रकार के बहुरूपता (सबटाइपिंग) की भी स्वीकृति देता है। सबक्लास में कार्यान्वयन सुपरक्लास में कार्यान्वयन को एक पद्धति प्रदान करके ओवरराइड (प्रतिस्थापित) करता है जिसमें समान नाम, समान [[पैरामीटर (कंप्यूटर विज्ञान)]] या हस्ताक्षर, और बेस क्लास में पद्धति के समान निर्वाचित प्रकार होता है।<ref name="flanagan">Flanagan 2002, p. 107</ref> निष्पादित की जाने वाली पद्धति का संस्करण उस वस्तु (कंप्यूटर विज्ञान) द्वारा निर्धारित किया जाएगा जिसका उपयोग इसे प्रयुक्त करने के लिए किया जाता है। यदि पैरेंट क्लास के किसी वस्तु का उपयोग पद्धति को प्रयुक्त करने के लिए किया जाता है, तो पैरेंट क्लास में संस्करण को निष्पादित किया जाएगा, लेकिन यदि सबक्लास के किसी वस्तु का उपयोग पद्धति को प्रयुक्त करने के लिए किया जाता है, तो चाइल्ड क्लास में संस्करण निष्पादित किया जाएगा।<ref name="lewis-loftus">Lewis & Loftus 2006, p.454</ref> यह विभेदक प्रसारण विश्लेषक से जुड़ी समस्याओं को रोकने में सहायता करता है जो अन्यथा एक रूपरेखा पर निर्भर करती हैं जिसमें पद्धति ओवरराइडिंग को कम किया जा सकता है।<ref>{{cite journal |last1=Overbey |first1=J |title=Differential precondition checking: A lightweight, reusable analysis for refactoring tools |journal=26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011) |date=2011}}</ref><ref>{{cite journal |last1=Li |first1=K |title=Residual investigation: Predictive and precise bug detection |journal=ACM Transactions on Software Engineering and Methodology (TOSEM) |date=2014 |volume=24 |issue=2}}</ref> कुछ भाषाएँ [[प्रोग्रामर]] को किसी पद्धति को ओवरराइड होने से रोकने की स्वीकृति देती हैं।

== भाषा-विशिष्ट उदाहरण ==

=== एडीए ===
[[एडा (प्रोग्रामिंग भाषा)|एडीए (प्रोग्रामिंग भाषा)]] डिफ़ॉल्ट रूप से '''ओवरराइडिंग पद्धति''' प्रदान करती है। प्रारम्भिक त्रुटि का पता लगाने के पक्ष में (उदाहरण के लिए एक गलत वर्तनी), यह निर्दिष्ट करना संभव है कि किस पद्धति के वास्तव में ओवरराइडिंग होने की अपेक्षा है, या नहीं। वह संकलक द्वारा जाँच की जाएगी।
  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 # (प्रोग्रामिंग भाषा) पद्धति ओवरराइडिंग का समर्थन करता है, लेकिन केवल यदि संशोधक {{C sharp|override}} और {{C sharp|virtual}} या {{C sharp|abstract}} का उपयोग करके स्पष्ट रूप से इंस्टेंस किया जाता है।

  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 # इनहेरिटेड गुण या पद्धति के 'छिपाने' की स्वीकृति देता है। यह एक गुण या पद्धति के समान हस्ताक्षर का उपयोग करके किया जाता है लेकिन संशोधक {{C sharp|new}} को जोड़कर किया जाता है।<ref>{{cite web
| accessdate = 2011-08-02
| date       = 2002-03-25
| first      = Hanspeter
| last       = Mössenböck
| pages       = 6–8
| publisher  = Institut für Systemsoftware, Johannes Kepler Universität Linz, Fachbereich Informatik
| title      = Advanced C#: Overriding of Methods
| quote      = 
| url        = http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/Part2.pdf}}
</ref>

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

 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 ++ में कीवर्ड {{Cpp|super}} नहीं है कि एक सबक्लास जावा में एक पद्धति के सुपरक्लास संस्करण को प्रयुक्त करने के लिए उपयोग कर सकता है जिसे वह ओवरराइड करना चाहता है। इसके अतिरिक्त, पैरेंट या बेस क्लास का नाम [[स्कोप रिज़ॉल्यूशन ऑपरेटर|स्कोप रिज़ॉल्यूशन संचालक]] के बाद प्रयोग किया जाता है। उदाहरण के लिए, निम्न कोड दो क्लास (कंप्यूटर विज्ञान), बेस क्लास {{Cpp|Rectangle}}, और व्युत्पन्न क्लास {{Cpp|Box}} प्रस्तुत करता है {{Cpp|Box}} {{Cpp|Rectangle}} क्लास के {{Cpp|Print}} पद्धति ओवरराइड करता है ताकि इसकी ऊंचाई को भी प्रिंट किया जा सके।<ref name="malik">Malik 2006, p. 676</ref>
 #include <iostream>
 
 //---------------------------------------------------------------------------
 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_;
 }



प्रक्रिया {{Cpp|Print}} क्लास में {{Cpp|Box}} पद्धति {{Cpp|Print}} के मूल संस्करण को प्रयुक्त करके बेस क्लास निजी [[चर (प्रोग्रामिंग)|वेरिएबल (प्रोग्रामिंग)]] {{Cpp|length}} और {{Cpp|width}} को आउटपुट करने में भी सक्षम है। अन्यथा, ये अस्थायी {{Cpp|Box}} के लिए अनधिगम्य है।

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

 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<Rectangle&>(box).Print();
 }
[[C++11]] में, जावा के समान, सुपर क्लास में <code>final</code> घोषित की गई पद्धति को ओवरराइड नहीं किया जा सकता है; साथ ही, एक पद्धति को ओवरराइड घोषित किया जा सकता है ताकि संकलक अवलोकन कर सके कि यह बेस क्लास में पद्धति को ओवरराइड करता है।

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

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

 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++ और जावा में ओवरराइडिंग पद्धति के अनुरूप है। पुनर्वितरण पुनर्वितरण के रूप में वर्गीकृत सुविधा अनुकूलन के तीन रूपों में से एक है। पुनर्घोषणा में प्रभावकारी भी सम्मिलित है, जिसमें एक विशेषता के लिए एक कार्यान्वयन प्रदान किया जाता है जो बेस क्लास में स्थगित (अमूर्त) था, और अपरिभाषित, जिसमें एक विशेषता जो मूल में प्रभावी (मूर्त) थी, एर क्लास में पुनः स्थगित हो जाती है। जब किसी वेरिएबल को पुनः परिभाषित किया जाता है, तो वेरिएबल का नाम एर क्लास द्वारा रखा जाता है, लेकिन वेरिएबल के गुण जैसे कि इसके हस्ताक्षर, अनुबंध (पूर्व शर्त और [[शर्त लगाना|शर्त]]  के लिए प्रतिबंधों का सम्मान), और/या कार्यान्वयन एर में अलग होंगे। यदि बेस क्लास में मूल विशेषता, जिसे एर वेरिएबल का प्रीकर्सर प्रभावी है, तो एर में पुनर्परिभाषित विशेषता प्रभावी होगी। यदि पूर्ववर्ती को स्थगित कर दिया गया है, तो एर में विशेषता को स्थगित कर दिया जाएगा।<ref name="meyer">Meyer 2009, page 572-575</ref>

वेरिएबल को पुनः परिभाषित करने के विचार मे, नीचे दिए गए उदाहरण में {{Eiffel|message}} के रूप में, स्पष्ट रूप से एर क्लास {{Eiffel|inherit}} वेरिएबल में घोषित किया जाना चाहिए।
 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



क्लास में {{Eiffel|ADVICE}} विशेषता {{Eiffel|message}} कार्यान्वयन दिया जाता है जो क्लास {{Eiffel|THOUGHT}} में इसके प्रीकर्सर से भिन्न होता है

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

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

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

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

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

=== जावा ===
[[जावा (प्रोग्रामिंग भाषा)]] में, जब सबक्लास में एक पद्धति होती है जो सुपरक्लास की पद्धति को ओवरराइड करती है, तो यह [[कीवर्ड (कंप्यूटर प्रोग्रामिंग)]] {{Java|super}}का उपयोग करके सुपरक्लास पद्धति को भी प्रयुक्त कर सकती है।<ref name="lewis-loftus" /> उदाहरण:

     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.");
     } 



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

 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."
<code>super</code> संदर्भ हो सकता है
 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. 



ऐसी पद्धतियाँ हैं जो सबक्लास ओवरराइड नहीं कर सकते हैं। उदाहरण के लिए, जावा में, सुपर क्लास में अंतिम घोषित की गई पद्धति को ओवरराइड नहीं किया जा सकता है। जिन तरीकों को निजी या स्थिर घोषित किया गया है, उन्हें ओवरराइड नहीं किया जा सकता क्योंकि वे पूरी तरह से अंतिम हैं। एक क्लास के लिए यह भी असंभव है कि सुपर क्लास बनने के लिए अंतिम घोषित किया जाए।<ref name="deitel">Deitel & Deitel 2001, p.474</ref>



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

  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")
 }

===पायथन===
पायथन (प्रोग्रामिंग भाषा) में, जब एक सबक्लास में एक पद्धति होती है जो सुपरक्लास की एक पद्धति को ओवरराइड करती है, तो आप स्वयं पद्धति के अतिरिक्त सुपर {{Python|super(Subclass, self).method}}<ref name="python-3-super">{{Python|super().method}} in Python 3 - see https://docs.python.org/3/library/functions.html#super {{Webarchive|url=https://web.archive.org/web/20181026035007/https://docs.python.org/3/library/functions.html#super |date=2018-10-26 }}</ref> को कॉल करके {{Python|self.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()
 # "I'm a new object of type Thought!"
 t.message()
 # "I feel like I am diagonally parked in a parallel universe.
 
 a = Advice()
 # "I'm a new object of type Thought!"
 a.message()
 # "Warning: Dates in calendar are closer than they appear"
 # "I feel like I am diagonally parked in a parallel universe.
 
 # ------------------
 # Introspection:
 
 isinstance(t, Thought)
 # True
 
 isinstance(a, Advice)
 # True
 
 isinstance(a, Thought)
 # True

 isinstance(a, Advice)
 # True

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

उदाहरण:

 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

==टिप्पणियाँ==
{{Reflist|2}}


== यह भी देखें ==
* [[कार्यान्वयन विरासत|कार्यान्वयन इनहेरिटेंस]]
* [[वंशानुक्रम शब्दार्थ|इनहेरिटेंस शब्दार्थ]]
* [[विधि अधिभार|पद्धति अधिभार]]
* [[वस्तु-उन्मुख प्रोग्रामिंग में बहुरूपता]]
* [[टेम्पलेट विधि पैटर्न|टेम्पलेट पद्धति पैटर्न]]
* [[आभासी विरासत|आभासी इनहेरिटेंस]]
* एचटीटीपी हेडर क्षेत्र की सूची

==संदर्भ==
* 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
* [[Bertrand Meyer|Meyer, Bertrand]] (2009). ''Touch of Class: Learning to Program Well with Objects and Contracts''. Springer.


==बाहरी संबंध==
* [http://www.codeproject.com/KB/architecture/OOP_Concepts_and_manymore.aspx#Overriding Introduction to O.O.P. Concepts and More] by Nirosh L.w.C.
* [http://java.sun.com/docs/books/tutorial/java/IandI/override.html Overriding and Hiding Methods] by [[Sun Microsystems]]

{{DEFAULTSORT:Method Overriding}}
<!--Categories-->

[[Category:Articles with example C Sharp code|Method Overriding]]
[[Category:Articles with example Java code|Method Overriding]]
[[Category:C++ कोड उदाहरण के साथ लेख|Method Overriding]]
[[Category:Created On 16/02/2023|Method Overriding]]
[[Category:Lua-based templates|Method Overriding]]
[[Category:Machine Translated Page|Method Overriding]]
[[Category:Pages with script errors|Method Overriding]]
[[Category:Short description with empty Wikidata description|Method Overriding]]
[[Category:Templates Vigyan Ready|Method Overriding]]
[[Category:Templates that add a tracking category|Method Overriding]]
[[Category:Templates that generate short descriptions|Method Overriding]]
[[Category:Templates using TemplateData|Method Overriding]]
[[Category:Webarchive template wayback links]]
[[Category:उदाहरण कोड वाले लेख|Method Overriding]]
[[Category:जावा कोड उदाहरण के साथ लेख|Method Overriding]]
[[Category:विधि (कंप्यूटर प्रोग्रामिंग)|Method Overriding]]