루비에서 추상 클래스를 구현하는 방법은 무엇입니까?

루비에는 추상 클래스의 개념이 없다는 것을 알고 있습니다. 하지만 구현해야한다면 어떻게해야할까요? 나는 다음과 같은 것을 시도했다.

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

물론이 경우 기본 클래스를 초기화하기 위해 다른 오류를 추가하는 것은 사소한 일입니다.

루비를 프로그래밍 한 지난 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>

다른 포스터가 말했듯이 추상 클래스보다는 믹스 인을 사용해야합니다.

나는 이런 식으로 그것을 했으므로, 비 추상 클래스에서 새로운 것을 찾기 위해 자식 클래스에서 새로운 것을 재정의합니다. 나는 여전히 루비에서 추상 클래스를 사용하는 데 실용적이지 않다.

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