我应该如何在Ruby中定义其处理算法在超类中定义的实例变量？

Question

In short: I want to define the algorithm in the superclass which inherits into all subclasses, but I want to define the data (on which the algorithm operates) in the subclasses as instance variables, which come into being when I call the "new" method of the given classes. What is the standard way for doing this in Ruby?

My solution is (but I am not exactly sure this is the right way):

class A
   attr_accessor :var
   def initialize
     @var=nil #I dont know the actual value, it will be defined only in the more specific subclasses.
   end

   def process_data
      puts @var #simply puts it out
   end
end

#in my program all further classes are inherited form class A, the processing facility is inherited, only the data varies.

class B < A
   attr_accessor :var
   def initialize
     @var=10 #specific value for class B which is always 10, no need for example b=B.new(20)
   end
end

class C < A
   attr_accessor :var
   def initialize
     @var=20 #specific value for class C which is always 20, no need for example c=C.new(20)
   end
end

b=B.new
b.process_data #needs to print 10

c=C.new
c.process_data #needs to print 20

Answer 1

What you have works. There's just some unneeded stuff in there:

Instance variables evaluate to nil if they are uninitialized and they spring into existence as soon as they are used, so your A#initialize method is unnecessary.

You override the A#var and A#var= methods in B and C with methods that do the exact same thing. There is no need for that, just get rid of the calls to attr_accessor in the definition of B and C .

You create var and var= accessor methods but you never use them. Either get rid of the call to attr_accessor or (preferably) use the accessor methods, ie use self.var = in initialize and puts var in process_data .

class A
  attr_accessor :var

  def process_data
    puts var #simply puts it out
  end
end

#in my program all further classes are inherited form class A, the processing facility is inherited, only the data varies.

class B < A
  def initialize
    self.var = 10 #specific value for class B which is always 10, no need for example b=B.new(20)
  end
end

class C < A
  def initialize
    self.var = 20 #specific value for class C which is always 20, no need for example c=C.new(20)
  end
end

b = B.new
b.process_data #needs to print 10

c = C.new
c.process_data #needs to print 20

[Note: your coding style was also off. Indentation is 2 spaces in Ruby, not 3.]

However, if the value of @var is always the same for all instances of B , then why do you need multiple instances of B ?

Why not something like this:

class A
  attr_accessor :var

  def initialize(val)
    self.var = val
  end

  def process_data
    puts var #simply puts it out
  end
end

b = A.new(10)
b.process_data #needs to print 10

c = A.new(20)
c.process_data #needs to print 20

Answer 2

You are doing it in almost the right way. A minor point is that your A::initialize definition is redundant for two reasons:

• An instance variable is initialized to nil automatically.
• The initialize methods in the subclasses will override A::initialize when the subclass instances are created.

Also, the attr_accessor calls in the subclasses are redundant.

---

Now I seem to get what you wanted. You can use class-level instance variables.

class A
  def initialize
    @var=self.class.instance_variable_get(:@var)
  end
  def process_data
    puts @var
  end
end

class B < A
  @var = 10
end

class C < A
  @var = 20
end

B.new.process_data # => 10
C.new.process_data # => 20