blocks|key|1634172|text|我不喜欢在Ruby中使用抽象类(几乎总是有更好的方法)。如果您真的认为这是最适合这种情况的技术，那么您可以使用以下代码片段来更明确地说明哪些方法是抽象的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634173|module+Abstract
++def+abstract_methods(*args)
++++args.each+do+%7Cname%7C
++++++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|code-block|syntax|javascript|1634174|基本上，您只需使用抽象的方法列表调用abstract_methods，当它们被抽象类的实例调用时，将引发NotImplementedError异常。|offset|length|style|CODE|1634175|entityMap^0|0|0|I|G|1G|J|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

I don't like using abstract classes in Ruby (there's almost always a better way). If you really think it's the best technique for the situation though, you can use the following snippet to be more declarative about which methods are abstract:

<pre><code>module Abstract
 def abstract_methods(*args)
 args.each do |name|
 class_eval(&lt;&lt;-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 &lt;&lt;-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
</code></pre>

Basically, you just call <code>abstract_methods</code> with the list of methods that are abstract, and when they get called by an instance of the abstract class, a <code>NotImplementedError</code> exception will be raised.

blocks|key|1419431|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419432|class+A
++def+initialize
++++raise+'Doh!+You+are+trying+to+instantiate+an+abstract+class!'
++end
end

class+B+<+A
++def+initialize
++end
end|code-block|syntax|javascript|1419433|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this:

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

class B &lt; A
 def initialize
 end
end
</code></pre>

blocks|key|1419297|text|就我个人而言，我在抽象类的方法中引发NotImplementedError。但是由于你提到的原因，你可能想把它从'new‘方法中去掉。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419298|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Personally I raise NotImplementedError in methods of abstract classes. But you may want to leave it out of the 'new' method, for the reasons you mentioned.

blocks|key|1634215|text|你的方法没有错。在initialize中引发一个错误似乎没问题，当然，只要你所有的子类都覆盖了initialize。但是你不想这样定义self.new。这就是我要做的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634216|class+A
++class+AbstractClassInstiationError+<+RuntimeError;+end
++def+initialize
++++raise+AbstractClassInstiationError,+"Cannot+instantiate+this+class+directly,+etc..."
++end
end|code-block|syntax|javascript|1634217|另一种方法是将所有这些功能放在一个模块中，正如您所提到的，这永远不会被激发。然后将模块包含在您的类中，而不是从另一个类继承。然而，这会打破类似super这样的东西。|1634218|因此，这取决于您想要如何构建它。尽管模块看起来像是一种更干净的解决方案来解决“我该如何写一些设计给其他类使用的东西”的问题|1634219|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Nothing wrong with your approach. Raise an error in initialize seems fine, as long as all your subclasses override initialize of course. But you dont want to define self.new like that. Here's what I would do.

<pre><code>class A
 class AbstractClassInstiationError &lt; RuntimeError; end
 def initialize
 raise AbstractClassInstiationError, "Cannot instantiate this class directly, etc..."
 end
end
</code></pre>

Another approach would be put all that functionality in a module, which as you mentioned can never be instiated. Then include the module in your classes rather than inheriting from another class. However, this would break things like super.

So it depends on how you want to structure it. Although modules seem like a cleaner solution for solving the problem of "How do I write some stuff that is deigned for other classes to use"

blocks|key|1419468|text|如果你想使用一个不可实例化的类，在你的A.new方法中，在抛出错误之前检查一下self+==+A。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419469|但实际上，模块看起来更像是您在这里想要的-例如，Enumerable在其他语言中可能是一种抽象类。从技术上讲，您不能对它们进行子类化，但是调用include+SomeModule可以实现大致相同的目标。有什么原因这对你不起作用吗？|offset|length|style|CODE|1419470|entityMap^0|0|1Z|I|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

If you want to go with an uninstantiable class, in your A.new method, check if self == A before throwing the error.

But really, a module seems more like what you want here — for example, Enumerable is the sort of thing that might be an abstract class in other languages. You technically can't subclass them, but calling <code>include SomeModule</code> achieves roughly the same goal. Is there some reason this won't work for you?

blocks|key|1634316|text|您试图为抽象类服务的目的是什么？也许有一种更好的方法可以用ruby来实现，但是你没有给出任何细节。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634317|我的指针是这样的:使用mixin而不是继承。|offset|length|1634318|entityMap|0|LINK|mutability|MUTABLE|url|http://www.rubycentral.com/pickaxe/tut_modules.html^0|0|B|5|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

What purpose are you trying to serve with an abstract class? There is probably a better way to do it in ruby, but you didn't give any details.

My pointer is this; use a <a href="http://www.rubycentral.com/pickaxe/tut_modules.html" rel="noreferrer">mixin</a> not inheritance.

blocks|key|1419554|text|另一个答案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419555|module+Abstract
++def+self.append_features(klass)
++++#+access+an+object's+copy+of+its+class's+methods+&+such
++++metaclass+=+lambda+{+%7Cobj%7C+class+<<+obj;+self+;+end+}

++++metaclass[klass].instance_eval+do
++++++old_new+=+instance_method(:new)
++++++undef_method+:new

++++++define_method(:inherited)+do+%7Csubklass%7C
++++++++metaclass[subklass].instance_eval+do
++++++++++define_method(:new,+old_new)
++++++++end
++++++end
++++end
++end
end|code-block|syntax|javascript|1419556|这依赖于普通的#method_missing来报告未实现的方法，但会阻止抽象类的实现(即使它们有一个初始化方法)|1419557|class+A
++include+Abstract
end
class+B+<+A
end

B.new+#=>+#<B:0x24ea0>
A.new+#+raises+#<NoMethodError:+undefined+method+`new'+for+A:Class>|1419558|就像其他发帖者所说的那样，你可能应该使用一个混入，而不是一个抽象类。|1419559|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Another answer:

<pre><code>module Abstract
 def self.append_features(klass)
 # access an object's copy of its class's methods &amp; such
 metaclass = lambda { |obj| class &lt;&lt; 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
</code></pre>

This relies on the normal #method_missing to report unimplemented methods,
but keeps abstract classes from being implemented (even if they have an initialize method)

<pre><code>class A
 include Abstract
end
class B &lt; A
end

B.new #=&gt; #&lt;B:0x24ea0&gt;
A.new # raises #&lt;NoMethodError: undefined method `new' for A:Class&gt;
</code></pre>

Like the other posters have said, you should probably be using a mixin though, rather than an abstract class.

blocks|key|1634369|text|class+A
++private_class_method+:new
end

class+B+<+A
++public_class_method+:new
end|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1634370|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class A
 private_class_method :new
end

class B &lt; A
 public_class_method :new
end
</code></pre>

blocks|key|1634413|text|我这样做了，所以它在子类上重新定义了新的，以找到一个新的非抽象类。我仍然看不到在ruby中使用抽象类有什么实际意义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634414|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+%7C*args,&block%7C
++++++++#+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|code-block|syntax|javascript|1634415|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I did it this way, so it redefines new on child class to find a new on non abstract class.
I still don't see any practical in using abstract classes in ruby.

<pre><code>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 &lt;&lt; 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,&amp;block|
 # non_abstract_parent.method('new').unbind.bind(self).call(*args,&amp;block)
 # end
 end
 end
end

class AbstractParent
 extend Abstract
 def initialize
 puts 'parent initializer'
 end
end

class Child &lt; AbstractParent
 def initialize
 puts 'child initializer'
 super
 end
end

# AbstractParent.new
puts Child.new

class AbstractChild &lt; AbstractParent
 extend Abstract
end

class Child2 &lt; AbstractChild

end
puts Child2.new
</code></pre>

blocks|key|1419645|text|2行gem：https://rubygems.org/gems/abstract|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1419646|entityMap|0|LINK|mutability|MUTABLE|url|https://rubygems.org/gems/abstract^0|6|Y|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

2-lines gem : <a href="https://rubygems.org/gems/abstract" rel="nofollow">https://rubygems.org/gems/abstract</a>

blocks|key|1419696|text|你可以尝试3个rubygems：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419697|interface|offset|length|1419698|abstract|1419699|simple+abstract|1419700|entityMap|0|LINK|mutability|MUTABLE|url|http://rubygems.org/gems/interface|1|http://rubygems.org/gems/abstract|2|https://rubygems.org/gems/simple_abstract^0|0|0|9|0|0|0|8|1|0|0|F|2|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@$D|11|E|12|1|13]]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]|T|$5|M|N|O|A|$P|U]]]]

You can try 3 rubygems: 
<a href="http://rubygems.org/gems/interface" rel="noreferrer">interface</a> 
<a href="http://rubygems.org/gems/abstract" rel="noreferrer">abstract</a> 
<a href="https://rubygems.org/gems/simple_abstract" rel="noreferrer">simple abstract</a>

blocks|key|1419791|text|我的2美分:我选择了一个简单，轻量级的DSL混合：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419792|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+%7Cmethod_name%7C

++++++++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|code-block|syntax|javascript|1419793|当然，在这种情况下，添加另一个用于初始化基类的错误将是微不足道的。|1419794|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

My 2¢: I opt for a simple, lightweight DSL mixin:

<pre><code>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 &lt; AbstractBaseWidget
end

SpecialWidget.new.widgetify # &lt;= raises NotImplementedError
</code></pre>

And, of course, adding another error for initializing the base class would be trivial in this case.

blocks|key|1419849|text|还有一个小的abstract_type+gem，允许以一种简单的方式声明抽象类和模块。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1419850|示例(来自README.md文件)：|1419851|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|code-block|syntax|javascript|1419852|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/dkubb/abstract_type/blob/master/README.md^0|6|D|0|5|9|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

There's also this small <code>abstract_type</code> gem, allowing to declare abstract classes and modules in an unobstrusive way.

Example (from the <a href="https://github.com/dkubb/abstract_type/blob/master/README.md" rel="nofollow">README.md</a> file):

<pre><code>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 &lt; Foo; end

object = Baz.new
object.bar # raises NotImplementedError: Baz#bar is not implemented
</code></pre>

blocks|key|1419899|text|对于rails世界中的任何人来说，将ActiveRecord模型实现为抽象类都是通过模型文件中的以下声明完成的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419900|self.abstract_class+=+true|code-block|syntax|javascript|1419901|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

for anyone in the rails world, implementing an ActiveRecord model as an abstract class is done with this declaration in the model file:

<pre><code>self.abstract_class = true
</code></pre>

blocks|key|1419970|text|虽然这感觉不像Ruby，但您可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419971|class+A
++def+initialize
++++raise+'abstract+class'+if+self.instance_of?(A)

++++puts+'initialized'
++end
end

class+B+<+A
end|code-block|syntax|javascript|1419972|结果：|1419973|>>+A.new
++(rib):2:in+`main'
++(rib):2:in+`new'
++(rib):3:in+`initialize'
RuntimeError:+abstract+class
>>+B.new
initialized
=>+#<B:0x00007f80620d8358>
>>|1419974|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Though this doesn't feel like Ruby, you can do this:

<pre class="lang-rb prettyprint-override"><code>class A
 def initialize
 raise 'abstract class' if self.instance_of?(A)

 puts 'initialized'
 end
end

class B &lt; A
end
</code></pre>

The results:

<pre><code>&gt;&gt; A.new
 (rib):2:in `main'
 (rib):2:in `new'
 (rib):3:in `initialize'
RuntimeError: abstract class
&gt;&gt; B.new
initialized
=&gt; #&lt;B:0x00007f80620d8358&gt;
&gt;&gt;
</code></pre>

I know there is no concept of abstract class in ruby. But if at all it needs to be implemented, how to go about it? I tried something like...

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

class B &lt; A
 ...
 ...
end
</code></pre>

But when I try to instantiate B, it is internally going to call <code>A.new</code> which is going to raise the exception.

Also, modules cannot be instantiated but they cannot be inherited too. making the new method private will also not work. Any pointers?

How to implement an abstract class in ruby?

Java

我知道ruby中没有抽象类的概念。但是，如果它真的需要实现，该怎么做呢？我试过像这样的..。class A def self.new raise 'Doh! You are trying to write Java in Ruby!' endendclass B < A ... ...end但是当我尝试实...

问如何在ruby中实现抽象类？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在ruby中实现抽象类？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在ruby中实现抽象类？
EN