Jak zaimplementować klasę abstrakcyjną w Rubim?

Wiem, że w rubinie nie ma pojęcia klasy abstrakcyjnej. Ale jeśli w ogóle trzeba to wdrożyć, jak się do tego zabrać? Próbowałem czegoś takiego ...

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

class B < A
  ...
  ...
end

Ale kiedy próbuję utworzyć wystąpienie B, wewnętrznie wywoła to wywołanie, A.newktóre spowoduje zgłoszenie wyjątku.

Ponadto nie można tworzyć instancji modułów, ale nie można ich również dziedziczyć. ustawienie nowej metody jako prywatnej również nie zadziała. Jakieś wskazówki?

Nie lubię używać klas abstrakcyjnych w Rubim (prawie zawsze jest lepszy sposób). Jeśli jednak naprawdę uważasz, że jest to najlepsza technika w tej sytuacji, możesz użyć następującego fragmentu kodu, aby bardziej zadeklarować, które metody są abstrakcyjne:

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

Zasadniczo wystarczy wywołać abstract_methodslistę metod, które są abstrakcyjne, a gdy zostaną wywołane przez instancję klasy abstrakcyjnej, NotImplementedErrorzostanie zgłoszony wyjątek.

Żeby zadzwonić późno, myślę, że nie ma powodu, aby powstrzymywać kogoś przed utworzeniem instancji klasy abstrakcyjnej, zwłaszcza że mogą dodawać do niej metody w locie .

Języki typu kaczego, takie jak Ruby, używają obecności / braku lub zachowania metod w czasie wykonywania, aby określić, czy powinny być wywoływane, czy nie. Dlatego twoje pytanie, w odniesieniu do metody abstrakcyjnej , ma sens

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

a to powinno dotyczyć końca historii. Jedynym powodem używania klas abstrakcyjnych w Javie jest naleganie, aby niektóre metody były „wypełniane”, podczas gdy inne zachowywały się w klasie abstrakcyjnej. W języku pisania kaczkami nacisk kładzie się na metody, a nie na klasy / typy, więc powinieneś przenieść swoje zmartwienia na ten poziom.

W swoim pytaniu zasadniczo próbujesz odtworzyć abstractsłowo kluczowe z Javy, które jest zapachem kodu do robienia Javy w Rubim.

Spróbuj tego:

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

dla każdego w świecie railsów implementacja modelu ActiveRecord jako klasy abstrakcyjnej jest wykonywana z następującą deklaracją w pliku modelu:

self.abstract_class = true

Moje 2 ¢: wybieram prostą, lekką mieszankę 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

I oczywiście dodanie kolejnego błędu przy inicjalizacji klasy bazowej byłoby w tym przypadku trywialne.

Przez ostatnie półtora roku programowania w Rubim ani razu nie potrzebowałem klasy abstrakcyjnej.

Jeśli myślisz, że potrzebujesz klasy abstrakcyjnej, myślisz za dużo w języku, który ich dostarcza / wymaga, a nie w języku Ruby jako takim.

Jak sugerowali inni, mixin jest bardziej odpowiedni dla rzeczy, które mają być interfejsami (tak jak definiuje je Java), a przemyślenie projektu jest bardziej odpowiednie dla rzeczy, które „potrzebują” abstrakcyjnych klas z innych języków, takich jak C ++.

Aktualizacja 2019: Nie potrzebowałem klas abstrakcyjnych w Rubim od 16 i pół roku użytkowania. Wszystko, co mówią wszyscy ludzie komentujący moją odpowiedź, jest omówione przez faktyczną naukę języka Ruby i użycie odpowiednich narzędzi, takich jak moduły (które nawet zapewniają powszechne implementacje). W zespołach, którymi zarządzałem, są ludzie, którzy stworzyli klasy, których podstawowa implementacja kończy się niepowodzeniem (jak klasa abstrakcyjna), ale są to głównie marnowanie kodu, ponieważ NoMethodErrordałyby dokładnie taki sam wynik jak AbstractClassErrorw produkcji.

Możesz wypróbować 3 rubygemy:
interfejs
streszczenie
proste streszczenie

Osobiście zgłaszam NotImplementedError w metodach klas abstrakcyjnych. Ale możesz zechcieć wykluczyć to z „nowej” metody z powodów, o których wspomniałeś.

Jeśli chcesz przejść z klasą niemożliwą do zainstalowania, w swojej metodzie A.new sprawdź, czy self == A przed wyrzuceniem błędu.

Ale tak naprawdę moduł wydaje się bardziej podobny do tego, co chcesz tutaj - na przykład Enumerable jest czymś, co może być klasą abstrakcyjną w innych językach. Technicznie nie można ich podklasy, ale dzwonienie include SomeModulepozwala osiągnąć mniej więcej ten sam cel. Czy jest jakiś powód, dla którego to nie zadziała?

Czemu starasz się służyć klasie abstrakcyjnej? Prawdopodobnie jest lepszy sposób na zrobienie tego w rubinie, ale nie podałeś żadnych szczegółów.

Mój wskaźnik jest taki; użyj mieszanki, a nie dziedziczenia.

Inna odpowiedź:

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

Opiera się to na normalnym #method_missing do zgłaszania niezaimplementowanych metod, ale zapobiega implementacji klas abstrakcyjnych (nawet jeśli mają metodę inicjalizacji)

class A
  include Abstract
end
class B < A
end

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

Tak jak powiedzieli inni plakaty, prawdopodobnie powinieneś używać mieszanki, a nie klasy abstrakcyjnej.

Zrobiłem to w ten sposób, więc na nowo definiuje nową klasę potomną, aby znaleźć nową klasę nieabstrakcyjną. Nadal nie widzę praktycznego zastosowania klas abstrakcyjnych w języku 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

Jest też ten mały abstract_typeklejnot, który pozwala deklarować abstrakcyjne klasy i moduły w dyskretny sposób.

Przykład (z pliku 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

Nie ma nic złego w Twoim podejściu. Zgłoszenie błędu podczas inicjalizacji wydaje się być w porządku, o ile wszystkie podklasy oczywiście zastępują inicjalizację. Ale nie chcesz tak definiować siebie. Nowego. Oto, co bym zrobił.

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

Innym podejściem byłoby umieszczenie całej tej funkcjonalności w module, którego, jak wspomniałeś, nigdy nie można zainicjować. Następnie włącz moduł do swoich klas, zamiast dziedziczyć po innej klasie. Jednak to zepsułoby rzeczy takie jak super.

To zależy od tego, jak chcesz to zorganizować. Chociaż moduły wydają się czystszym rozwiązaniem problemu „Jak napisać coś, co jest przeznaczone do użycia przez inne klasy”

Klejnot 2-liniowy: https://rubygems.org/gems/abstract

Chociaż to nie wygląda jak Ruby, możesz to zrobić:

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

    puts 'initialized'
  end
end

class B < A
end

Wyniki:

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