रूबी

Question

में अभिभावक कन्स्ट्रक्टर कॉल करें मैं माता-पिता कन्स्ट्रक्टर को कैसे कॉल कर सकता हूं?

module C 
    attr_accessor :c, :cc 
    def initialization c, cc 
     @c, @cc = c, cc 
    end 
end 

class B 
    attr_accessor :b, :bb 
    def initialization b, bb 
     @b, @bb = b, bb 
    end 
end 


class A < B 
    include C 
    attr_accessor :a, :aa 
    def initialization (a, b, c, aa, bb, cc) 
     #call B::initialization - ? 
     #call C::initialization - ? 
     @a, @aa = a, aa 
    end 
end 

धन्यवाद।

Answer 1

पहले, अपने विधि initialize, नहीं initialization होना चाहिए। फिर, आप पैरेंट क्लास विधि को कॉल करने के लिए super का उपयोग कर सकते हैं। स्पष्टता के लिए A में C के प्रारंभकर्ता को कॉल करने के लिए, मैं प्रारंभिक सामग्री को एक अलग फ़ंक्शन में विभाजित करने की अनुशंसा करता हूं, फिर बस उस फ़ंक्शन को सीधे कॉल करें। इसे कार्यान्वित करना और स्पष्ट करना आसान है।

Answer 2

super विधि का उपयोग करें! हालांकि रूबी के पास एकाधिक विरासत नहीं है।

class B 

    attr_accessor :b, :bb 

    def initialize(b, bb) 
    @b, @bb = b, bb 
    end 

end 

module C 

end 

class A < B 
    include C # <= if C was a class, you'd get: TypeError: wrong argument type Class (expected Module) 

    attr_accessor :a, :aa 

    def initialize(a,b,aa,bb) 
    @a, @aa = a, aa 
    super(b, bb) # <= calls B#initialize 
    end 

end 

a = A.new(1,2,3,4) 
puts a.inspect # => #<A:0x42d6d8 @aa=3, @a=1, @b=2, @bb=4> 

Answer 3

रूबी में रचनाकार नहीं हैं, इसलिए स्पष्ट रूप से उन्हें कॉल करना, माता-पिता या अन्यथा कॉल करना संभव नहीं है। रुबी में विधियां हैं, हालांकि, वर्तमान में निष्पादन विधि के समान ही नाम के साथ माता-पिता की विधि को कॉल करने के लिए, आप super कीवर्ड का उपयोग कर सकते हैं। [नोट: बिना तर्क के super एक ही तर्क को पारित करने के लिए एक शॉर्टकट है जो वर्तमान में निष्पादन विधि में पारित किया गया था। आप वास्तव में कोई तर्क पास करना चाहते हैं, तो आप ऐसा स्पष्ट रूप से क्या करना है: super()]

Answer 4

नीचे इस कोड को प्रिंट होगा:।

A.proc1 B.proc1 C.proc1

module A 
    def proc1 
    puts "A.proc1" 
    super 
    end 
end 

class B 
    def proc1 
    puts "B.proc1" 
    end 
end 

class C < B 
    include A 
    def proc1 
    super 
    puts "C.proc1" 
    end 
end 

C.new.proc1