रूबी में एक अमूर्त वर्ग को कैसे कार्यान्वित करें?

Question

मुझे पता है कि रूबी में अमूर्त वर्ग की कोई अवधारणा नहीं है। लेकिन अगर इसे लागू करने की जरूरत है, तो इसके बारे में कैसे जाना है? मैं कुछ की तरह कोशिश की ...

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

class B < A 
    ... 
    ... 
end 

लेकिन जब मैं बी का दृष्टांत करने की कोशिश, उसका आंतरिक A.new जो अपवाद को बढ़ाने के लिए जा रहा है कॉल करने के लिए जा रहा है।

इसके अलावा, मॉड्यूल को तत्काल नहीं किया जा सकता है लेकिन उन्हें विरासत में भी प्राप्त नहीं किया जा सकता है। नई विधि निजी बनाना भी काम नहीं करेगा। कोई संकेतक?

Answer 1

मुझे रूबी में अमूर्त कक्षाओं का उपयोग करना पसंद नहीं है (लगभग हमेशा एक बेहतर तरीका है)। यदि आप वास्तव में लगता है कि यह स्थिति के लिए सबसे अच्छी तकनीक है, हालांकि, आप निम्नलिखित स्निपेट का उपयोग कर सकते अधिक कथात्मक तरीकों के बारे में जो अमूर्त हैं होने के लिए:

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 अपवाद उठाया जाएगा।

Answer 2

व्यक्तिगत रूप से मैं अमूर्त वर्गों के तरीकों में NotImplementedError को बढ़ाता हूं। लेकिन आप जिन कारणों का उल्लेख करते हैं, उनके लिए आप इसे 'नई' विधि से बाहर छोड़ना चाहेंगे।

Answer 3

आपके दृष्टिकोण में कुछ भी गलत नहीं है। आरंभ में त्रुटि उत्पन्न करना ठीक लगता है, जब तक कि आपके सभी उप-वर्गों ने पाठ्यक्रम की शुरूआत को ओवरराइड किया हो। लेकिन आप स्वयं को परिभाषित नहीं करना चाहते हैं। नया ऐसा। मैं यही करूँगा।

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

एक और दृष्टिकोण एक मॉड्यूल में उस कार्यक्षमता को रखा जाएगा, जैसा कि आपने उल्लेख किया है, कभी भी उत्तेजित नहीं किया जा सकता है। फिर किसी अन्य वर्ग से विरासत के बजाय अपनी कक्षाओं में मॉड्यूल शामिल करें। हालांकि, यह सुपर जैसी चीजों को तोड़ देगा।

तो यह इस बात पर निर्भर करता है कि आप इसे कैसे व्यवस्थित करना चाहते हैं।

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

class B < A 
    def initialize 
    end 
end 

Answer 4

इस प्रयास करें "मैं कुछ सामान है कि उपयोग करने के लिए अन्य वर्गों के लिए deigned है कैसे लिख सकता हूँ" कक्षा, अपने एनी विधि में, त्रुटि को फेंकने से पहले स्वयं == ए जांचें।

लेकिन वास्तव में, एक मॉड्यूल जो आप यहां चाहते हैं उतना ही लगता है - उदाहरण के लिए, संख्यात्मक चीज ऐसी चीज है जो अन्य भाषाओं में एक अमूर्त वर्ग हो सकती है। आप तकनीकी रूप से उन्हें उपclass नहीं कर सकते हैं, लेकिन include SomeModule पर कॉल करना लगभग एक ही लक्ष्य प्राप्त करता है। क्या कोई कारण है कि यह आपके लिए काम नहीं करेगा?

Answer 5

आप एक uninstantiable के साथ जाना चाहते हैं: हालांकि मॉड्यूल की समस्या को हल करने के लिए एक क्लीनर समाधान की तरह लग

Answer 6

आप एक सार तत्व के साथ सेवा करने का क्या उद्देश्य कर रहे हैं? रूबी में ऐसा करने का शायद एक बेहतर तरीका है, लेकिन आपने कोई विवरण नहीं दिया।

मेरा सूचक यह है; mixin विरासत का उपयोग करें।

Answer 7

एक अन्य जवाब:

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> 

कार्यान्वित किया जा रहा से सार कक्षाएं रहता है अन्य पोस्टर्स की तरह कहा है, आप शायद एक अमूर्त वर्ग के बजाय, एक मिश्रण का उपयोग करना चाहिए।

Answer 8

प्रोग्रामिंग रूबी के पिछले 6 1/2 वर्षों में, मेरे पास एक सारणी कक्षा की आवश्यकता नहीं है।

यदि आप सोच रहे हैं कि आपको एक अमूर्त वर्ग की आवश्यकता है, तो आप ऐसी भाषा में बहुत अधिक सोच रहे हैं जो उन्हें रूबी में नहीं, प्रदान करता है।

जैसा कि अन्य ने सुझाव दिया है, एक मिश्रण उन चीजों के लिए अधिक उपयुक्त है जो इंटरफेस (जैसे जावा उन्हें परिभाषित करता है) माना जाता है, और आपके डिजाइन पर पुनर्विचार करना उन चीजों के लिए अधिक उपयुक्त है जिन्हें सी ++ जैसी अन्य भाषाओं से अमूर्त कक्षाओं की आवश्यकता होती है।

Answer 9

class A 
    private_class_method :new 
end 

class B < A 
    public_class_method :new 
end 

Answer 10

बस देर से यहाँ में झंकार के, मुझे लगता है कि अमूर्त वर्ग, especially because they can add methods to it on the fly instantiating से किसी को रोकने के लिए कोई कारण नहीं है कि।

रूबी की तरह बतख-टाइपिंग भाषा, रनटाइम पर उपस्थिति/अनुपस्थिति या विधियों के व्यवहार का उपयोग यह निर्धारित करने के लिए करें कि उन्हें कॉल किया जाना चाहिए या नहीं। इसलिए अपने प्रश्न, के रूप में यह एक सार विधि पर लागू होता है, भावना

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

बनाता है और उस कहानी का अंत के बारे में होना चाहिए। जावा में अमूर्त वर्गों का उपयोग करने का एकमात्र कारण यह है कि कुछ विधियों को "भरने" मिलते हैं जबकि अन्यों के पास अमूर्त वर्ग में उनका व्यवहार होता है। एक बतख-टाइपिंग भाषा में, फोकस विधियों पर है, कक्षाओं/प्रकारों पर नहीं, इसलिए आपको अपनी चिंताओं को उस स्तर पर ले जाना चाहिए।

अपने प्रश्न में, आप मूल रूप से जावा से abstract कीवर्ड को फिर से बनाने की कोशिश कर रहे हैं, जो रूबी में जावा करने के लिए कोड-गंध है।

Answer 11

मैंने इसे इस तरह से किया, इसलिए यह गैर-वर्ग वर्ग पर नया खोजने के लिए बाल वर्ग पर नए को फिर से परिभाषित करता है। मुझे अभी भी रूबी में अमूर्त कक्षाओं का उपयोग करने में कोई व्यावहारिक नहीं दिख रहा है।

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 12

2-लाइनों मणि: https://rubygems.org/gems/abstract

Answer 13

आप 3 rubygems कोशिश कर सकते हैं:
interface
abstract
simple abstract

Answer 14

मेरे 2 ¢: मैं एक सरल, हल्के डीएसएल mixin के लिए चुनते हैं:

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 

और, ज़ाहिर है, बेस क्लास को शुरू करने के लिए एक और त्रुटि जोड़ना इस मामले में मामूली होगा।

Answer 15

यह छोटा 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 

Answer 16

रेल दुनिया में किसी के लिए, एक ActiveRecord मॉडल को लागू के रूप में एक अमूर्त वर्ग मॉडल फ़ाइल में इस घोषणा के साथ किया जाता है:

self.abstract_class = true