Ruby child class update parent class variable - ruby

Question

I am trying to update the parent class variable from the child class. This is what I have
class Dog
def initialize
#breed = []
end
def show
puts "#{#first_name} of breed #{#breed}" ### <- Changed
end
end
class Lab < Dog
attr_reader :first_name, :i
def initialize
super ### <- Added
#first_name = "good dog"
#i = 1
end
def add
#breed << #i
#i += 1
end
end
As you can see, I have a #breed variable in the parent class, which the child class has access to. But when I update the #breed variable from the child class and call the same variable from the parent class it does not show the update values. How can I do that?
irb(main):172:0> d = Dog.new
=> #<Dog:0x00005607908130d8 #breed=[]>
irb(main):173:0> l = Lab.new
=> #<Lab:0x000056079081add8 #breed=[], #first_name="good dog", #i=1>
irb(main):174:0> d.show
of breed []
irb(main):175:0> l.show
good dog of breed []
irb(main):176:0> l.add
=> 2
irb(main):177:0> l.show # inherited variable got updated
good dog of breed [1]
irb(main):178:0> d.show # parent array did not get updated?
of breed []
irb(main):179:0>
Calling d.show returns an empty array, but calling l.show returns the filled array. I would like my parent class also return the filled array. Is this possible? What am I missing.

Answer 1

d and l in your example are absolutely different objects, having nothing in common. That’s not how inheritance works.
There would be a brief example of using the instance variable from parent class.
class Dog
def initialize
#breed = []
end
def add
puts "Dog: #{#breed}"
end
end
class Lab < Dog
def initialize
super ### <- #breed is now declared
end
def add
puts "Lab 1: #{#breed}"
#breed << :ok
super
puts "Lab 2: #{#breed}"
end
end
Lab.new.add
#⇒ Lab 1: []
#⇒ Dog: [:ok]
#⇒ Lab 2: [:ok]

Answer 2

No, this is not possible, at least not without some (unadvisable) hacking.
You are missing the distinction between classes and instances. There can be a hierarchy of classes, as you created with Dog and Lab, but the instances you create from these classes don't have a hierarchical relationship. The (instance) variables, like #breed, are private to each instance and each instance has its own copies.
In other words: There is no "parent array", only an array which has been declared in a parent class.
It looks like you want a collection of Dog instances. The right place would a variable outside of the Dog class.
class Dog
attr_reader :first_name
def initialize(name)
#first_name = name
end
def show
puts "#{first_name} of breed #{self.class.name}"
end
end
class Lab < Dog
def initialize
super('good dog')
end
end
class Schnauzer < Dog
end
class BlackLab < Lab
end
Notice that I moved first_name from Lab to Dog, because Dog#show already uses it and it makes no sense to declare it in a sub class.
You can use this class hierarchy to collect multiple instances in an array which is stored outside of the class hierarchy:
breeds = []
breeds << Dog.new('some dog')
breeds << Lab.new
breeds << Dog.new('another dog')
breeds << Schnauzer.new('yet another')
breeds << BlackLab.new
breeds.each do |dog_instance|
dog_instance.show
end
This produces the following output:
some dog of breed Dog
good dog of breed Lab
another dog of breed Dog
yet another of breed Schnauzer
good dog of breed BlackLab

Answer 3

class Dog
def initialize
puts "self in Dog#initialize = #{self}"
#breed = []
end
def show
puts "#{#first_name} of breed #{#breed}"
end
end
class Lab < Dog
attr_reader :first_name, :i
def initialize
super
#first_name = "good dog"
#i = 1
end
def add
#breed << #i
#i += 1
end
end
Let's create an instance of Lab and examine its instance variables:
sue = Lab.new
#=> #<Lab:0x000059195710eec8 #breed=[], #first_name="good dog", #i=1>
# displays: self in Dog#initialize = #<Lab:0x000059195710eec8>
sue.instance_variables
#=> [:#breed, :#first_name, :#i]
sue.first_name"
#=> "good dog"
sue.i
#=> 1
sue.instance_variable_get(:#breed)
#=> []
Notice I had to use Object#instance_variable_get to obtain the value of sue's instance variable #breed because no getter had been created for that instance variable.
You say you wish to "update the parent class variable from the child class". Firstly the parent class, Dog has no class variables or instance variables (sometimes referred to as class instance variables). I assume you mean the instance variable #breed that is associated with each instance of Dog. In fact, it appears that one would not likely create an instance of Dog; that Dog has been created only to define methods and instance variables that are to be used by subclasses of Dog. Nevertheless, let's create an instance of Dog:
bob = Dog.new
#=> #<Dog:0x0000591956ffd4a8 #breed=[]>
# displays: self in Dog#initialize = #<Dog:0x0000591956ffd4a8>
bob.instance_variables
#=> [:#breed]
bob.instance_variable_get(:#breed)
#=> []
Let's also change the value of #breed for this instance:
bob.instance_variable_get(:#breed) << "pug"
#=> ["pug"]
Now let's add a method get_iv to Lab to get the value of the instance variable #breed of an instance of Dog. Think about the information that must be passed to this method. It needs to know which instance of Dog we are concerned with (as different instances may very well have different values for their instance variables), and for that instance, which instance variable we are interested in. (Here there is but one, but let's make it general so that we could add instance variables to Dog's instances.)
class Lab
def get_iv(instance, instance_variable)
instance.public_send(:instance_variable_get, instance_variable)
end
end
See Object#public_send. So we could now write:
sue.get_iv(bob, :#breed)
#=> ["pug"]
sue.get_iv(bob, :#breed) << "collie"
#=> ["pug", "collie"]
Sure enough, we have accomplished the task:
bob.instance_variable_get(:#breed)
#=> ["pug", "collie"]
But wait! Now let's create a completely unrelated class and an instance of it.
class Bird
def initialize
#type = ["canary"]
end
end
tweetie = Bird.new
#=> #<Bird:0x0000591956ffee98 #type=["canary"]>
Next, let sue get and alter the value of tweetie's instance variable #type:
sue.get_iv(tweetie, :#type)
#=> ["canary"]
sue.get_iv(tweetie, :#type) << "robin"
#=> ["canary", "robin"]
and confirm they've been changed:
tweetie.instance_variable_get(:#breed)
#=> ["canary", "robin"]
The point is that the instance method we must add to Lab requires two pieces of information:
the instance whose instance variable's value is to be obtained; and
the name of the instance variable.
This has nothing to do with the fact that Lab is a subclass of Dog! Therefore, to get or set the value of an instance variable of an instance of Lab's superclass is no different than getting or setting the value of an instance variable of any other class.