Ruby Language
कक्षाएं

वाक्य - विन्यास

• कक्षा का नाम
• # वर्ग व्यवहार का वर्णन करने वाला कुछ कोड
• समाप्त

टिप्पणियों

class Cat # correct
end  

class dog # wrong, throws an error
end

एक वर्ग बनाना

आप class कीवर्ड का उपयोग करके एक नया वर्ग परिभाषित कर सकते हैं।

class MyClass
end

एक बार परिभाषित होने पर, आप .new विधि का उपयोग करके एक नया उदाहरण बना सकते हैं

somevar = MyClass.new
# => #<MyClass:0x007fe2b8aa4a18>

निर्माता

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

class Customer
  def initialize(name)
     @name = name.capitalize 
  end
end

sarah = Customer.new('sarah')
sarah.name #=> 'Sarah'

वर्ग और उदाहरण चर

कई विशेष प्रकार के चर हैं जो एक वर्ग अधिक आसानी से साझा करने वाले डेटा के लिए उपयोग कर सकते हैं।

इंस्टेंस चर, @ से पहले। यदि आप एक ही चर का उपयोग विभिन्न तरीकों से करना चाहते हैं तो वे उपयोगी हैं।

class Person
  def initialize(name, age)
    my_age = age # local variable, will be destroyed at end of constructor
    @name = name # instance variable, is only destroyed when the object is
  end

  def some_method
    puts "My name is #{@name}." # we can use @name with no problem
  end
   
  def another_method
    puts "My age is #{my_age}." # this will not work!
  end
end

mhmd = Person.new("Mark", 23)

mhmd.some_method #=> My name is Mark.
mhmd.another_method #=> throws an error

वर्ग चर, @@ से पहले। वे एक वर्ग के सभी उदाहरणों में समान मान रखते हैं।

class Person
  @@persons_created = 0 # class variable, available to all objects of this class
  def initialize(name)
    @name = name

    # modification of class variable persists across all objects of this class
    @@persons_created += 1
  end  
      
  def how_many_persons
    puts "persons created so far: #{@@persons_created}"
  end 
end
    
mark = Person.new("Mark")
mark.how_many_persons #=> persons created so far: 1
helen = Person.new("Helen")

mark.how_many_persons #=> persons created so far: 2
helen.how_many_persons #=> persons created so far: 2
# you could either ask mark or helen

वैश्विक चर, $ से पहले। ये कार्यक्रम के लिए कहीं भी उपलब्ध हैं, इसलिए इनका बुद्धिमानी से उपयोग करना सुनिश्चित करें।

$total_animals = 0

class Cat
  def initialize
    $total_animals += 1
  end
end

class Dog
  def initialize
    $total_animals += 1
  end
end

bob = Cat.new()
puts $total_animals #=> 1
fred = Dog.new()
puts $total_animals #=> 2

गेटर्स और सेटर्स के साथ इंस्टेंस वेरिएबल एक्सेस करना

हमारे पास तीन तरीके हैं:

1. attr_reader : कक्षा के बाहर चर को read अनुमति देने के लिए उपयोग किया जाता है।
2. attr_writer : वर्ग के बाहर चर को संशोधित करने की अनुमति देने के लिए उपयोग किया जाता है।
3. attr_accessor : दोनों तरीकों को जोड़ती है।

class Cat
  attr_reader :age # you can read the age but you can never change it
  attr_writer :name # you can change name but you are not allowed to read
  attr_accessor :breed # you can both change the breed and read it

  def initialize(name, breed)
    @name = name
    @breed = breed
    @age = 2 
  end
  def speak
    puts "I'm #{@name} and I am a #{@breed} cat"
  end
end
 
my_cat = Cat.new("Banjo", "birman")
# reading values:

my_cat.age  #=> 2
my_cat.breed #=> "birman"
my_cat.name #=> Error

# changing values
 
my_cat.age = 3 #=> Error
my_cat.breed = "sphynx" 
my_cat.name = "Bilbo"

my_cat.speak #=> I'm Bilbo and I am a sphynx cat

ध्यान दें कि पैरामीटर प्रतीक हैं। यह एक विधि बनाकर काम करता है।

class Cat
  attr_accessor :breed
end

मूल रूप से समान है:

class Cat
  def breed
    @breed
  end
  def breed= value
    @breed = value
  end
end

पहुँच स्तर

रूबी के तीन पहुँच स्तर हैं। वे public , private और protected ।

private या protected कीवर्ड का अनुसरण करने वाले तरीके इस प्रकार परिभाषित किए गए हैं। इससे पहले आने वाले तरीके public रूप से निहित हैं।

सार्वजनिक तरीके

एक सार्वजनिक विधि में बनाई जा रही वस्तु के व्यवहार का वर्णन करना चाहिए। इन विधियों को निर्मित वस्तु के दायरे के बाहर से बुलाया जा सकता है।

class Cat
  def initialize(name)
    @name = name
  end

  def speak
    puts "I'm #{@name} and I'm 2 years old"
  end
  
  ...
end

new_cat = Cat.new("garfield")
#=> <Cat:0x2321868 @name="garfield">
 
new_cat.speak
#=> I'm garfield and I'm 2 years old

ये विधियां सार्वजनिक रूबी विधियां हैं, वे एक नई बिल्ली को बोलने के लिए व्यवहार और बोलने के तरीके के व्यवहार का वर्णन करते हैं।

public कीवर्ड अनावश्यक है, लेकिन इसका उपयोग private या protected से बचने के लिए किया जा सकता protected

def MyClass
  def first_public_method
  end

  private

  def private_method
  end

  public

  def second_public_method
  end
end

निजी तरीके

वस्तु के बाहर से निजी तरीके सुलभ नहीं हैं। उनका उपयोग आंतरिक रूप से ऑब्जेक्ट द्वारा किया जाता है। बिल्ली का उदाहरण फिर से उपयोग करना:

class Cat
  def initialize(name)
    @name = name
  end

  def speak
    age = calculate_cat_age # here we call the private method 
    puts "I'm #{@name} and I'm #{age} years old"
  end

  private
     def calculate_cat_age
       2 * 3 - 4 
     end
end

my_cat = Cat.new("Bilbo")
my_cat.speak #=> I'm Bilbo and I'm 2 years old
my_cat.calculate_cat_age #=> NoMethodError: private method `calculate_cat_age' called for #<Cat:0x2321868 @name="Bilbo">

जैसा कि आप ऊपर दिए गए उदाहरण में देख सकते हैं, नई बनाई गई कैट ऑब्जेक्ट में आंतरिक रूप से calculate_cat_age पद्धति तक पहुंच है। हम वैरिएबल age को प्राइवेट calculate_cat_age विधि को चलाने के परिणाम के लिए असाइन करते हैं जो कंसोल के लिए बिल्ली के नाम और आयु को प्रिंट करता है।

जब हम कोशिश करते हैं और कहते हैं calculate_cat_age बाहर से विधि my_cat वस्तु, हम एक प्राप्त NoMethodError क्योंकि यह निजी है। उसे ले लो?

संरक्षित तरीके

संरक्षित विधियां निजी विधियों के समान हैं। वे उसी तरह से वस्तु के उदाहरण से बाहर नहीं जा सकते हैं जिस तरह से निजी तरीके नहीं हो सकते हैं। हालांकि, self माणिक विधि का उपयोग करके, संरक्षित तरीकों को उसी प्रकार की वस्तु के संदर्भ में कहा जा सकता है।

class Cat
  def initialize(name, age)
    @name = name
    @age = age
  end

  def speak
    puts "I'm #{@name} and I'm #{@age} years old"
  end

  # this == method allows us to compare two objects own ages. 
  # if both Cat's have the same age they will be considered equal.
  def ==(other)
     self.own_age == other.own_age
  end

  protected
     def own_age
        self.age
     end
end

cat1 = Cat.new("ricky", 2)
=> #<Cat:0x007fe2b8aa4a18 @name="ricky", @age=2>

cat2 = Cat.new("lucy", 4)
=> #<Cat:0x008gfb7aa6v67 @name="lucy", @age=4>

cat3 = Cat.new("felix", 2)
=> #<Cat:0x009frbaa8V76 @name="felix", @age=2>

आप देख सकते हैं कि हमने कैट क्लास में एक आयु पैरामीटर जोड़ दिया है और नाम और उम्र के साथ तीन नई कैट ऑब्जेक्ट बनाए हैं। हम अपनी बिल्ली की वस्तुओं की उम्र की तुलना करने के लिए own_age संरक्षित विधि को कॉल करने जा रहे हैं।

cat1 == cat2
=> false

cat1 == cat3
=> true

उस पर गौर करें, हम self.own_age संरक्षित पद्धति का उपयोग करके cat1 की आयु प्राप्त करने में सक्षम थे और cat2.own_age भीतर cat2.own_age को कॉल करके cat2 की आयु के खिलाफ तुलना कर सकते थे।

क्लास के तरीके

वर्गों में 3 प्रकार की विधियाँ होती हैं: उदाहरण, सिंगलटन और क्लास विधियाँ।

उदाहरण के तरीके

ये ऐसी विधियाँ हैं जिन्हें कक्षा के instance से कहा जा सकता है।

class Thing
  def somemethod
    puts "something"
  end
end

foo = Thing.new # create an instance of the class
foo.somemethod # => something

कक्षा विधि

ये स्थैतिक विधियाँ हैं, अर्थात, इन्हें कक्षा पर लागू किया जा सकता है, न कि उस कक्षा के एक पल पर।

class Thing
  def Thing.hello(name)
    puts "Hello, #{name}!"
  end
end

यह वर्ग नाम के स्थान पर self का उपयोग करने के बराबर है। निम्नलिखित कोड उपरोक्त कोड के बराबर है:

class Thing
  def self.hello(name)
    puts "Hello, #{name}!"
  end
end

लिखकर विधि को लागू करें

Thing.hello("John Doe")  # prints: "Hello, John Doe!"

सिंगलटन के तरीके

ये केवल कक्षा के विशिष्ट उदाहरणों के लिए उपलब्ध हैं, लेकिन सभी के लिए नहीं।

# create an empty class
class Thing
end

# two instances of the class
thing1 = Thing.new
thing2 = Thing.new

# create a singleton method
def thing1.makestuff
  puts "I belong to thing one"
end

thing1.makestuff # => prints: I belong to thing one
thing2.makestuff # NoMethodError: undefined method `makestuff' for #<Thing>

दोनों singleton और class तरीकों को eigenclass एस कहा जाता है। मूल रूप से, रूबी क्या करती है एक अनाम वर्ग बनाने के लिए जो इस तरह के तरीकों को रखता है ताकि यह पैदा होने वाले उदाहरणों के साथ हस्तक्षेप न करे।

ऐसा करने का एक अन्य तरीका class << निर्माता द्वारा है। उदाहरण के लिए:

# a class method (same as the above example)
class Thing
  class << self # the anonymous class
    def hello(name)
      puts "Hello, #{name}!"
    end
  end
end

Thing.hello("sarah") # => Hello, sarah!

# singleton method

class Thing
end

thing1 = Thing.new

class << thing1
  def makestuff
    puts "I belong to thing one"
  end
end

thing1.makestuff # => prints: "I belong to thing one"

गतिशील वर्ग निर्माण

Class.new के उपयोग के माध्यम से कक्षाएं गतिशील रूप से बनाई जा सकती हैं।

# create a new class dynamically
MyClass = Class.new

# instantiate an object of type MyClass
my_class = MyClass.new

उपरोक्त उदाहरण में, एक नया वर्ग बनाया गया है और निरंतर MyClass को सौंपा गया है। इस वर्ग को किसी भी अन्य वर्ग की तरह ही त्वरित और इस्तेमाल किया जा सकता है।

Class.new पद्धति एक ऐसे Class स्वीकार करती है जो गतिशील रूप से निर्मित कक्षा का Class.new ।

# dynamically create a class that subclasses another
Staffy = Class.new(Dog)

# instantiate an object of type Staffy
lucky = Staffy.new
lucky.is_a?(Staffy) # true
lucky.is_a?(Dog)    # true

Class.new पद्धति एक ब्लॉक को भी स्वीकार करती है। ब्लॉक का संदर्भ नवसृजित वर्ग है। इससे तरीकों को परिभाषित किया जा सकता है।

Duck = 
  Class.new do
    def quack
      'Quack!!'
    end
  end

# instantiate an object of type Duck
duck = Duck.new
duck.quack # 'Quack!!'

नया, आवंटित करें, और आरंभ करें

कई भाषाओं में, एक विशेष new कीवर्ड का उपयोग करके कक्षा के नए उदाहरण बनाए जाते हैं। रूबी में, new का उपयोग एक वर्ग के उदाहरण बनाने के लिए भी किया जाता है, लेकिन यह एक कीवर्ड नहीं है; इसके बजाय, यह एक स्थिर / वर्ग विधि है, किसी भी अन्य स्थिर / वर्ग विधि से अलग नहीं है। परिभाषा मोटे तौर पर यह है:

class MyClass
   def self.new(*args)
     obj = allocate
     obj.initialize(*args) # oversimplied; initialize is actually private
     obj
   end
end

allocate वर्ग का एक असम्बद्ध उदाहरण बनाने का वास्तविक 'जादू' करता है

यह भी ध्यान दें कि initialize का रिटर्न वैल्यू छोड़ दिया गया है, और इसके बदले obj लौटा दिया गया है। इससे यह तुरंत स्पष्ट हो जाता है कि आप अंत में self लौटने के बारे में चिंता किए बिना अपनी प्रारंभिक विधि को क्यों कोड कर सकते हैं।

'सामान्य' new विधि जो सभी वर्गों को Class से मिलती है, ऊपर की तरह काम करती है, लेकिन यह संभव है कि आप इसे पसंद करें या अलग-अलग काम करने वाले विकल्पों को परिभाषित करें। उदाहरण के लिए:

class MyClass
  def self.extraNew(*args)
    obj = allocate
    obj.pre_initialize(:foo)
    obj.initialize(*args)
    obj.post_initialize(:bar)
    obj
  end
end