Как реализовать абстрактный класс в 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 - настаивать на том, чтобы одни методы были «заполнены», в то время как другие имели свое поведение в абстрактном классе. В языке «утиного набора» основное внимание уделяется методам, а не классам / типам, поэтому вам следует переместить свои заботы на этот уровень.

В вашем вопросе вы в основном пытаетесь воссоздать abstractключевое слово из Java, которое является запахом кода для выполнения Java в Ruby.

Попробуй это:

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

для всех в мире рельсов реализация модели 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 мне ни разу не понадобился абстрактный класс.

Если вы думаете, что вам нужен абстрактный класс, вы слишком много думаете о языке, который их предоставляет / требует, а не о Ruby как таковом.

Как предлагали другие, миксин больше подходит для вещей, которые должны быть интерфейсами (как их определяет Java), а переосмысление вашего дизайна больше подходит для вещей, которым «нужны» абстрактные классы из других языков, таких как C ++.

Обновление 2019: мне не нужны абстрактные классы в Ruby за 16,5 лет использования. Все, что говорят все, кто комментирует мой ответ, решается путем фактического изучения 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>

Как было сказано на других плакатах, вам, вероятно, следует использовать миксин, а не абстрактный класс.

Я сделал это таким образом, поэтому он переопределяет новое в дочернем классе, чтобы найти новый в не абстрактном классе. Я до сих пор не вижу практического смысла в использовании абстрактных классов в 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

Другой подход заключался бы в том, чтобы поместить всю эту функциональность в модуль, который, как вы упомянули, никогда нельзя внедрить. Затем включите модуль в свои классы вместо наследования от другого класса. Однако это сломало бы такие вещи, как супер.

Так что это зависит от того, как вы хотите его структурировать. Хотя модули кажутся более чистым решением для решения проблемы «Как мне написать что-то, что предназначено для использования другими классами»

Двухстрочный гем: 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>
>>