วิธีการใช้คลาสนามธรรมในทับทิม?

ฉันรู้ว่าไม่มีแนวคิดเรื่องชนชั้นนามธรรมในทับทิม แต่ถ้าจำเป็นต้องมีการดำเนินการจะดำเนินการอย่างไร? ฉันลองทำสิ่งที่ชอบ ...

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

class B < A
  ...
  ...
end

แต่เมื่อฉันพยายามสร้างอินสแตนซ์ B มันกำลังจะเรียกภายในA.newซึ่งจะเพิ่มข้อยกเว้น

นอกจากนี้โมดูลไม่สามารถสร้างอินสแตนซ์ได้ แต่ไม่สามารถสืบทอดได้เช่นกัน การทำให้วิธีการใหม่เป็นแบบส่วนตัวจะไม่ได้ผลเช่นกัน คำแนะนำใด ๆ

ฉันไม่ชอบใช้คลาสนามธรรมใน Ruby (แทบจะมีวิธีที่ดีกว่าเสมอ) หากคุณคิดว่าเป็นเทคนิคที่ดีที่สุดสำหรับสถานการณ์คุณสามารถใช้ตัวอย่างต่อไปนี้เพื่ออธิบายเพิ่มเติมว่าวิธีการใดเป็นนามธรรม:

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

โดยพื้นฐานแล้วคุณจะเรียกabstract_methodsด้วยรายการวิธีการที่เป็นนามธรรมและเมื่อพวกเขาถูกเรียกโดยอินสแตนซ์ของคลาสนามธรรมNotImplementedErrorจะมีการเพิ่มข้อยกเว้น

เพียงเพื่อตีระฆังในช่วงปลายปีที่นี่ผมคิดว่ามีเหตุผลที่จะหยุดใครบางคนจากอินสแตนซ์ระดับนามธรรมไม่มีโดยเฉพาะอย่างยิ่งเพราะพวกเขาสามารถเพิ่มวิธีการได้ทันที

ภาษาเป็ดพิมพ์เช่น Ruby ใช้การมี / ไม่มีหรือพฤติกรรมของเมธอดในรันไทม์เพื่อพิจารณาว่าควรเรียกหรือไม่ ดังนั้นคำถามของคุณที่ใช้กับวิธีนามธรรมจึงสมเหตุสมผล

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

และนั่นควรจะเป็นตอนท้ายของเรื่อง เหตุผลเดียวที่ใช้คลาสนามธรรมใน Java คือการยืนยันว่าวิธีการบางอย่างได้รับการ "เติมเต็ม" ในขณะที่คนอื่นมีพฤติกรรมในคลาสนามธรรม ในภาษาพิมพ์เป็ดโฟกัสอยู่ที่วิธีการไม่ใช่ในชั้นเรียน / ประเภทดังนั้นคุณควรย้ายความกังวลไปที่ระดับนั้น

ในคำถามของคุณโดยพื้นฐานแล้วคุณกำลังพยายามสร้างabstractคำหลักจาก Java ซึ่งเป็นรหัสกลิ่นสำหรับการทำ Java ใน Ruby

ลองสิ่งนี้:

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

สำหรับทุกคนในโลกแห่งรางการใช้โมเดล ActiveRecord เป็นคลาสนามธรรมทำได้ด้วยการประกาศนี้ในไฟล์โมเดล:

self.abstract_class = true

2 ¢ของฉัน: ฉันเลือกมิกซ์อิน 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

และแน่นอนว่าการเพิ่มข้อผิดพลาดอื่นสำหรับการเริ่มต้นคลาสพื้นฐานจะเป็นเรื่องเล็กน้อยในกรณีนี้

ในช่วง 6 1/2 ปีที่ผ่านมาของการเขียนโปรแกรม Ruby ฉันไม่ต้องการคลาสนามธรรมเลยสักครั้ง

หากคุณคิดว่าคุณต้องการคลาสนามธรรมคุณกำลังคิดมากเกินไปในภาษาที่ให้ / ต้องการไม่ใช่ใน Ruby

ตามที่คนอื่น ๆ แนะนำมิกซ์อินเหมาะสมกว่าสำหรับสิ่งที่ควรจะเป็นอินเทอร์เฟซ (ตามที่ Java กำหนด) และการคิดใหม่ในการออกแบบของคุณจะเหมาะสมกว่าสำหรับสิ่งที่ "ต้องการ" คลาสนามธรรมจากภาษาอื่นเช่น C ++

อัปเดต 2019: ฉันไม่ต้องการคลาสนามธรรมใน Ruby ในการใช้งาน 16 ปี ทุกสิ่งที่คนทุกคนแสดงความคิดเห็นเกี่ยวกับคำตอบของฉันบอกว่าได้รับการแก้ไขโดยการเรียนรู้ Ruby และใช้เครื่องมือที่เหมาะสมเช่นโมดูล (ซึ่งให้การใช้งานทั่วไปแก่คุณด้วย) มีคนในทีมที่ฉันจัดการซึ่งได้สร้างคลาสที่มีการใช้งานพื้นฐานที่ล้มเหลว (เช่นคลาสนามธรรม) แต่สิ่งเหล่านี้ส่วนใหญ่เป็นการเสียการเข้ารหัสเพราะNoMethodErrorจะให้ผลลัพธ์เหมือนกับการAbstractClassErrorผลิต

คุณสามารถลองทับทิม 3 แบบ:
อินเทอร์เฟซ
นามธรรมนามธรรม
ง่าย ๆ

โดยส่วนตัวแล้วฉันเพิ่ม NotImplementedError ในวิธีการของคลาสนามธรรม แต่คุณอาจต้องการออกจากวิธีการ 'ใหม่' ด้วยเหตุผลที่คุณกล่าวถึง

หากคุณต้องการไปกับคลาสที่ไม่หยุดนิ่งในวิธีใหม่ของคุณให้ตรวจสอบว่า self == A ก่อนที่จะโยนข้อผิดพลาด

แต่จริงๆแล้วโมดูลดูเหมือนสิ่งที่คุณต้องการมากกว่าที่นี่ตัวอย่างเช่น Enumerable คือประเภทของสิ่งที่อาจเป็นคลาสนามธรรมในภาษาอื่น ในทางเทคนิคคุณไม่สามารถ subclass ได้ แต่การโทรinclude SomeModuleจะบรรลุเป้าหมายเดียวกันโดยประมาณ มีเหตุผลบางอย่างที่ไม่เหมาะกับคุณหรือไม่?

คุณพยายามรับใช้ด้วยชั้นเรียนนามธรรมด้วยจุดประสงค์ใด อาจมีวิธีที่ดีกว่าในการทำทับทิม แต่คุณไม่ได้ให้รายละเอียดใด ๆ

ตัวชี้ของฉันคือนี่ ใช้mixinไม่ใช่การถ่ายทอดทางพันธุกรรม

คำตอบอื่น:

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

สิ่งนี้อาศัย #method_missing ปกติในการรายงานวิธีการที่ไม่ได้นำไปใช้ แต่จะป้องกันไม่ให้ใช้คลาสนามธรรม (แม้ว่าจะมีวิธีการเริ่มต้นก็ตาม)

class A
  include Abstract
end
class B < A
end

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

เช่นเดียวกับผู้โพสต์คนอื่น ๆ ได้กล่าวไว้คุณน่าจะใช้มิกซ์อินมากกว่าคลาสนามธรรม

ฉันทำแบบนี้ดังนั้นจึงกำหนดนิยามใหม่สำหรับคลาสเด็กใหม่เพื่อค้นหาคลาสใหม่ที่ไม่ใช่คลาสนามธรรม ฉันยังไม่เห็นว่ามีประโยชน์ในการใช้คลาสนามธรรมในทับทิม

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

นอกจากนี้ยังมีขนาดเล็ก abstract_typeอัญมณีซึ่งช่วยให้สามารถประกาศคลาสและโมดูลที่เป็นนามธรรมได้อย่างไม่สะดุด

ตัวอย่าง (จากไฟล์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

ไม่มีอะไรผิดปกติกับแนวทางของคุณ การเพิ่มข้อผิดพลาดในการเริ่มต้นดูเหมือนจะดีตราบใดที่คลาสย่อยทั้งหมดของคุณจะลบล้างการเริ่มต้นแน่นอน แต่คุณไม่ต้องการกำหนดตัวเองใหม่แบบนั้น นี่คือสิ่งที่ฉันจะทำ

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

อีกวิธีหนึ่งคือการใส่ฟังก์ชันทั้งหมดนั้นไว้ในโมดูลซึ่งตามที่คุณกล่าวมานั้นไม่สามารถสร้างขึ้นได้ จากนั้นรวมโมดูลในชั้นเรียนของคุณแทนที่จะรับช่วงจากคลาสอื่น อย่างไรก็ตามสิ่งนี้จะทำลายสิ่งต่างๆเช่นซุปเปอร์

ดังนั้นจึงขึ้นอยู่กับว่าคุณต้องการจัดโครงสร้างอย่างไร แม้ว่าโมดูลจะดูเหมือนเป็นโซลูชันที่สะอาดกว่าสำหรับการแก้ปัญหา "ฉันจะเขียนบางสิ่งที่กำหนดให้คลาสอื่นใช้" ได้อย่างไร

อัญมณี 2 บรรทัด: https://rubygems.org/gems/abstract

แม้ว่าจะไม่รู้สึกเหมือน Ruby แต่คุณสามารถทำได้:

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

    puts 'initialized'
  end
end

class B < A
end

ผลลัพธ์:

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