polimorfismo - que es una clase en ruby

¿Cómo implementar una clase abstracta en ruby?

Question

Sé que no existe un concepto de clase abstracta en ruby. Pero si es necesario implementarlo, ¿cómo hacerlo? Intenté algo como ...

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

class B < A
  ...
  ...
end

Pero cuando intento crear una instancia de B, internamente va a llamar a A.new que va a generar la excepción.

Además, los módulos no se pueden crear instancias, pero tampoco se pueden heredar. hacer que el nuevo método sea privado tampoco funcionará. ¿Alguna sugerencia?

Answer 1

¿Para qué intentas servir con una clase abstracta? Probablemente haya una mejor manera de hacerlo en ruby, pero no proporcionó ningún detalle.

Mi puntero es esto; usa un mixin no herencia.

Answer 2

En los últimos 6 1/2 años de programación de Ruby, no he necesitado una clase abstracta una vez.

Si estás pensando que necesitas una clase abstracta, estás pensando demasiado en un lenguaje que los proporciona / requiere, no en Ruby como tal.

Como otros han sugerido, un mixin es más apropiado para cosas que se supone que son interfaces (como Java las define), y repensar su diseño es más apropiado para cosas que "necesitan" clases abstractas de otros lenguajes como C ++.

Answer 3

Gema de 2 líneas: https://rubygems.org/gems/abstract

Answer 4

Lo hice de esta manera, por lo que redefine la clase nueva en el niño para encontrar una nueva en la clase no abstracta. Todavía no veo ninguna práctica en el uso de clases abstractas en 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

Answer 5

Mi 2 ¢: opto por una mezcla DSL simple y liviana:

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

Y, por supuesto, agregar otro error para inicializar la clase base sería trivial en este caso.

Answer 6

No hay nada malo con su enfoque. Generar un error al inicializar parece estar bien, siempre que todas las subclases anuladas se inicialicen, por supuesto. Pero no quieres definir self.new así. Esto es lo que haría.

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

Otro enfoque sería poner toda esa funcionalidad en un módulo, que como usted mencionó nunca puede ser instigado. Luego incluya el módulo en sus clases en lugar de heredar de otra clase. Sin embargo, esto rompería cosas como súper.

Entonces depende de cómo quieras estructurarlo. Aunque los módulos parecen una solución más limpia para resolver el problema de "¿Cómo escribo algunas cosas que está diseñado para otras clases?"

Answer 7

No me gusta usar clases abstractas en Ruby (casi siempre hay una mejor manera). Sin embargo, si realmente crees que es la mejor técnica para la situación, puedes usar el siguiente fragmento para ser más declarativo sobre qué métodos son abstractos:

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

Básicamente, simplemente llama a abstract_methods con la lista de métodos que son abstractos, y cuando una instancia de la clase abstracta los NotImplementedError , se NotImplementedError una excepción NotImplementedError .

Answer 8

Otra respuesta:

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

Esto se basa en el #method_missing normal para informar métodos no implementados, pero evita que se implementen clases abstractas (incluso si tienen un método de inicialización)

class A
  include Abstract
end
class B < A
end

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

Como han dicho los otros carteles, probablemente deberías estar usando mixin, en lugar de una clase abstracta.

Answer 9

Personalmente elevo NotImplementedError en métodos de clases abstractas. Pero es posible que desee dejarlo fuera del ''nuevo'' método, por las razones que ha mencionado.

Answer 10

Prueba esto:

class A
  def initialize
    raise ''Doh! You are trying to instantiate an abstract class!''
  end
end

class B < A
  def initialize
  end
end

Answer 11

Puedes probar 3 rubygems:
interface
abstract
simple resumen

Answer 12

Si desea ir con una clase que no se puede desinstalar, en su método A.new, verifique si self == A antes de arrojar el error.

Pero, en realidad, un módulo se parece más a lo que quiere aquí; por ejemplo, Enumerable es el tipo de cosa que podría ser una clase abstracta en otros idiomas. Técnicamente no puede subclasificarlos, pero llamar include SomeModule logra aproximadamente el mismo objetivo. ¿Hay alguna razón por la que esto no funcionará para ti?

Answer 13

Solo para sonar aquí tarde, creo que no hay razón para evitar que alguien cree una instancia de la clase abstracta, especialmente porque pueden agregar métodos sobre la marcha .

Los lenguajes de pato, como Ruby, usan la presencia / ausencia o el comportamiento de los métodos en tiempo de ejecución para determinar si deben llamarse o no. Por lo tanto, su pregunta, tal como se aplica a un método abstracto, tiene sentido

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

y eso debería ser sobre el final de la historia. La única razón para usar clases abstractas en Java es insistir en que ciertos métodos se "completan" mientras que otros tienen su comportamiento en la clase abstracta. En un lenguaje de pato, el foco está en los métodos, no en las clases / tipos, por lo que debe mover sus preocupaciones a ese nivel.

En su pregunta, básicamente está tratando de recrear la palabra clave abstract de Java, que es un olor de código para hacer Java en Ruby.

Answer 14

También existe esta pequeña gema de tipo abstract_type , que permite declarar clases abstractas y módulos de una manera discreta.

Ejemplo (del archivo 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

Answer 15

para cualquier persona en el mundo de los rieles, la implementación de un modelo de ActiveRecord como clase abstracta se hace con esta declaración en el archivo de modelo:

self.abstract_class = true

Answer 16

class A
  private_class_method :new
end

class B < A
  public_class_method :new
end