Ruby'de soyut bir sınıf nasıl uygulanır?

Ruby'de soyut sınıf kavramı olmadığını biliyorum. Ama eğer uygulanması gerekiyorsa, nasıl yapılmalı? Bir şey denedim ...

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

class B < A
  ...
  ...
end

Ama B'yi somutlaştırmaya çalıştığımda, içsel A.newolarak istisnayı artıracak olan çağrı yapacak.

Ayrıca, modüller somutlaştırılamaz, ancak bunlar da miras alınamaz. yeni yöntemi özel yapmak da işe yaramayacaktır. Herhangi bir işaret var mı?

Ruby'de soyut sınıfları kullanmayı sevmiyorum (neredeyse her zaman daha iyi bir yol vardır). Durum için en iyi teknik olduğunu gerçekten düşünüyorsanız, hangi yöntemlerin soyut olduğu konusunda daha açıklayıcı olmak için aşağıdaki pasajı kullanabilirsiniz:

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

Temel olarak, sadece abstract_methodssoyut olan yöntemlerin listesiyle çağırırsınız ve soyut sınıfın bir örneği tarafından çağrıldıklarında, bir NotImplementedErroristisna ortaya çıkar.

Buraya geç gelmek için, birisinin soyut sınıfı somutlaştırmasını engellemenin bir nedeni olmadığını düşünüyorum, özellikle de ona anında yöntemler ekleyebildikleri için .

Ruby gibi Duck-typing dilleri, çağrılmaları gerekip gerekmediğini belirlemek için çalışma zamanında yöntemlerin varlığını / yokluğunu veya davranışını kullanır. Bu nedenle sorunuz, soyut bir yöntem için geçerli olduğundan mantıklıdır

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

ve bu hikayenin sonu olmalı. Java'da soyut sınıfları kullanmanın tek nedeni, bazı yöntemlerin "doldurulduğunda" diğerlerinin davranışlarını soyut sınıfta tuttuğunda ısrar etmektir. Ördek yazma dilinde, odak sınıflara / türlere değil yöntemlere odaklanır, bu nedenle endişelerinizi bu seviyeye taşımalısınız.

Sorunuzda, temel olarak abstractanahtar kelimeyi Ruby'de Java yapmak için bir kod kokusu olan Java'dan yeniden oluşturmaya çalışıyorsunuz .

Bunu dene:

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 dünyasındaki herkes için, bir ActiveRecord modelinin soyut sınıf olarak uygulanması, model dosyasındaki şu bildirimle yapılır:

self.abstract_class = true

2 ¢'m: Basit, hafif bir DSL karışımını tercih ediyorum:

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

Ve tabii ki, temel sınıfı başlatmak için başka bir hata eklemek bu durumda önemsiz olacaktır.

Ruby'yi programlamanın son 6 1/2 yılında ihtiyacım olmadı bir kez soyut bir sınıfa .

Soyut bir sınıfa ihtiyacınız olduğunu düşünüyorsanız, Ruby'de değil, bunları sağlayan / gerektiren bir dilde çok fazla düşünüyorsunuz.

Diğerlerinin de önerdiği gibi, bir mixin arayüz olması gereken şeyler için daha uygundur (Java'nın tanımladığı gibi) ve tasarımınızı yeniden düşünmek, C ++ gibi diğer dillerden soyut sınıflara "ihtiyaç duyan" şeyler için daha uygundur.

2019 Güncellemesi: 16½ yıldır Ruby'de soyut sınıflara ihtiyacım olmadı. Yanıtım hakkında yorum yapan herkesin söylediği her şey, Ruby'yi öğrenerek ve modüller gibi uygun araçları kullanarak (hatta size ortak uygulamalar sağlayan) ele alınmaktadır. Yönettiğim ekiplerde, başarısız olan (soyut bir sınıf gibi) temel uygulamaya sahip sınıflar yaratan insanlar var, ancak bunlar çoğunlukla bir kodlama israfı çünkü üretimde NoMethodErrorbir ile aynı sonucu üretecekler AbstractClassError.

3 rubygem deneyebilirsiniz:
arayüz
özeti
basit soyut

Kişisel olarak, soyut sınıfların yöntemlerinde NotImplementedError'ı yükseltiyorum. Ancak bahsettiğiniz nedenlerden dolayı onu 'yeni' yöntemin dışında bırakmak isteyebilirsiniz.

Özgünleştirilemeyen bir sınıfla gitmek istiyorsanız, yeni yönteminizde, hatayı atmadan önce self == A olup olmadığını kontrol edin.

Ama gerçekte, bir modül burada istediğiniz gibi görünüyor - örneğin, Numaralandırılabilir diğer dillerde soyut bir sınıf olabilecek türden bir şey. Teknik olarak alt sınıflara giremezsiniz, ancak çağırmak include SomeModuleaşağı yukarı aynı amaca ulaşır. Bunun sizin için işe yaramamasının bir nedeni var mı?

Soyut bir sınıfla hangi amaca hizmet etmeye çalışıyorsunuz? Bunu yakutla yapmanın muhtemelen daha iyi bir yolu vardır, ancak herhangi bir ayrıntı vermediniz.

İşaretçim bu; kalıtım değil bir mixin kullanın .

Başka bir cevap:

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

Bu, uygulanmamış yöntemleri bildirmek için normal #method_missing'e dayanır, ancak soyut sınıfların uygulanmasını engeller (bir başlatma yöntemine sahip olsalar bile)

class A
  include Abstract
end
class B < A
end

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

Diğer afişlerin de söylediği gibi, muhtemelen soyut bir sınıf yerine bir mixin kullanmalısınız.

Bunu bu şekilde yaptım, bu yüzden soyut olmayan sınıfta yeni bir şey bulmak için çocuk sınıfında yeniyi yeniden tanımlıyor. Ruby'de soyut sınıfları kullanmanın hala pratik olduğunu görmüyorum.

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

Ayrıca abstract_type, soyut sınıfları ve modülleri göze çarpmayan bir şekilde bildirmeye izin veren bu küçük mücevher de var .

Örnek ( README.md dosyasından):

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

Yaklaşımınızda yanlış bir şey yok. Tüm alt sınıflarınız başlatıldıkça, başlatma sırasında bir hatanın yükseltilmesi iyi görünüyor. Ama kendini böyle tanımlamak istemezsin. İşte yapacağım şey.

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

Başka bir yaklaşım, tüm bu işlevselliği, bahsettiğiniz gibi hiçbir zaman başlatılamayacak bir modüle koymak olacaktır. Ardından, başka bir sınıftan miras almak yerine modülü sınıflarınıza dahil edin. Ancak bu, süper gibi şeyleri bozar.

Yani onu nasıl yapılandırmak istediğinize bağlı. Modüller, "Diğer sınıfların kullanması için tasarlanmış bazı şeyleri nasıl yazabilirim" sorununu çözmek için daha temiz bir çözüm gibi görünse de

2 satırlı mücevher: https://rubygems.org/gems/abstract

Bu Ruby gibi hissettirmese de, bunu yapabilirsiniz:

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

    puts 'initialized'
  end
end

class B < A
end

Sonuçlar:

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