[Scala] स्कैला में ऑब्जेक्ट और क्लास के बीच अंतर


Answers

एक class एक परिभाषा है, एक विवरण। यह विधियों और अन्य प्रकार की संरचना के मामले में एक प्रकार को परिभाषित करता है।

एक object एक सिंगलटन है - एक वर्ग का एक उदाहरण जो अद्वितीय होने की गारंटी है। कोड में प्रत्येक object के लिए, एक अज्ञात वर्ग बनाया जाता है, जो आपके द्वारा object को लागू करने के लिए घोषित किए गए object भी वर्ग से प्राप्त होता है। इस वर्ग को स्कैला स्रोत कोड से नहीं देखा जा सकता है - हालांकि आप इसे प्रतिबिंब के माध्यम से प्राप्त कर सकते हैं।

object और class बीच एक रिश्ता है। एक वस्तु को एक वर्ग का साथी-वस्तु कहा जाता है यदि वे एक ही नाम साझा करते हैं। जब ऐसा होता है, तो प्रत्येक के पास दूसरे में private दृश्यता के तरीकों तक पहुंच होती है। हालांकि, ये विधियां स्वचालित रूप से आयात नहीं होती हैं। आपको या तो उन्हें स्पष्ट रूप से आयात करना होगा, या कक्षा / ऑब्जेक्ट नाम के साथ उन्हें उपसर्ग करना होगा।

उदाहरण के लिए:

class X {
  // class X can see private members of object X
  // Prefix to call
  def m(x: Int) = X.f(x)

  // Import and use
  import X._
  def n(x: Int) = f(x)

  private def o = 2
}

object X {
  private def f(x: Int) = x * x

  // object X can see private members of class X
  def g(x: X) = {
    import x._
    x.o * o // fully specified and imported
   }
}
Question

मैं बस इंटरनेट पर कुछ स्कैला ट्यूटोरियल पर जा रहा हूं और कुछ उदाहरणों में देखा है कि उदाहरण की शुरुआत में ऑब्जेक्ट घोषित किया गया है।

स्कैला में class और object बीच क्या अंतर है?




जैसा कि कई लोगों द्वारा समझाया गया है, object एक सिंगलटन उदाहरण को परिभाषित करता है। यहां जवाबों में से एक बात जो मुझे विश्वास है कि छोड़ दिया गया है वह object कई उद्देश्यों को पूरा करती है।

  • यह एक class / trait लिए साथी वस्तु हो सकती है, जिसमें स्थिर विधियों या सुविधा विधियों को माना जा सकता है।

  • यह एक मॉड्यूल की तरह कार्य कर सकता है, जिसमें संबंधित / सहायक प्रकार और परिभाषाएं इत्यादि शामिल हैं।

  • यह class या एक या अधिक trait को विस्तारित करके एक इंटरफेस को कार्यान्वित कर सकता है।

  • यह एक sealed trait मामले का प्रतिनिधित्व कर सकता है जिसमें कोई डेटा नहीं है। इस संबंध में, इसे किसी भी पैरामीटर के साथ case class से अधिक सही माना जाता है। केवल case object कार्यान्वयनकर्ताओं के साथ एक sealed trait का विशेष मामला एनम के स्कैला संस्करण को कम या कम करता है।

  • यह implicit दिव्य तर्क के सबूत के रूप में कार्य कर सकता है।

  • यह एक सिंगलटन प्रकार पेश करता है।

यह एक बहुत शक्तिशाली और सामान्य निर्माण है। स्कैला शुरुआती लोगों के लिए बहुत भ्रमित हो सकता है कि एक ही निर्माण में काफी अलग-अलग उपयोग हो सकते हैं। और एक object एक साथ कई अलग-अलग उपयोगों को पूरा कर सकती है, जो और भी भ्रमित हो सकती है।




औपचारिक अंतर -

  1. आप कन्स्ट्रक्टर पैरामीटर प्रदान नहीं कर सकते हैं
  2. यह एक प्रकार नहीं है - आप नए ऑपरेटर के साथ एक उदाहरण नहीं बना सकते हैं। लेकिन इसमें फ़ील्ड, विधियां, सुपरक्लास का विस्तार और लक्षणों में मिश्रण हो सकता है।

उपयोग में अंतर:

  • स्कैला में स्थिर तरीके या फ़ील्ड नहीं हैं। इसके बजाय आपको object उपयोग करना चाहिए। आप इसे संबंधित वर्ग के साथ या बिना इस्तेमाल कर सकते हैं। पहले मामले में इसे एक साथी वस्तु कहा जाता है। आपको करना होगा:
    1. कक्षा और वस्तु दोनों के लिए एक ही नाम का उपयोग करें
    2. उन्हें एक ही स्रोत फ़ाइल में डाल दें।
  • एक प्रोग्राम बनाने के लिए आपको object में मुख्य विधि का उपयोग करना चाहिए, class नहीं।

    object Hello {
      def main(args: Array[String]) {
        println("Hello, World!")
      }
    }
    
  • जब आप जावा में सिंगलटन ऑब्जेक्ट का उपयोग करते हैं तो आप इसका भी उपयोग कर सकते हैं।






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

स्कैला सिंगलटन ऑब्जेक्ट उदाहरण

object Singleton{  
    def main(args:Array[String]){  
        SingletonObject.hello()         // No need to create object.  
    }  
}  


object SingletonObject{  
    def hello(){  
        println("Hello, This is Singleton Object")  
    }  
}  

आउटपुट:

Hello, This is Singleton Object

स्कैला में, जब आपके पास सिंगलटन ऑब्जेक्ट के समान नाम वाला वर्ग होता है, तो उसे साथी वर्ग कहा जाता है और सिंगलटन ऑब्जेक्ट को साथी ऑब्जेक्ट कहा जाता है।

साथी वर्ग और उसके साथी ऑब्जेक्ट दोनों को एक ही स्रोत फ़ाइल में परिभाषित किया जाना चाहिए।

स्कैला कंपैनियन ऑब्जेक्ट उदाहरण

class ComapanionClass{  
    def hello(){  
        println("Hello, this is Companion Class.")  
    }  
}  
object CompanoinObject{  
    def main(args:Array[String]){  
        new ComapanionClass().hello()  
        println("And this is Companion Object.")  
    }  
}  

आउटपुट:

Hello, this is Companion Class.
And this is Companion Object.

स्कैला में, एक वर्ग में निम्न शामिल हो सकते हैं:

1. डेटा सदस्य

2. सदस्य विधि

3. कन्स्ट्रक्टर ब्लॉक

4. नेस्टेड क्लास

5. सुपर क्लास सूचना आदि

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

कक्षा के स्कैला नमूना उदाहरण

class Student{  
    var id:Int = 0;                         // All fields must be initialized  
    var name:String = null;  
}  
object MainObject{  
    def main(args:Array[String]){  
        var s = new Student()               // Creating an object  
        println(s.id+" "+s.name);  
    }  
} 

मुझे खेद है, मुझे बहुत देर हो चुकी है लेकिन मुझे उम्मीद है कि यह आपकी मदद करेगा।




ऑब्जेक्ट एक वर्ग है लेकिन इसमें पहले से ही एक उदाहरण है, इसलिए आप new ObjectName ऑब्जेक्टनाम को कॉल नहीं कर सकते हैं। दूसरी तरफ, कक्षा सिर्फ टाइप है और यह new ClassName() कॉल करके एक उदाहरण हो सकता है।




एक वर्ग वस्तुओं के लिए एक ब्लूप्रिंट है। एक बार कक्षा को परिभाषित करने के बाद, आप कक्षा ब्लूप्रिंट से ऑब्जेक्ट्स को new कीवर्ड के साथ बना सकते हैं। वस्तु के माध्यम से, आप परिभाषित वर्ग की सभी कार्यक्षमताओं का उपयोग कर सकते हैं।

बेहतर स्पष्टीकरण के लिए आरेख:

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

object Demo {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // Move to a new location
      pt.move(10, 10);
   }
}

Source