पॉलिमॉर्फिज्म एक लूप के अंदर एक और कथन कहां बदल सकता है?

Question

पॉलिमॉर्फिज्म अगर किसी अन्य कथन को बदल सकता है या लूप के अंदर स्विच कर सकता है? विशेष रूप से यह हमेशा किसी और को प्रतिस्थापित कर सकता है? यदि मैं लूप के अंदर उपयोग करता हूं तो अधिकांश अधिकांश अंकगणितीय तुलना होते हैं। यह प्रश्न इस question से उत्पन्न हुआ है।

int x; 
int y; 
int z; 

while (x > y) 
{ 
    if (x < z) 
    { 
     x = z; 
    } 
} 

यह पॉलिमॉर्फिज्म के साथ कैसे काम करेगा?
नोट: मैंने जावा में यह लिखा है लेकिन किसी भी ओओएल के लिए इसमें दिलचस्पी है।

Answer 1

पॉलिमॉर्फिज्म आमतौर पर स्विच स्टेटमेंट को प्रतिस्थापित करता है जब प्रत्येक केस एक अलग प्रकार से मेल खाता है। तो होने के बजाय:

public class Operator 
{ 
    string operation; 

    public int Execute(int x, int y) 
    { 
     switch(operation) 
     { 
      case "Add": 
       return x + y; 
      case "Subtract": 
       return x - y; 
      case "Multiply": 
       return x * y; 
      case "Divide": 
       return x/y; 
      default: 
       throw new InvalidOperationException("Unsupported operation"); 
     } 
    } 
} 

आप होगा:

public abstract class Operator 
{ 
    public abstract int Execute(int x, int y); 
} 

public class Add : Operator 
{ 
    public override int Execute(int x, int y) 
    { 
     return x + y; 
    } 
} 

// etc 

हालांकि, निर्णय आपके द्वारा प्रदान की तुलना प्रकार के लिए, बहुरूपता वास्तव में मदद नहीं करता है।

Answer 2

पॉलिमॉर्फिज्म वास्तव में आपके द्वारा प्रदान किए गए उदाहरण में लागू नहीं है।

यह SO answer देखें।

Answer 3

पॉलिमॉर्फिज्म केवल तभी प्रतिस्थापित कर सकता है जब परीक्षण परीक्षण मूल रूप से ऑब्जेक्ट के "प्रकार" के आधार पर विभिन्न तरीकों से जी को प्रेषित करता है। उदाहरण के लिए यदि ऑब्जेक्ट प्रकार एक्स है तो foo को आमंत्रित करें यदि यह एक वाई इनक बार है और इसलिए। इस संक्रमित उदाहरण में कोई एक विधि खराब() के साथ एक इंटरफ़ेस DoSonething परिभाषित करेगा। एक्स और वाई दोनों बाज़ को लागू करेंगे और वाई के लिए एक्स और बार() के लिए अपने संबंधित बाज़() को foo() का आह्वान करेंगे। यह बस कॉलिंग बाज़() एक परीक्षण के लिए आवश्यकता को खत्म कर देगा।

Answer 4

स्मॉलटॉक में, "अगर" वास्तव में बूलियन में एक बहुलक विधि है। निम्न उदाहरण में:

[ x>y ] whileTrue: 
    [ 
    (x<z) ifTrue: [ x:=z ]   
    ] 

ifTrue:aBlock संदेश "इस ब्लॉक पर अमल" के रूप में True में कार्यान्वित किया जाता है और False के रूप में "इस ब्लॉक उपेक्षा", तो क्या (x<z) को मूल्यांकन करता है, या तो कार्यान्वयन बुलाया जाएगा पर निर्भर करता है।

तो स्मालटाक बहुरूपता में हर बदल दे-किसी और डिफ़ॉल्ट रूप से निर्माण :)

Answer 5

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

उस फ़ॉर्म में अपने लूप को एन्कोड करने के लिए, एक्स और वाई की तुलना करने के परिणामस्वरूप चुनिंदा विधि को कॉल करने की आवश्यकता है ताकि यह निर्धारित किया जा सके कि ब्लॉक को लूप के अंदर के लिए कॉल करना है या नहीं, और यह ब्लॉक भी तुलना करता है और एक्स का मान सेट करना चुनें। एक और शाब्दिक अनुवाद या तो एक ब्लॉक चुनना होगा जो एक्स को ज़ेड या एक सेट करता है जो कुछ भी नहीं करता है; इसके बजाय यह एक्स को उसी मान पर वापस सेट करने के लिए चुनता है।

स्पष्ट रूप से यह इस साधारण मामले के लिए अतिसंवेदनशील और अक्षम है।

public class WantonPolymorphism { 

    static class Int32 { 
     final int value; 
     Int32 (final int value) { this.value = value; } 

     Compare compare (Int32 other) { 
      // Java runs out of turtles at this point unless you use 
      // an enum for every value 
      if (this.value < other.value) return Compare.LESS; 
      if (this.value > other.value) return Compare.GREATER; 
      return Compare.EQUAL; 
     } 
    } 

    enum Compare { 
     LESS { 
      <T> T choose (T less, T equal, T greater) { return less; } 
     }, 
     EQUAL { 
      <T> T choose (T less, T equal, T greater) { return equal; } 
     }, 
     GREATER { 
      <T> T choose (T less, T equal, T greater) { return greater; } 
     }; 

     abstract <T> T choose (T less, T equal, T greater) ; 
    } 

    interface Block { Block execute() ; } 


    /** 
    * Main entry point for application. 
    * @param args The command line arguments. 
    */ 
    public static void main (String...args) { 
     Block block = new Block() { 
      Int32 x = new Int32(4); 
      Int32 y = new Int32(3); 
      Int32 z = new Int32(2); 

      public Block execute() { 
       System.out.printf("x = %d, y = %d, z = %d\n", x.value, y.value, z.value); 

       return x.compare(y).choose(done, done, new Block() { 
        public Block execute() { 
         x = x.compare(z).choose(x,x,z); 

         return x.compare(y).choose(done, done, this); 
        } 
       }); 
      } 

      Block done = new Block() { 
       public Block execute() { 
        System.out.printf("x = %d, y = %d, z = %d\n", x.value, y.value, z.value); 
        System.exit(0); 
        return this; 
       } 
      }; 
     }; 

     for(;;) 
      block = block.execute(); 
    } 
} 

Answer 6

आदिम के लिए हम नहीं कर सकते, लेकिन ऑब्जेक्ट के लिए हम कर सकते हैं।

यह blog देखें।