Rubyで抽象クラスを実装する方法は？

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で抽象クラスを使用する唯一の理由は、特定のメソッドが「塗りつぶされる」一方で、他のメソッドは抽象クラスで動作することを主張することです。ダックタイピング言語では、焦点はクラス/タイプではなくメソッドにあるので、心配はそのレベルに移動する必要があります。

あなたの質問では、基本的にabstractJavaからキーワードを再作成しようとしています。これは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年半の間、私は抽象クラスを一度も必要としませんでした。

抽象クラスが必要だと考えている場合、Ruby自体ではなく、抽象クラスを提供/要求する言語で考えすぎています。

他の人が示唆しているように、ミックスインはインターフェース（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に依存しますが、抽象クラスが実装されないようにします（初期化メソッドがある場合でも）

class A
  include Abstract
end
class B < A
end

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

他のポスターが言ったように、あなたはおそらく抽象クラスではなくミックスインを使うべきです。

私はそれをこのようにしたので、新しいon子クラスを再定義して、新しいon非抽象クラスを見つけます。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

別のアプローチでは、すべての機能をモジュールに配置します。これは、前述したように、決して実行できません。次に、別のクラスから継承するのではなく、モジュールをクラスに含めます。しかし、これはスーパーのようなものを壊します。

したがって、それをどのように構成するかによって異なります。モジュールは「他のクラスが使用できるように設計されたものをどのように書くのですか」の問題を解決するためのより明確な解決策のように見えますが

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>
>>