מחלקות ואובייקטים ב-Scala

DataCamp לאחרונה השקה את הקורס הראשון שלהם בסקלה: התחלה בסקלה. תראו את זה!

גם, תסתכלו על ההדמיות הבאות:

• מדריך המתחילים בסקלה
• האם-אם בסקלה
• משתמשים בסקלה
• רשימות בסקלה

הקדם

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

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

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

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

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

התרשים שלהלן נותן לכם הגיון נוסף על זרימת תכנות מבוססת אובייקטים, או במידה מסוימת, מהו נראה למחלקה. בתמונה שלהלן, יש class car שיש לה attributes: fuel, max speed, ויכולה להיות לה עוד מאפיינים כמו model, make, וכן הלאה. יש לה מערכות שונות של methods כמו refuel(), getFuel(), setSpeed(), ויכולות להיות שיטות נוספות כמו change gear, start the engine, stop the engine, וכן הלאה.

אז,

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

קלאסים ואובייקטים בסקלה

כמו C++ וג'אווה, פרוגרמים מונחה-גוף בסקלה עוקבים בדיוק אחרי אותן הקונבנציות. יש בו את הקונספט של הגדרת קלאסים ואובייקטים ותוך קלאס מפעלים, וזהו כל מה שנדרש לתוך פרוגרמים מונחה-גוף בסקלה.

הצהרת קלאס

class Class_name{
// שיטות ומאפיינים
}

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

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

לבסוף, הגוף של קלאס בסקלה מוקף בסוגריות {}.

// שם הקלאס הוא Car
class Car
{

    // משתני קלאס
    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);
    }
}
object Main  
{

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

        // אובייקט קלאס</diy19
        var obj = new Car();
        obj.Display();
    }
}

שמירת הקוד הנ"ל בשם class.scala והרצתו במסוף כscala class.scala, ואתה צריך לראות את הפלט כפי שהוא מתואר מתחת.

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

בניית מפתחות בסקלה

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

ישנם שני סוגים של מפתחות בסקלה: מפתחות ראשיים ומפתחות עזר. במדריך זה, תלמד על מפתחות ראשיים (מקור: O'Reilly).

class Class_name(Parameter_list){
// שיטות, תכונות
}

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

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

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

// שם המועבד הוא Car
class Car(make: String, model: String, fuel: Int)
{

    // שיטת המועבד
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}

object Main

{

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

        // מקומות אובייקט מועבד מרובים
        var obj1 = new Car("BMW", "X7", 40);
        var obj2 = new Car("Mercedes Benz", "S350D", 50);
        obj1.Display();
        obj2.Display();
    }
}

בואו נראה בקצרה את היוצא:

ובכן, האם זה לא נהדר? עם העזרת הבנאדם, הצלחתם ליצור תוצאות יעילות יותר.

הכרזת אובייקטים בסקלה

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

מועבד יכול להכיל שלושה תכונות (מקור: GeeksforGeeks:

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

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

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

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

מאפשר לכם לראות תמונתית של הרכיבים המאוחדים במחלקה 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();
    }
}

מברך עליכם!

מברך על הסיום של הטוריאלוגיה הזו.

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

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

תוכלו לשאול שאלות כלשהיות הקשורות להדרכה הזו בחלק התגובות שלהלן.

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