מאפיינים ב-Scala

דאטהקאמפ יצא לאחרונה עם קורס סקאלה הראשון שלהם: הקדמה לסקאלה. בדקו את זה!

אתם גם עשויים להתעניין בקריאת ההדרכות הבאות:

• מדריך למתחילים בסקאלה
• IF ELSE בסקאלה
• פעולות בסקאלה
• רשימות בסקאלה
• קלסים ואובייקטים בסקאלה

הקדמה

טרייט הוא תפיסה שמשמשת בעיקר בתחום תכנות מונחה-אובייקטים, היכולה להרחיב את הפונקציונליות של קלס באמצעות סט של שיטות.

תכונות דומות ברוחן ל-ממשקים בשפת התכנות Java. בניגוד למחלקה, תכונות ב-Scala לא ניתן להציג ואין להן ארגומנטים או פרמטרים. עם זאת, ניתן לרשת (להרחיב) אותן באמצעות מחלקות ואובייקטים. עם זאת נאמר, תכונות מספקות קבוצה ספציפית של שיטות/פונקציות שמבצעות התנהגות למחלקה ומצפות שהמחלקה תיישם קבוצה של שיטות שמפרמטרות את ההתנהגות המסופקת.

תכונה שמוגדרת לאובייקט נוצרת כתערובת של שיטות שניתן להשתמש בהן על ידי מחלקות שונות מבלי לדרוש ירושה מרובה. עם זאת, ייתכן שיהיו מקרים חריגים בהם לשתי תכונות יש שיטה עם אותו שם (התנגשות שמות), שצריכה לשמש על ידי מחלקה, ובמקרה זה יש לפתור את העמימות במפורש.

לתכונות יכולות להיות גם שיטות אבסטרקטיות וגם לא-אבסטרקטיות, שדות כחברים בתכונה. כאשר לא מאתחלים שיטה בתכונה, הן אבסטרקטיות, בעוד שאותן שאותחלו נקראות לא-אבסטרקטיות. בשיטות האבסטרקטיות, המחלקה שמיישמת את התכונה מטפלת באתחול.

כעת, בואו נבין במהירות תכונות Scala בעזרת כמה דוגמאות!

תחביר תכונה ב-Scala

התחביר לתכונה ב-Scala הוא פשוט, הוא מוגדר על ידי מילת המפתח trait ואחריו שם התכונה.

trait Trait_Name{
// משתנים
// שיטות
}

כפי שאתם יכולים לראות מההגדרה העליונה של המיקום, תכונה בשם DataCamp נוצרה, שבתוכה אין מופיעים משתמשים ושיטות.

בואו נעבור למדיום פשוט של תכונות בסקלה, שיעניק לכם הרבה בהבנה טובה יותר על איך הם פועלים באופן קודמטי.

כפי שדובר בההקדם, תכונות בסקלה נשארות על ידי המחלקה בעזרת המילה extends.

class Scala_Tutorial extends DataCamp{
// משתמשים
// שיטות
}

בואו נוציא תכונה בשם Scala_Course, שתהיה מורשת על ידי המחלקה DataCamp. בתוך הtrait, תוכלו להגדיר שיטה מופיעה בשם 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() היתה שיטה מופיעה, ולכן, ההצגה נעשתה במחלקה המורשת את התכונה.

אבל מה אם יש לך שיטה (עיקרית) שכבר מופיעה בתכונה? טוב, במקרה זה, המחלקה המרחיצה את התכונה הזו לא צריכה לממש את השיטה שכבר מופיעה בתכונה.

בואו נבין את זה עם מדמה קטנה.

trait BMW{

    // משתני תכונה
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // שיטת תכונה: לא-מופשטת
    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{
    // משתני מחלקה
    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50

    // שיטת מחלקה
    def Merc_Specs()
    {
        println("Make of the Car : " + make1);
        println("Model of the Car : " + model1);
        println("Fuel capacity of the Car : " + fuel1);
    }
}

object Main  
{

    // שיטה ראשית
    def main(args: Array[String])  
    {

        // אובייקט מחלקה
        var obj = new Car();
        println("Calling the Class Method")
        obj.Merc_Specs();
        println("Calling the Trait Method")
        obj.Display();
    }
}

בואו נריץ את הקוד הנ"ל:

עכשיו כשאתם מבינים את ההבדל בין שיטות מופשטות לבין שיטות לא-מופשטות, בואו נראה מה יכול להשתבש כששיטה מופשטת לא ממומשת במחלקה שיורשת או מתארכת אותה.

בואו נשתמש באותו דוגמה כדי להבין את הקונספט הזה.

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()  
    }  
}

הרצת הקוד הנ"ל תגרום לשגיאה, כפי שמוצג למטה, מכיוון שלא הגדרת את שיטת התכונה scala() (מופשטת) במחלקה שירשה אותה.

כדי לגרום לקוד הנ"ל לעבוד, ישנם שני פתרונות אפשריים:

• הגדירו את שיטת scala() במחלקה DataCamp או
• הגדירו את מחלקת DataCamp כמופשטת.

הנושא האחרון להיום הוא כיצד ניתן לירש מספר תכונות במחלקה אחת. אז, בואו נסיים את זה במהירות.

trait A{
// שיטות
}
trait B{
// שיטות
}
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  
{

    // שיטה ראשית
    def main(args: Array[String])  
    {

        // אובייקט מחלקה
        var obj = new Car();
        println("Calling the BMW Trait")
        obj.BMW_Specs();
        println();
        println("Calling the Merc Trait")
        obj.Merc_Specs();
    }
}

לבסוף, בואו נריץ את הקוד הנוסף הזה.

מזל טוב!

מזל טוב שסיימתם את ההדרכה הזו.

כעת אתם יודעים מהיו טרייטים בתכנות ואיך להשתמש בהם בסקלה. משימה טובה עבורכם תהיה למצוא פתרון לשיטת שיטה מופשטת שלא מוגדרת בכיתה שירשה אותה. נסו לכתוב קוד עבור אותה וראו אם הקוד רץ בלי שגיאת קומפילציה. טיפ קטן, אולי תרצו להסתכל על כיתות מופשטות בסקלה.

תרשו לשאול שאלות על ההדרכה הזו בחלק התגובות שמתחת.

לבסוף, אל תשכחו לקחת את קורס הסקלה החדש ב-DataCamp, הקדמה לסקלה.