Ruby Language
विरासत

वाक्य - विन्यास

• वर्ग SubClass <SuperClass

इनहेरिटेंस का उपयोग करने के लिए मौजूदा कक्षाओं को फिर से बनाना

मान लीजिए कि हमारे पास दो वर्ग हैं, Cat और Dog ।

class Cat
  def eat
    die unless has_food?
    self.food_amount -= 1
    self.hungry = false
  end
  def sound
    puts "Meow"
  end
end

class Dog
  def eat
    die unless has_food?
    self.food_amount -= 1
    self.hungry = false
  end
  def sound
    puts "Woof"
  end
end

इन दोनों वर्गों में eat तरीका बिल्कुल एक जैसा है। जबकि यह काम करता है, इसे बनाए रखना मुश्किल है। यदि एक ही eat विधि के साथ अधिक जानवर हैं तो समस्या और बदतर हो जाएगी। वंशानुक्रम इस समस्या को हल कर सकता है।

class Animal
  def eat
    die unless has_food?
    self.food_amount -= 1
    self.hungry = false
  end
  # No sound method
end

class Cat < Animal
  def sound
    puts "Meow"
  end
end

class Dog < Animal
  def sound
    puts "Woof"
  end
end

हमने एक नया वर्ग, Animal बनाया है, और हमारे eat विधि को उस वर्ग में स्थानांतरित कर दिया है। फिर, हमने Cat और Dog को इस नए सामान्य सुपरक्लास से विरासत में बनाया। यह कोड को दोहराने की आवश्यकता को हटा देता है

एकाधिक वंशानुक्रम

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

उपवर्गों

वंशानुक्रम वर्गों को मौजूदा कक्षा के आधार पर विशिष्ट व्यवहार को परिभाषित करने की अनुमति देता है।

class Animal
  def say_hello
    'Meep!'
  end

  def eat
    'Yumm!'
  end
end

class Dog < Animal
  def say_hello
    'Woof!'
  end
end

spot = Dog.new
spot.say_hello # 'Woof!'
spot.eat       # 'Yumm!'

इस उदाहरण में:

• Dog इनहेरिट इन Animal , इसे सबक्लास बना रहा है।
• Dog ने say_hello दोनों हासिल say_hello और Animal से तरीके eat ।
• Dog अलग-अलग कार्यक्षमता के साथ say_hello विधि को ओवरराइड करता है।

mixins

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

module SampleModule

  def self.included(base)
    base.extend ClassMethods
  end

  module ClassMethods

    def method_static
      puts "This is a static method"
    end

  end

  def insta_method
    puts "This is an instance method"
  end

end

class SampleClass
  include SampleModule
end

sc = SampleClass.new

sc.insta_method

prints "This is an instance method"

sc.class.method_static

prints "This is a static method"

विरासत में क्या मिला है?

तरीके विरासत में मिले हैं

class A
  def boo; p 'boo' end
end

class B < A; end

b = B.new
b.boo # => 'boo'

वर्ग के तरीके विरासत में मिले हैं

class A
  def self.boo; p 'boo' end
end

class B < A; end

p B.boo # => 'boo'

लगातार विरासत में मिले हैं

class A
  WOO = 1
end

class B < A; end

p B::WOO # => 1

लेकिन सावधान रहें, उन्हें ओवरराइड किया जा सकता है:

class B
  WOO = WOO + 1
end

p B::WOO # => 2

उदाहरण चर विरासत में मिले हैं:

class A
  attr_accessor :ho
  def initialize
    @ho = 'haha'
  end
end

class B < A; end

b = B.new
p b.ho # => 'haha'

सावधान रहें, यदि आप उन तरीकों को ओवरराइड करते हैं जो super कॉल किए बिना इंस्टेंस वेरिएबल्स को इनिशियलाइज़ करते हैं, तो वे शून्य हो जाएंगे। ऊपर से जारी:

class C < A
  def initialize; end
 end

c = C.new
p c.ho    # => nil

वर्ग उदाहरण चर विरासत में नहीं मिले हैं:

class A
    @foo = 'foo'
    class << self
        attr_accessor :foo
    end
end

class B < A; end

p B.foo # => nil

# The accessor is inherited, since it is a class method
#
B.foo = 'fob' # possible

वर्ग चर वास्तव में विरासत में नहीं मिले हैं

उन्हें आधार वर्ग और सभी उपवर्गों के बीच 1 चर के रूप में साझा किया जाता है:

class A
    @@foo = 0
    def initialize
        @@foo  += 1 
        p @@foo
    end
end

class B < A;end

a = A.new # => 1
b = B.new # => 2

तो ऊपर से जारी:

class C < A
  def initialize
    @@foo = -10
    p @@foo
  end
end

a = C.new # => -10
b = B.new # => -9