रूबी में आप पॉलिमॉर्फिज्म कैसे करते हैं?

Question

सी # में, मैं यह कर सकता हूँ:

class Program 
{ 
    static void Main(string[] args) 
    { 
     List<Animal> animals = new List<Animal>(); 

     animals.Add(new Dog()); 
     animals.Add(new Cat()); 

     foreach (Animal a in animals) 
     { 
      Console.WriteLine(a.MakeNoise()); 
      a.Sleep(); 
     } 
    } 
} 

public class Animal 
{ 
    public virtual string MakeNoise() { return String.Empty; } 
    public void Sleep() 
    { 
     Console.Writeline(this.GetType().ToString() + " is sleeping."); 
    } 
} 

public class Dog : Animal 
{ 
    public override string MakeNoise() 
    { 
     return "Woof!"; 
    } 
} 

public class Cat : Animal 
{ 
    public override string MakeNoise() 
    { 
     return "Meow!"; 
    } 
} 

जाहिर है, उत्पादन होता है (थोड़ा दूसरे शब्दों में बयान):

• Woof
• कुत्ता सो रही है
• म्याऊ
• बिल्ली सो रही है

चूंकि सी # को अक्सर अपने वर्बोज़ प्रकार सिंटैक्स के लिए मजाक किया जाता है, इसलिए आप रूबी जैसे बतख वाली भाषा में बहुरूपता/आभासी तरीकों को कैसे संभालेंगे?

Answer 1

संपादित करें: अपने अद्यतन प्रश्न के लिए और अधिक कोड जोड़ा

अस्वीकरण: मैं एक साल या में रूबी का इस्तेमाल किया है नहीं है, और यह इस मशीन पर नहीं स्थापित किया है, इसलिए वाक्य रचना पूरी तरह से गलत हो सकता है। लेकिन अवधारणाएं सही हैं।

---

ठीक उसी तरह से, वर्गों और ओवरराइड तरीकों के साथ: पिछले जवाब पर

class Animal 
    def MakeNoise 
     return "" 
    end 
    def Sleep 
     print self.class.name + " is sleeping.\n" 
    end 
end 

class Dog < Animal 
    def MakeNoise 
     return "Woof!" 
    end 
end 

class Cat < Animal 
    def MakeNoise 
     return "Meow!" 
    end 
end 

animals = [Dog.new, Cat.new] 
animals.each {|a| 
    print a.MakeNoise + "\n" 
    a.Sleep 
} 

Answer 2

बिल्डिंग, यह कैसे आप यह कर सकता है?

---

स्पष्टीकरण के बाद दूसरा कटौती:

class Animal 
    def MakeNoise 
     raise NotImplementedError # I don't remember the exact error class 
    end 
    def Sleep 
     puts self.class.to_s + " is sleeping." 
    end 
end 

class Dog < Animal 
    def MakeNoise 
     return "Woof!" 
    end 
end 

class Cat < Animal 
    def MakeNoise 
     return "Meow!" 
    end 
end 

animals = [Dog.new, Cat.new] 
animals.each {|a| 
    puts a.MakeNoise 
    a.Sleep 
} 

Answer 3

(मैं इस रूप में है "self.class.name" छोड़ देंगे, लेकिन ".to_s" पर जीतता है) मुहावरेदार रूबी का उपयोग करना

class Animal 
    def sleep 
    puts "#{self.class} is sleeping" 
    end 
end 

class Dog < Animal 
    def make_noise 
    "Woof!" 
    end 
end 

class Cat < Animal 
    def make_noise 
    "Meow!" 
    end 
end 

[Dog, Cat].each do |clazz| 
    animal = clazz.new 
    puts animal.make_noise 
    animal.sleep 
end 

Answer 4

यह मैं इसे कैसे लिखना होता है:

class Animal 
    def make_noise; '' end 
    def sleep; puts "#{self.class.name} is sleeping." end 
end 

class Dog < Animal; def make_noise; 'Woof!' end end 
class Cat < Animal; def make_noise; 'Meow!' end end 

[Dog.new, Cat.new].each do |animal| 
    puts animal.make_noise 
    animal.sleep 
end 

यह वास्तव में अन्य समाधानों से अलग नहीं है, लेकिन यह वह शैली है जिसे मैं पसंद करूंगा।

मूल सी # उदाहरण से 41 लाइनों (वास्तव में, आप संग्रह प्रारंभकर्ता का उपयोग करके 3 लाइनों को बंद कर सकते हैं) बनाम 12 लाइनें हैं। बुरा नहीं!

Answer 5

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

"नींद" व्यवहार का उपयोग करके प्रदान किया जा सकता है एक मिश्रण मॉड्यूल, जैसे ऐरे, हैश और अन्य रूबी अंतर्निर्मित कक्षाएं अंकुरित हैं। मैं यह सुझाव नहीं दे रहा हूं कि यह आवश्यक रूप से बेहतर है, बस इसे करने का एक अलग और शायद अधिक मूर्खतापूर्ण रूबी तरीका।

module Animal 
    def sleep 
    puts self.class.name + " sleeps" 
    end 
end 

class Dog 
    include Animal 
    def make_noise 
    puts "Woof" 
    end 
end 

class Cat 
    include Animal 
    def make_noise 
    puts "Meow" 
    end 
end 

आप बाकी को जानते हैं ...

Answer 6

बतख टाइपिंग का सिद्धांत यह है कि ऑब्जेक्ट को बुलाए गए तरीकों का जवाब देना है। तो ऐसा ही कुछ भी काम कर सकता है:

module Sleeping 
    def sleep; puts "#{self} sleeps" 
end 

dog = "Dog" 
dog.extend Sleeping 
class << dog 
    def make_noise; puts "Woof!" end 
end 

class Cat 
    include Sleeping 
    def to_s; "Cat" end 
    def make_noise; puts "Meow!" end 
end 

[dog, Cat.new].each do |a| 
    a.sleep 
    a.make_noise 
end 

Answer 7

manveru के समाधान की एक छोटी सी प्रकार, जिसमें गतिशील कक्षा प्रकार की एक सरणी में स्थित वस्तु के विभिन्न प्रकार बना सकते हैं। वास्तव में अलग नहीं, बस थोड़ा और स्पष्ट है।

Species = [Dog, Cat] 

Species.each do |specie| 
    animal = specie.new # this will create a different specie on each call of new 
    print animal.MakeNoise + "\n" 
    animal.Sleep 
end 

Answer 8

एक विधि becomes जो एक बहुरूपता

class Animal 
    attr_reader :name 

    def initialize(name = nil) 
    @name = name 
    end 

    def make_noise 
    '' 
    end 

    def becomes(klass) 
    became = klass.new 
    became.instance_variables.each do |instance_variable| 
     value = self.instance_variable_get(instance_variable) 
     became.instance_variable_set(instance_variable, value) 
    end 

    became 
    end 
end 

class Dog < Animal 
    def make_noise 
    'Woof' 
    end 
end 

class Cat < Animal 
    def make_noise 
    'Meow' 
    end 
end 

animals = [Dog.new('Spot'), Cat.new('Tom')] 

animals.each do |animal| 
    new_animal = animal.becomes(Cat) 
    puts "#{animal.class} with name #{animal.name} becomes #{new_animal.class}" 
    puts "and makes a noise: #{new_animal.make_noise}" 
    puts '----' 
end 

और परिणाम (नया एक के लिए किसी वर्ग से सभी उदाहरण चर मुकाबला द्वारा) को लागू करता है है:

Dog with name Spot becomes Cat 
and makes a noise: Meow 
---- 
Cat with name Tom becomes Cat 
and makes a noise: Meow 
---- 

• एक if कथन से बचने के लिए बहुरूपता उपयोगी हो सकती है (antiifcampaign.com)

• आप का उपयोग करते हैं RubyOnRailsbecomes पद्धति पहले से ही लागू किया गया है: becomes

• Quicktip: यदि आप STI साथ बहुरूपता मिश्रण यह आप सबसे कुशल कॉम्बो लाता है अपने कोड

मैं refactor करने के लिए इच्छा है कि यह आपकी मदद करे