ओवरराइडिंग विधि: Difference between revisions

From Vigyanwiki
Line 368: Line 368:
[[Category: Machine Translated Page]]
[[Category: Machine Translated Page]]
[[Category:Created On 16/02/2023]]
[[Category:Created On 16/02/2023]]
[[Category:Vigyan Ready]]

Revision as of 15:48, 23 February 2023

चित्रण

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

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

एडीए

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

 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 # (प्रोग्रामिंग भाषा) पद्धति ओवरराइडिंग का समर्थन करता है, लेकिन केवल यदि संशोधक override और virtual या 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 # इनहेरिटेड गुण या पद्धति के 'छिपाने' की स्वीकृति देता है। यह एक गुण या पद्धति के समान हस्ताक्षर का उपयोग करके किया जाता है लेकिन संशोधक new को जोड़कर किया जाता है।[6]

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

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 ++ में कीवर्ड super नहीं है कि एक सबक्लास जावा में एक पद्धति के सुपरक्लास संस्करण को प्रयुक्त करने के लिए उपयोग कर सकता है जिसे वह ओवरराइड करना चाहता है। इसके अतिरिक्त, पैरेंट या बेस क्लास का नाम स्कोप रिज़ॉल्यूशन संचालक के बाद प्रयोग किया जाता है। उदाहरण के लिए, निम्न कोड दो क्लास (कंप्यूटर विज्ञान), बेस क्लास Rectangle, और व्युत्पन्न क्लास Box प्रस्तुत करता है Box Rectangle क्लास के Print पद्धति ओवरराइड करता है ताकि इसकी ऊंचाई को भी प्रिंट किया जा सके।[7] 

#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_;
}


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

निम्नलिखित कथन (प्रोग्रामिंग) Rectangle और Box वस्तु (कंप्यूटर विज्ञान) प्रकार की वस्तुओं का होगा और उनके संबंधित 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 में, जावा के समान, सुपर क्लास में final घोषित की गई पद्धति को ओवरराइड नहीं किया जा सकता है; साथ ही, एक पद्धति को ओवरराइड घोषित किया जा सकता है ताकि संकलक अवलोकन कर सके कि यह बेस क्लास में पद्धति को ओवरराइड करता है।

डेल्फी

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

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

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

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


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

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

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

जब तत्काल, क्लास APPLICATION निम्नलिखित आउटपुट उत्पन्न करता है: 

I feel like I am diagonally parked in a parallel universe.
Warning: Dates in calendar are closer than they appear.

एक पुनर्परिभाषित सुविधा के अंदर, भाषा कीवर्ड Precursor का उपयोग करके सुविधा के प्रीकर्सर तक अभिगम्य प्राप्त की जा सकती है, {ADVICE}.message के कार्यान्वयन पर विचार करें निम्नानुसार परिवर्तित किया जाता है: 

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

सुविधा के इंस्टेंस में {THOUGHT}.message का निष्पादन सम्मिलित है, और निम्न आउटपुट उत्पन्न करता है: 

Warning: Dates in calendar are closer than they appear.
I feel like I am diagonally parked in a parallel universe.

जावा

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

    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 सुपरक्लास का प्रतिनिधित्व करता है और एक पद्धति कॉल message()प्रयुक्त करता है। Adviceनामक सबक्लास प्रत्येक उस पद्धति को इनहेरिट करता है जो Thought क्लास में हो सकती है। हालाँकि, क्लास Advice पद्धति message()को ओवरराइड करता है, इसकी कार्यक्षमता को 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."

super संदर्भ हो सकता है 

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. 


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


कोटलिन

कोटलिन (प्रोग्रामिंग भाषा) में हम इस तरह से एक फ़ंक्शन को ओवरराइड कर सकते हैं (ध्यान दें कि फ़ंक्शन 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")
}

पायथन

पायथन (प्रोग्रामिंग भाषा) में, जब एक सबक्लास में एक पद्धति होती है जो सुपरक्लास की एक पद्धति को ओवरराइड करती है, तो आप स्वयं पद्धति के अतिरिक्त सुपर super(Subclass, self).method[10] को कॉल करके 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

रूबी

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

उदाहरण: 

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

टिप्पणियाँ

  1. ↑ Zhang, Jie (2015). "A novel P2P overridden API for open data communications in WWW". 2015 IEEE International Conference on Consumer Electronics-Taiwan.
  2. ↑ Flanagan 2002, p. 107
  3. ↑ 3.0 3.1 Lewis & Loftus 2006, p.454
  4. ↑ Overbey, J (2011). "Differential precondition checking: A lightweight, reusable analysis for refactoring tools". 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011).
  5. ↑ Li, K (2014). "Residual investigation: Predictive and precise bug detection". ACM Transactions on Software Engineering and Methodology (TOSEM). 24 (2).
  6. ↑ Mössenböck, Hanspeter (2002-03-25). "Advanced C#: Overriding of Methods" (PDF). Institut für Systemsoftware, Johannes Kepler Universität Linz, Fachbereich Informatik. pp. 6–8. Retrieved 2011-08-02.
  7. ↑ Malik 2006, p. 676
  8. ↑ Meyer 2009, page 572-575
  9. ↑ Deitel & Deitel 2001, p.474
  10. ↑ super().method in Python 3 - see https://docs.python.org/3/library/functions.html#super Archived 2018-10-26 at the Wayback Machine


यह भी देखें

संदर्भ

  • 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.


बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=ओवरराइडिंग_विधि&oldid=95945’