如何创建“类簇” （带有具体子类实例的工厂类）在 Ruby 中？

Question

我想创建一个抽象类，它将根据初始化参数创建具体实例。示例：

class SomethingGeneric
def self.new(type, arg)

    class_name = "#{type.capitalize}Something"

    if obj.const_defined?(class_name)
        a_class = obj.const_get(class_name)
    else
        raise ArgumentError, "Concrete something '#{type}' was not found"
    end

    obj = a_class.new(arg)

    return obj
end
end # class

那么我想要 FooSomething < SomethingGeneric，BarSomething <一些通用的东西等等。然后当我这样做时：

obj = SomethingGeneric.new("foo", arg)

我会得到 FooSomething 实例。

我的问题是“新”方法。我已经定义了 SomethingGeneric.new，但是 FooSomething 和 BarSomething 是 SomethingGeneric 的子类，因此它们继承了“new”方法，该方法在此处使用错误的参数调用：

obj = a_class.new(arg)

解决方案之一是为工厂方法“new”使用另一个名称。不过，我想坚持方便并保留名为“new”的抽象超类工厂方法。

解决这个问题最干净、正确的方法是什么？

Answer 1

你的新方法应该采用一个参数：*args，

你需要从数组中获取第一个项目作为你的类型var，然后从数组中删除该项目，这样你就可以将其余的参数传递给下一个新的参数称呼。

Array#shift 将为您提供第一个项目，然后将其删除。

class SomethingGeneric
  def self.new(*args)

    type = args.shift
    class_name = "#{type.capitalize}Something"

    if obj.const_defined?(class_name)
        a_class = obj.const_get(class_name)
    else
        raise ArgumentError, "Concrete something '#{type}' was not found"
    end

    obj = a_class.new(*args)

    return obj
  end
end # class

Answer 2

真正的问题是你需要这种行为的目的是什么？看起来您来自像 Java 这样的语言，其中工厂之类的东西是常态。您是否需要这种行为以便知道该对象将对您将要使用的特定方法做出响应？使用接口怎么样？

类似的事情：

class GenericThing
  def name # Interface method
     # Return a String of the name of the GenericThing.
  end
end

class GenericSomething
  def name
    # ...
   end
 end

 class Whatever
   def self.method_that_uses_the_generic_interface(generic)
     if generic.respond_to?(:name) # Check for interface compliance
       generic.name
     else
        raise "Generic must implement the name method."
     end
   end
 end

如果你真的想使用抽象类，你可以这样做：

class AbstractGeneric
  def name
    raise "You must override name in subclasses!"
  end

 class GenericThing < AbstractGeneric
   def name
     "GenericThing"
    end
 end

 class GenericSomething < AbstractGeneric
   # ...
 end

 class Whatever
   def self.method_that_uses_the_generic_interface(generic)
     if generic.kind_of? AbstractGeneric
       generic.name
       # Will raise if the interface method hasn't been overridden in subclass.
     else
       raise "Must be a instance of a subclass of AbstractGeneric!"
     end
   end
 end

在这种情况下，行为将是这样的：

generic_thing = GenericThing.new
Whatever.method_that_uses_the_generic_interface(generic_thing)
=> "GenericThing"

generic_something = GenericSomething.new
Whatever.method_that_uses_the_generic_interface(generic_something)
# Will raise "You must override name in subclass!"

object = Object.new
Whatever.method_that_uses_the_generic_interface(object)
# Will raise "Must be an instance of a subclass of AbstractGeneric!"