c# - una - ¿Cómo se hace el polimorfismo en Ruby?

interfaces con c#

Question

En C #, puedo hacer esto:

class Program
{
    static void Main(string[] args)
    {
        List<Animal> animals = new List<Animal>();

        animals.Add(new Dog());
        animals.Add(new Cat());

        foreach (Animal a in animals)
        {
            Console.WriteLine(a.MakeNoise());
            a.Sleep();
        }
    }
}

public class Animal
{
    public virtual string MakeNoise() { return String.Empty; }
    public void Sleep()
    {
        Console.Writeline(this.GetType().ToString() + " is sleeping.");
    }
}

public class Dog : Animal
{
    public override string MakeNoise()
    {
        return "Woof!";
    }
}

public class Cat : Animal
{
    public override string MakeNoise()
    {
        return "Meow!";
    }
}

Obviamente, el resultado es (ligeramente parafraseado):

• Guau
• Perro está durmiendo
• maullar
• Cat está durmiendo

Dado que C # a menudo se burla de su sintaxis de tipo detallado, ¿cómo manejas el polimorfismo / los métodos virtuales en un lenguaje de tipo pato como Ruby?

Answer 1

Así es como lo escribiría:

class Animal
  def make_noise; '''' end
  def sleep; puts "#{self.class.name} is sleeping." end
end

class Dog < Animal; def make_noise; ''Woof!'' end end
class Cat < Animal; def make_noise; ''Meow!'' end end

[Dog.new, Cat.new].each do |animal|
  puts animal.make_noise
  animal.sleep
end

No es realmente diferente de las otras soluciones, pero este es el estilo que preferiría.

Eso es 12 líneas vs. 41 líneas (en realidad, puedes cortar 3 líneas usando un inicializador de colección) del ejemplo original de C #. ¡No está mal!

Answer 2

Sobre la base de la respuesta anterior, ¿así es como puedes hacerlo?

Segundo corte después de la aclaración:

class Animal
    def MakeNoise
        raise NotImplementedError # I don''t remember the exact error class
    end
    def Sleep
        puts self.class.to_s + " is sleeping."
    end
end

class Dog < Animal
    def MakeNoise
        return "Woof!"
    end
end

class Cat < Animal
    def MakeNoise
        return "Meow!"
    end
end

animals = [Dog.new, Cat.new]
animals.each {|a|
    puts a.MakeNoise
    a.Sleep
}

(Dejaré esto como está, pero "self.class.name" gana a ".to_s")

Answer 3

Todas las respuestas hasta ahora se ven bastante bien para mí. Pensé que solo mencionaría que toda la herencia no es del todo necesaria. Excluyendo el comportamiento de "dormir" por un momento, podemos lograr el resultado deseado utilizando el pato-tipado y omitiendo la necesidad de crear una clase base Animal. Buscar en Google para "pato-mecanografiar" debería arrojar cualquier cantidad de explicaciones, así que para aquí solo digamos "si camina como un pato y grazna como un pato ..."

El comportamiento de "dormir" podría proporcionarse mediante el uso de un módulo de mixin, como Array, Hash y otras clases incorporadas de Ruby inclue Enumerable. No estoy sugiriendo que sea necesariamente mejor, solo una forma diferente y tal vez más idiomática de Ruby de hacerlo.

module Animal
  def sleep
    puts self.class.name + " sleeps"
  end
end

class Dog
  include Animal
  def make_noise
    puts "Woof"
  end
end

class Cat
  include Animal
  def make_noise
    puts "Meow"
  end
end

Tu sabes el resto...

Answer 4

editar: agregó más código para su pregunta actualizada

descargo de responsabilidad: no he usado Ruby en un año más o menos, y no lo tengo instalado en esta máquina, por lo que la sintaxis puede ser completamente incorrecta. Pero los conceptos son correctos.

Exactamente de la misma manera, con clases y métodos anulados:

class Animal
    def MakeNoise
        return ""
    end
    def Sleep
        print self.class.name + " is sleeping./n"
    end
end

class Dog < Animal
    def MakeNoise
        return "Woof!"
    end
end

class Cat < Animal
    def MakeNoise
        return "Meow!"
    end
end

animals = [Dog.new, Cat.new]
animals.each {|a|
    print a.MakeNoise + "/n"
    a.Sleep
}

Answer 5

El principio de tipaje de pato es solo que el objeto tiene que responder a los métodos llamados. Entonces algo como eso también puede hacer el truco:

module Sleeping
  def sleep; puts "#{self} sleeps"
end

dog = "Dog"
dog.extend Sleeping
class << dog
  def make_noise; puts "Woof!" end
end

class Cat
  include Sleeping
  def to_s; "Cat" end
  def make_noise; puts "Meow!" end
end

[dog, Cat.new].each do |a|
  a.sleep
  a.make_noise
end

Answer 6

Una pequeña variante de la solución de manveru que crea dinámicamente diferentes tipos de objetos basados ​​en una variedad de tipos de clase. No es realmente diferente, solo un poco más claro.

Species = [Dog, Cat]

Species.each do |specie|
  animal = specie.new   # this will create a different specie on each call of new
  print animal.MakeNoise + "/n"
  animal.Sleep
end

Answer 7

Hay un método que implementa un polimorfismo (al hacer frente a todas las variables de instancia de una clase determinada a una nueva)

class Animal
  attr_reader :name

  def initialize(name = nil)
    @name = name
  end

  def make_noise
    ''''
  end

  def becomes(klass)
    became = klass.new
    became.instance_variables.each do |instance_variable|
      value = self.instance_variable_get(instance_variable)
      became.instance_variable_set(instance_variable, value)
    end

    became
  end
end

class Dog < Animal
  def make_noise
    ''Woof''
  end
end

class Cat < Animal
  def make_noise
    ''Meow''
  end
end

animals = [Dog.new(''Spot''), Cat.new(''Tom'')]

animals.each do |animal|
  new_animal = animal.becomes(Cat)
  puts "#{animal.class} with name #{animal.name} becomes #{new_animal.class}"
  puts "and makes a noise: #{new_animal.make_noise}"
  puts ''----''
end

y el resultado es:

Dog with name Spot becomes Cat
and makes a noise: Meow
----
Cat with name Tom becomes Cat
and makes a noise: Meow
----

• Un polimorfismo podría ser útil para evitar la declaración if ( antiifcampaign.com )

• Si usa RubyOnRails becomes método ya implementado: se becomes

• Sugerencia rápida: si mezclas el polimorfismo con STI te ofrece el combo más eficiente para refactorizar tu código

Ojalá te haya ayudado

Answer 8

Uso de Ruby idiomático

class Animal
  def sleep
    puts "#{self.class} is sleeping"
  end
end

class Dog < Animal
  def make_noise
    "Woof!"
  end
end

class Cat < Animal
  def make_noise
    "Meow!"
  end
end

[Dog, Cat].each do |clazz|
  animal = clazz.new
  puts animal.make_noise
  animal.sleep
end