Ruby 中的抽象方法

Question

如何强制子类实现 Ruby 中的方法。 Ruby 中似乎没有抽象关键字，而我在 Java 中则采用这种方法。还有另一种更像 Ruby 的方式来强制抽象吗？

Answer 1

抽象方法在 Ruby 中应该不太有用，因为它不是强静态类型。

然而，这就是我所做的：

class AbstractThing
  MESS = "SYSTEM ERROR: method missing"

  def method_one; raise MESS; end
  def method_two; raise MESS; end
end

class ConcreteThing < AbstractThing
  def method_one
     puts "hi"
  end
end

a = ConcreteThing.new
a.method_two # -> raises error.

然而，这似乎很少是必要的。

Answer 2

我喜欢 pvandenberk 的答案，但我会对其进行如下改进：

module Canine      # in Ruby, abstract classes are known as modules
  def bark
    fail NotImplementedError, "A canine class must be able to #bark!"
  end
end

现在，如果您创建一个属于 Canine “抽象类”的类（即具有 Canine 的类）模块），如果发现 #bark 方法未实现，它会抱怨：

class Dog
  include Canine   # make dog belong to Canine "abstract class"
end

Dog.new.bark       # complains about #bark not being implemented

class Dog
  def bark; "Bow wow!" end
end

# Now it's OK:
Dog.new.bark #=> "Bow wow!"

请注意，由于 Ruby 类不是静态的，而是始终开放更改，Dog 类本身不能强制存在#bark 方法，因为它不知道什么时候应该完成。如果你作为程序员这样做，那么这个时候就由你来测试它。

Answer 3

我喜欢的方法类似，但略有不同...我更喜欢如下，因为它使代码自我记录，为您提供与 Smalltalk 非常相似的东西：

class AbstractThing
  def method_one; raise "SubclassResponsibility" ; end
  def method_two; raise "SubclassResponsibility" ; end
  def non_abstract_method; method_one || method_two ; end
end

有些人会抱怨这不太 DRY，并坚持创建异常子类和/或将 "SubclassResponsibility" 字符串放入常量中，但恕我直言 你可以把东西弄干到被摩擦的程度，这通常不是一件好事。例如，如果您的代码库中有多个抽象类，那么您将在哪里定义 MESS 字符串常量？！？

Answer 4

我喜欢使用像 abstract_method 这样的 gem，它提供了 dsl Rails 风格的语法抽象方法：

class AbstractClass
  abstract_method :foo
end

class AbstractModule
  abstract_method :bar
end

class ConcreteClass < AbstractClass
  def foo
    42
  end
end

Answer 5

如果继承类中未定义方法“foo”、“bar”和“mate”，则此代码将不允许您加载该类。

它没有考虑到跨多个文件定义的类，但老实说，我们中的许多人实际上是否跨多个文件定义了类方法？我的意思是如果你不计算混合。 （这确实说明了这一点）

def self.abstract(*methods_array)
  @@must_abstract ||= []
  @@must_abstract = Array(methods_array)
end
def self.inherited(child)
   trace = TracePoint.new(:end) do |tp|
      if tp.self == child #modules also trace end we only care about the class end   
        trace.disable
        missing = ( Array(@@must_abstract) - child.instance_methods(false) )
        raise NotImplementedError, "#{child} must implement the following method(s) #{missing}" if missing.present?
      end
  end 
  trace.enable
end

abstract :foo
abstract :bar, :mate

Answer 6

如果您想在创建类的实例时抛出错误，您可以执行以下操作

class AbstractClass
  def self.new(args)
    instance = allocate # make memory space for a new object
    instance.send(:default_initialize, args)
    instance.send(:initialize, args)
    instance
  end

  #This is called whenever object created, regardless of whether 'initialize' is overridden
  def default_initialize(args)
    self.abstract_method #This will raise error upon object creation
  end
  private :default_initialize

  def initialize(args)
   # This can be overridden by new class
  end
end


class NewClass < AbstractClass
end

NewClass.new #Throw error

Answer 7

因为问题是（重点）“如何强制子类在 Ruby 中实现方法”，所以我认为我们可以使用 TDD :D，例如：rspec 共享示例< /code>

shared_examples "MUST implement abstract method" do |method_sym|
  it { is_expected.to respond_to(method_sym) }
end

describe Stack do
  it_behaves_like "MUST implement abstract method", :push
  it_behaves_like "MUST implement abstract method", :pop
end

也许 测试比 Abstract 更好 :D ，参考：http://morningcoffee.io/interfaces-in-ruby.html