Scala में क्लासेस और ऑब्जेक्ट्स

DataCamp ने हाल ही में अपना पहला Scala कोर्स लॉन्च किया है: Introduction to Scala। देखिए जरूर!

निम्नलिखित ट्यूटोरियल भी देखें:

• Scala के लिए शुरुआती मार्गदर्शिका
• Scala में IF ELSE
• Scala में ऑपरेटर्स
• Scala में लिस्ट्स

परिचय

सामान्यतः, ऑब्जेक्ट‑ओरिएंटेड प्रोग्रामिंग (OOP) में क्लासेस और ऑब्जेक्ट्स होते हैं और इसका उद्देश्य वास्तविक जीवन की इकाइयों, जैसे पॉलिमॉर्फिज़्म, इनहेरिटेंस, आदि को लागू करना है।

OOPs से विकास तेज़ और सस्ता होता है तथा सॉफ़्टवेयर का मेंटेनेंस बेहतर रहता है। इसका मुख्य कारण यह है कि यह कई फीचर्स देता है; आपके पास क्लासेस और ऑब्जेक्ट्स होते हैं जिन्हें आवश्यकता के अनुसार भविष्य में आसानी से पुनः‑उपयोग किया जा सकता है, जबकि जिन प्रोग्रामों में क्लासेस और ऑब्जेक्ट्स नहीं होते, वहाँ यह संभव नहीं। नतीजतन, सॉफ़्टवेयर की गुणवत्ता बेहतर होती है और वह नए मेथड्स और एट्रिब्यूट्स के साथ विस्तार योग्य भी रहता है।

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

क्लास को ऑब्जेक्ट्स के लिए एक प्रतिनिधित्व या डिज़ाइन के रूप में समझा जा सकता है। क्लासेस में सामान्यतः अपने मेथड्स (व्यवहार) और एट्रिब्यूट्स होते हैं।

एट्रिब्यूट्स वे व्यक्तिगत इकाइयाँ हैं जो हर ऑब्जेक्ट को दूसरे से अलग करती हैं और उसकी विभिन्न विशेषताओं को निर्धारित करती हैं। दूसरी ओर, मेथड्स वैसे ही होते हैं जैसे सामान्यतः प्रोग्रामिंग में फ़ंक्शन काम करते हैं। वे यह निर्धारित करते हैं कि क्लास का इंस्टेंस कैसे कार्य करेगा। अधिकांशतः मेथड्स (व्यवहार) की वजह से ही ऑब्जेक्ट्स पर कुछ किया जा सकता है।

ऊपर दिए गए चित्र से आपको ऑब्जेक्ट‑ओरिएंटेड प्रोग्रामिंग के फ्लो या विशेष रूप से, एक क्लास कैसी दिखती है, इसकी और समझ बनती है। ऊपर की तस्वीर में एक class car है जिसके attributes: fuel, max speed हैं और इसमें model, make आदि जैसे और एट्रिब्यूट्स भी हो सकते हैं। इसमें refuel(), getFuel(), setSpeed() जैसे विभिन्न methods हैं, और कुछ अतिरिक्त मेथड्स जैसे change gear, start the engine, stop the engine भी हो सकते हैं।

तो जब आप किसी विशिष्ट कार की बात करेंगे, तो आपके पास एक ऑब्जेक्ट होगा, जो क्लास का इंस्टैंसिएशन है।

अब, Scala में ऑब्जेक्ट‑ओरिएंटेड प्रोग्रामिंग की बात करते हैं।

Scala में क्लासेस और ऑब्जेक्ट्स

C++ और Java की तरह, Scala में ऑब्जेक्ट‑ओरिएंटेड प्रोग्रामिंग भी लगभग वही परंपराएँ मानती है। इसमें classes और objects को परिभाषित करने तथा क्लास के भीतर constructors की अवधारणा है, और Scala में ऑब्जेक्ट‑ओरिएंटेड प्रोग्रामिंग का सार यही है।

क्लास डिक्लरेशन

class Class_name{
// methods and attributes
}
संचालित द्वारा

Scala में क्लास को class कीवर्ड के साथ परिभाषित किया जाता है, जिसके बाद क्लास का नाम आता है, और सामान्यतः क्लास का नाम कैपिटल अक्षर से शुरू होता है। कुछ कीवर्ड वैकल्पिक हैं लेकिन Scala क्लास डिक्लरेशन में इस्तेमाल किए जा सकते हैं जैसे: class-name, यह कैपिटल अक्षर से शुरू होना चाहिए: superclass, पैरेंट क्लास का नाम जो extend कीवर्ड से पहले आता है: traits, यह कॉमा‑सेपरेटेड सूची होती है जिसे क्लास द्वारा implement किया जाता है और जो extend कीवर्ड से पहले आती है।

Scala में एक क्लास केवल एक पैरेंट क्लास से इनहेरिट कर सकती है, यानी Scala मल्टिपल इनहेरिटेंस को सपोर्ट नहीं करता। हालांकि, इसे Traits के उपयोग से प्राप्त किया जा सकता है।

अंत में, Scala में क्लास का बॉडी कर्ली ब्रेसेस {} में घिरा होता है।

// Name of the class is Car
class Car
{

    // Class variables
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // Class method
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}
object Main  
{

    // Main method
    def main(args: Array[String])  
    {

        // Class object
        var obj = new Car();
        obj.Display();
    }
}
संचालित द्वारा

उपरोक्त कोड को आप class.scala नाम से सेव कर सकते हैं और टर्मिनल पर scala class.scala के रूप में चला सकते हैं, और नीचे दिखाए अनुसार आउटपुट देखेंगे।

खैर, ऊपर दिया गया कोड किसी ऑब्जेक्ट‑ओरिएंटेड प्रोग्राम की पूरी क्षमताओं का इस्तेमाल नहीं करता। क्योंकि इस कोड का आउटपुट कितनी भी बार चलाएँ, वही रहेगा। आपने क्लास के अंदर स्टैटिक वैरिएबल परिभाषित किए हैं, और उन वैरिएबल्स के मान स्थिर रहेंगे, चाहे आप अनंत नए ऑब्जेक्ट्स ही क्यों न बनाएँ। निष्कर्षतः, आप इससे Mercedes Benz या Ferrari कार का विवरण मिलने की अपेक्षा नहीं कर सकते।

Scala में कंस्ट्रक्टर

कंस्ट्रक्टर्स मुख्यतः ऑब्जेक्ट की अवस्था को इनिशियलाइज़ करने के लिए उपयोग होते हैं। यह इनिशियलाइज़ेशन ऑब्जेक्ट के निर्माण के समय होता है, और इन्हें केवल एक बार कॉल किया जाता है।

Scala में कंस्ट्रक्टर्स दो प्रकार के होते हैं: Primary और Auxiliary। इस ट्यूटोरियल में आप प्राइमरी कंस्ट्रक्टर के बारे में जानेंगे (स्रोत: O'Reilly)।

class Class_name(Parameter_list){
// methods, attributes
}
संचालित द्वारा

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

तो, पिछला उदाहरण लेते हैं, लेकिन इस बार उसमें प्राइमरी कंस्ट्रक्टर जोड़ते हैं और परिणाम देखते हैं।

साथ ही, यहाँ आप क्लास की एक नई विशेषता सीखेंगे, यानी एक क्लास के कई ऑब्जेक्ट्स या इंस्टैंसेज़ हो सकते हैं, जो एक‑दूसरे से स्वतंत्र होते हैं।

// Name of the class is Car
class Car(make: String, model: String, fuel: Int)
{

    // Class method
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}

object Main

{

    // Main method
    def main(args: Array[String])  
    {

        // Multiple Class object
        var obj1 = new Car("BMW", "X7", 40);
        var obj2 = new Car("Mercedes Benz", "S350D", 50);
        obj1.Display();
        obj2.Display();
    }
}
संचालित द्वारा

आइए, जल्दी से आउटपुट देखते हैं:

अच्छा है न? कंस्ट्रक्टर की मदद से आप अधिक सार्थक परिणाम प्राप्त कर पाए।

Scala में ऑब्जेक्ट्स घोषित करना

Scala में ऑब्जेक्ट्स घोषित करना क्लास का इंस्टैंसिएशन करना या क्लास को इनवोक करना भी कहा जा सकता है। क्लासेस की तरह, ऑब्जेक्ट्स भी ऑब्जेक्ट‑ओरिएंटेड प्रोग्रामिंग की मौलिक इकाई हैं।

एक ऑब्जेक्ट में तीन विशेषताएँ हो सकती हैं (स्रोत: GeeksforGeeks):

• State: ऑब्जेक्ट के एट्रिब्यूट्स उसे निरूपित करते हैं। यह ऑब्जेक्ट के गुणों को भी दर्शाता है।
• Behavior: ऑब्जेक्ट के मेथड्स उसे निरूपित करते हैं। यह अन्य ऑब्जेक्ट्स के साथ उसकी प्रतिक्रिया को भी दर्शाता है।
• Identity: यह ऑब्जेक्ट को एक विशिष्ट नाम देता है और एक ऑब्जेक्ट को अन्य ऑब्जेक्ट्स से अंतःक्रिया करने में सक्षम बनाता है।

कुत्ते को एक ऑब्जेक्ट मानें और नीचे दिए गए डायग्राम में उसकी पहचान, अवस्था और व्यवहार देखें।

सभी इंस्टैंसेज़ या ऑब्जेक्ट्स क्लास के एट्रिब्यूट्स और मेथड्स को साझा करते हैं। जैसा कि आपने यहाँ सीखा, एक ही क्लास के कई ऑब्जेक्ट्स हो सकते हैं। हालांकि, प्रत्येक ऑब्जेक्ट की अवस्था या मान अद्वितीय होते हैं।

अंत में, आप ऐसा कोड लिखेंगे जिसमें प्राइमरी कंस्ट्रक्टर्स, क्लास वैरिएबल्स, एट्रिब्यूट्स और मेथड्स—सभी एक ही कोड में एक साथ होंगे।

नीचे Motorcycle क्लास में एक साथ रखे गए घटकों का चित्रात्मक निरूपण है।

नीचे दिया गया कोड काफ़ी हद तक स्वयं स्पष्ट है; उच्च स्तर पर, यह जाँचता है कि मोटरसाइकिल का इंजन on है या off। प्रारंभ में, इंजन को off अवस्था में रखा गया है, और यह आपको उसकी अवस्था बताएगा और उसे ऑन कर देगा।

class Motorcycle(make:String,color:String) {


       var engineState: Boolean = false;

       def startEngine() {
          if (engineState == true){
            println("The engine is already on.");
          }
          else {
            engineState = true
            println("The engine is now on.");
         }
       }

       def showAtts() {
         println("This motorcycle is a "+ color + " " + make);
         if (engineState == true){
           println("The engine is on.");
         }
         else{
            println("The engine is off.");
         }
      }

}
object Main
{
    def main (args: Array[String])
    {
        var m = new Motorcycle("BMW K 1600 GTL","White");
        println("Calling showAtts...");
        m.showAtts();
        println("------");
        println("Starting engine...");
        m.startEngine();
        println("------");
        println("Calling showAtts...");
        m.showAtts();
        println("------");
        println("Starting engine...");
        m.startEngine();
    }
}
संचालित द्वारा

बधाई हो!

इस ट्यूटोरियल को पूरा करने पर बधाई।

अब आप Scala में क्लासेस और मेथड्स घोषित करना, ऑब्जेक्ट्स का इंस्टैंसिएशन करना, उनके एट्रिब्यूट्स सेट करना और इंस्टेंस मेथड्स को कॉल करना जानते हैं। ये अवधारणाएँ न केवल Scala में बल्कि अन्य प्रोग्रामिंग भाषाओं में भी आपके काम आएंगी।

ऑब्जेक्ट‑ओरिएंटेड प्रोग्रामिंग की अवधारणाएँ रोचक और साथ ही बहुत शक्तिशाली होती हैं। यह आपके कोड में एक नया आयाम जोड़ती हैं और उसे पुनः‑उपयोग योग्य बनाती हैं। जैसे‑जैसे आपका प्रोग्राम बड़ा होगा, आपका कोड जटिल होता जाएगा। ऑब्जेक्ट‑ओरिएंटेड प्रोग्रामिंग में इनहेरिटेंस, पॉलिमॉर्फिज़्म, इंस्टेंस मेथड्स जैसी बहुत‑सी गूढ़ बातें हैं। एक और शक्तिशाली फीचर Singleton है। डिजाइन सिद्धांत आपके कोड को अधिक संरचित और पठनीय बनाए रखने में मदद करते हैं। डिजाइन पैटर्न्स पर अधिक जानने के लिए, यह किताब पढ़ें।

कृपया इस ट्यूटोरियल से संबंधित कोई भी प्रश्न नीचे कमेंट्स सेक्शन में पूछें।

अंत में, DataCamp पर नया Scala कोर्स Introduction to Scala करना न भूलें।