如何在Ruby中实现一个抽象类？

我知道红宝石中没有抽象类的概念。但是，如果根本需要实施，该怎么做？我尝试过类似...

class A
  def self.new
    raise 'Doh! You are trying to write Java in Ruby!'
  end
end

class B < A
  ...
  ...
end

但是，当我尝试实例化B时，它将在内部进行调用A.new，这将引发异常。

同样，模块不能被实例化，但是它们也不能被继承。将新方法设为私有也将不起作用。有指针吗？

我不喜欢在Ruby中使用抽象类（几乎总是有更好的方法）。如果您确实认为这是针对这种情况的最佳技术，则可以使用以下代码段来更明确地声明哪些方法是抽象的：

module Abstract
  def abstract_methods(*args)
    args.each do |name|
      class_eval(<<-END, __FILE__, __LINE__)
        def #{name}(*args)
          raise NotImplementedError.new("You must implement #{name}.")
        end
      END
      # important that this END is capitalized, since it marks the end of <<-END
    end
  end
end

require 'rubygems'
require 'rspec'

describe "abstract methods" do
  before(:each) do
    @klass = Class.new do
      extend Abstract

      abstract_methods :foo, :bar
    end
  end

  it "raises NoMethodError" do
    proc {
      @klass.new.foo
    }.should raise_error(NoMethodError)
  end

  it "can be overridden" do
    subclass = Class.new(@klass) do
      def foo
        :overridden
      end
    end

    subclass.new.foo.should == :overridden
  end
end

基本上，您只需abstract_methods使用抽象方法的列表进行调用，并且当它们被抽象类的实例调用时，NotImplementedError将引发异常。

我只是想在这里晚些时候发出警报，我认为没有理由阻止某人实例化抽象类，尤其是因为他们可以动态地向其添加方法。

鸭式语言（如Ruby）在运行时使用方法的存在/不存在或行为来确定是否应调用它们。因此，您的问题（适用于抽象方法）很有意义

def get_db_name
   raise 'this method should be overriden and return the db name'
end

那应该是故事的结局。在Java中使用抽象类的唯一原因是要坚持某些方法被“填充”，而其他方法则在抽象类中具有其行为。在鸭子式语言中，重点放在方法上，而不是在类/类型上，因此您应该将担忧转移到该级别。

在您的问题中，您基本上是在尝试abstract从Java 重新创建关键字，这是在Ruby中使用Java的代码气味。

试试这个：

class A
  def initialize
    raise 'Doh! You are trying to instantiate an abstract class!'
  end
end

class B < A
  def initialize
  end
end

class A
  private_class_method :new
end

class B < A
  public_class_method :new
end

对于Rails世界中的任何人，都可以通过在模型文件中使用以下声明来将ActiveRecord模型实现为抽象类：

self.abstract_class = true

我的2分：我选择一种简单，轻巧的DSL混合：

module Abstract
  extend ActiveSupport::Concern

  included do

    # Interface for declaratively indicating that one or more methods are to be
    # treated as abstract methods, only to be implemented in child classes.
    #
    # Arguments:
    # - methods (Symbol or Array) list of method names to be treated as
    #   abstract base methods
    #
    def self.abstract_methods(*methods)
      methods.each do |method_name|

        define_method method_name do
          raise NotImplementedError, 'This is an abstract base method. Implement in your subclass.'
        end

      end
    end

  end

end

# Usage:
class AbstractBaseWidget
  include Abstract
  abstract_methods :widgetify
end

class SpecialWidget < AbstractBaseWidget
end

SpecialWidget.new.widgetify # <= raises NotImplementedError

当然，在这种情况下，添加另一个错误来初始化基类将是微不足道的。

在Ruby的过去6 1/2年中，我不需要一次抽象类。

如果您认为需要一个抽象类，那么您在使用提供/要求它们的语言中考虑过多，而不是在Ruby中。

正如其他人所建议的，mixin更适合于应该是接口的事物（如Java定义的那样），而重新思考设计则更适合于“需要”来自其他语言（例如C ++）的抽象类的事物。

2019年更新：在使用16½年的时间里，我不需要Ruby中的抽象类。通过实际学习Ruby并使用适当的工具（例如模块（甚至为您提供通用的实现））可以解决所有在我的回应中发表评论的人们所回答的所有问题。我管理的团队中有一些人创建的基类实现失败的类（例如抽象类），但是这些大多数都是在浪费代码，因为它们NoMethodError会产生与生产中完全相同的结果AbstractClassError。

您可以尝试3个rubygems：
接口
摘要
简单摘要

我个人在抽象类的方法中提出NotImplementedError。但是出于您提到的原因，您可能希望将其保留在“新”方法之外。

如果要使用无法实例化的类，请在A.new方法中，在引发错误之前检查self ==A。

但是实际上，模块似乎更像您在这里想要的-例如，Enumerable是可能是其他语言中的抽象类的一种东西。从技术上讲，您不能将它们归类，但是调用include SomeModule可以达到大致相同的目标。是否出于某些原因对您不起作用？

您试图为抽象类提供服务的目的是什么？用红宝石可能有更好的方法，但是您没有提供任何细节。

我的指针是这个；使用混合而不是继承。

另一个答案：

module Abstract
  def self.append_features(klass)
    # access an object's copy of its class's methods & such
    metaclass = lambda { |obj| class << obj; self ; end }

    metaclass[klass].instance_eval do
      old_new = instance_method(:new)
      undef_method :new

      define_method(:inherited) do |subklass|
        metaclass[subklass].instance_eval do
          define_method(:new, old_new)
        end
      end
    end
  end
end

这依赖于常规的#method_missing报告未实现的方法，但是使抽象类无法实现（即使它们具有initialize方法）

class A
  include Abstract
end
class B < A
end

B.new #=> #<B:0x24ea0>
A.new # raises #<NoMethodError: undefined method `new' for A:Class>

就像其他张贴者所说的那样，您可能应该使用mixin而不是抽象类。

我是这样做的，所以它在子类上重新定义了new，以在非抽象类上找到了新的。我仍然看不到在ruby中使用抽象类的任何实践。

puts 'test inheritance'
module Abstract
  def new
    throw 'abstract!'
  end
  def inherited(child)
    @abstract = true
    puts 'inherited'
    non_abstract_parent = self.superclass;
    while non_abstract_parent.instance_eval {@abstract}
      non_abstract_parent = non_abstract_parent.superclass
    end
    puts "Non abstract superclass is #{non_abstract_parent}"
    (class << child;self;end).instance_eval do
      define_method :new, non_abstract_parent.method('new')
      # # Or this can be done in this style:
      # define_method :new do |*args,&block|
        # non_abstract_parent.method('new').unbind.bind(self).call(*args,&block)
      # end
    end
  end
end

class AbstractParent
  extend Abstract
  def initialize
    puts 'parent initializer'
  end
end

class Child < AbstractParent
  def initialize
    puts 'child initializer'
    super
  end
end

# AbstractParent.new
puts Child.new

class AbstractChild < AbstractParent
  extend Abstract
end

class Child2 < AbstractChild

end
puts Child2.new

还有一个小abstract_type瑰宝，允许以不显眼的方式声明抽象类和模块。

示例（来自README.md文件）：

class Foo
  include AbstractType

  # Declare abstract instance method
  abstract_method :bar

  # Declare abstract singleton method
  abstract_singleton_method :baz
end

Foo.new  # raises NotImplementedError: Foo is an abstract type
Foo.baz  # raises NotImplementedError: Foo.baz is not implemented

# Subclassing to allow instantiation
class Baz < Foo; end

object = Baz.new
object.bar  # raises NotImplementedError: Baz#bar is not implemented

您的方法没有错。只要您的所有子类都覆盖了初始化，那么引发初始化错误似乎就可以了。但是您不想这样定义self.new。这就是我要做的。

class A
  class AbstractClassInstiationError < RuntimeError; end
  def initialize
    raise AbstractClassInstiationError, "Cannot instantiate this class directly, etc..."
  end
end

另一种方法是将所有这些功能放在一个模块中，就像您提到的那样，它永远不会被激活。然后将模块包含在您的类中，而不是从另一个类继承。但是，这会破坏诸如super之类的东西。

因此，这取决于您要如何构造它。尽管模块似乎是解决“如何编写一些供其他类使用的东西”问题的更干净的解决方案。

2行宝石：https：//rubygems.org/gems/abstract

尽管这听起来不像Ruby，但是您可以执行以下操作：

class A
  def initialize
    raise 'abstract class' if self.instance_of?(A)

    puts 'initialized'
  end
end

class B < A
end

结果：

>> A.new
  (rib):2:in `main'
  (rib):2:in `new'
  (rib):3:in `initialize'
RuntimeError: abstract class
>> B.new
initialized
=> #<B:0x00007f80620d8358>
>>