Scala Traits

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

आप निम्नलिखित ट्यूटोरियल भी पढ़ने में रुचि ले सकते हैं:

• Beginners Guide to Scala
• IF ELSE in Scala
• Operators in Scala
• Lists in Scala
• Scala Classes and Objects

Introduction

Trait ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में मुख्य रूप से प्रयुक्त एक अवधारणा है, जो विधियों के एक सेट का उपयोग करके किसी क्लास की कार्यक्षमता का विस्तार कर सकती है।

Traits, जावा प्रोग्रामिंग भाषा के interfaces की भावना से मिलते-जुलते हैं। किसी क्लास के विपरीत, Scala traits को instantiate नहीं किया जा सकता और इनके कोई आर्ग्युमेंट या पैरामीटर नहीं होते। हालांकि, आप इन्हें क्लासों और ऑब्जेक्ट्स का उपयोग करके इनहेरिट (extend) कर सकते हैं। दूसरे शब्दों में, traits कुछ विशिष्ट विधियाँ/फंक्शंस उपलब्ध कराते हैं जो किसी क्लास में व्यवहार निष्पादित करते हैं और अपेक्षा करते हैं कि क्लास कुछ विधियाँ implement करे, जो दिए गए व्यवहार को पैरामीटराइज़ करती हैं।

किसी ऑब्जेक्ट को परिभाषित करने के लिए इस्तेमाल किया जाने वाला trait, विधियों का एक मिश्रण होता है जिसे अलग-अलग क्लासों द्वारा बिना multiple inheritance की आवश्यकता के इस्तेमाल किया जा सकता है। हालांकि, अपवाद हो सकते हैं जहाँ दो traits में एक ही नाम की विधि हो (naming collision), और किसी क्लास को दोनों का उपयोग करना हो—ऐसी स्थिति में अस्पष्टता को स्पष्ट रूप से सुलझाना पड़ता है।

Traits में abstract और non-abstract दोनों प्रकार की विधियाँ और फील्ड्स सदस्य के रूप में हो सकते हैं। जब आप किसी trait में किसी विधि को initialize नहीं करते, तो वह abstract होती है; जबकि जो initialize की गई हों वे non-abstract कहलाती हैं। Abstract विधियों के लिए, trait को implement करने वाली क्लास initialization का ध्यान रखती है।

अब कुछ उदाहरणों की मदद से Scala traits को जल्दी से समझते हैं!

Scala Trait Syntax

Scala trait का सिंटैक्स सीधा-सादा है—इसे trait कीवर्ड के बाद trait के नाम से परिभाषित किया जाता है।

trait Trait_Name{
// Variables
// Methods
}
संचालित द्वारा

जैसा कि आप ऊपर दी गई trait परिभाषा से देख सकते हैं, DataCamp नाम का एक trait परिभाषित किया गया है, जिसके अंदर कोई भी वेरिएबल या विधि परिभाषित नहीं है।

आइए Scala traits का एक सरल उदाहरण देखते हैं, जो आपको प्रोग्रामेटिक रूप से इनके काम करने के तरीके पर और स्पष्टता देगा।

जैसा कि introduction में चर्चा की गई थी, Scala Traits किसी क्लास द्वारा extends कीवर्ड से इनहेरिट किए जाते हैं।

class Scala_Tutorial extends DataCamp{
// Variables
// Methods
}
संचालित द्वारा

आइए Scala_Course नाम का एक trait परिभाषित करें, जिसे DataCamp क्लास द्वारा इनहेरिट किया जाएगा। trait के अंदर, आप abstract method scala() परिभाषित करेंगे, जिसे DataCamp क्लास में परिभाषित किया जाएगा।

trait Scala_Course{  
    def scala()  
}  

class DataCamp extends Scala_Course{  
    def scala(){  
        println("DataCamp has recently launched there first Scala course")  
    }  
}  

object Main{  
    def main(args:Array[String]){  
        var a = new DataCamp()  
        a.scala()  
    }  
}
संचालित द्वारा

अब उपरोक्त कोड को चलाते हैं।

ऊपर के उदाहरण में, scala() विधि abstract थी, इसलिए उसकी परिभाषा उस क्लास में दी गई जिसने उस trait को इनहेरिट किया।

लेकिन यदि कोई विधि (non-abstract) पहले से ही trait में implement की गई हो तो क्या होगा? ऐसे में, वह क्लास जो इस trait को extend करती है, उसे उस विधि को दोबारा implement करने की आवश्यकता नहीं होती।

इसे एक छोटे उदाहरण से समझते हैं।

trait BMW{

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

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


class Car extends BMW{
    // class variables
    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50

    // Class method
    def Merc_Specs()
    {
        println("Make of the Car : " + make1);
        println("Model of the Car : " + model1);
        println("Fuel capacity of the Car : " + fuel1);
    }
}

object Main  
{

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

        // Class object
        var obj = new Car();
        println("Calling the Class Method")
        obj.Merc_Specs();
        println("Calling the Trait Method")
        obj.Display();
    }
}
संचालित द्वारा

आइए ऊपर के कोड को चलाते हैं:

अब जब आपने abstract और non-abstract विधियों के बीच का अंतर समझ लिया है, तो देखते हैं कि क्या समस्या आती है जब किसी abstract विधि को उस क्लास में implement नहीं किया जाता जो उसे inherits या extends करती है।

इसी अवधारणा को समझने के लिए same उदाहरण का उपयोग करते हैं।

trait Scala_Course{  
    def scala()  
}  

class DataCamp extends Scala_Course{  
    def print(){  
        println("Error: Class DataCamp needs to be Abstract")  
    }  
}  

object Main{  
    def main(args:Array[String]){  
        var a = new DataCamp()  
        a.print()  
    }  
}
संचालित द्वारा

ऊपर दिए गए कोड को चलाने पर त्रुटि आती है, जैसा कि नीचे दिखाया गया है, क्योंकि आपने उस क्लास में trait की scala() (abstract) विधि को परिभाषित नहीं किया जिसने उसे इनहेरिट किया था।

ऊपर के कोड को काम कराने के लिए दो संभावित समाधान हो सकते हैं:

• DataCamp क्लास में scala() विधि परिभाषित करें या
• DataCamp क्लास को abstract घोषित करें।

आज के ट्यूटोरियल का अंतिम विषय है कि आप एक ही क्लास में एक से अधिक traits को कैसे इनहेरिट कर सकते हैं। तो आइए, इसे जल्दी से पूरा करते हैं।

trait A{
// methods
}
trait B{
// methods
}
class C extends A with B{
}
संचालित द्वारा

trait BMW{


    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40
}

trait Merc{


    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50


}



class Car extends BMW with Merc{

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


    def Merc_Specs()
    {
        println("Make of the Car : " + make1);
        println("Model of the Car : " + model1);
        println("Fuel capacity of the Car : " + fuel1);
    }

}


object Main  
{

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

        // Class object
        var obj = new Car();
        println("Calling the BMW Trait")
        obj.BMW_Specs();
        println();
        println("Calling the Merc Trait")
        obj.Merc_Specs();
    }
}
संचालित द्वारा

अंत में, ऊपर दिए गए कोड को चलाते हैं।

Congratulations!

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

अब आप जानते हैं कि प्रोग्रामिंग में Traits क्या होते हैं और Scala में उनका उपयोग कैसे किया जाता है। आपके लिए एक अच्छा अभ्यास यह होगा कि उस स्थिति का समाधान ढूंढें जब abstract विधि को उसे इनहेरिट करने वाली क्लास में परिभाषित न किया गया हो। उसी के लिए कोड लिखकर देखें और जाँचें कि क्या कोड बिना किसी संकलन त्रुटि के चलता है। एक छोटा संकेत: आप Scala में Abstract Classes पर नज़र डालना चाहेंगे।

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

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