Interface - System object - עצרת

Interface

Interface – מחלקה של פונקציות שבמידה ומחלקה אחרת רוצה לירש היא חייבת לבצע את כל הפונקציות במחלקה אין את גוף הפונקציות אלא רק את השמות שלהם

מחלקה שלא אומרת איך לעשות אלא רק מה צריך לעשות

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

·        נהוג ששם ה interface יתחיל תמיד בi

·        הפונקציות ב interface ללא הרשאות גישה ולכן המחלקה חייבת  להיות public

·        ניתן לרשת יותר מ interface אחד !! (מחלקה יכולה לרשת רק ממחלקה אחת)

·        לא ניתן ליצור אובייקטים ממחלקה זו

·        אם רוצים לבצע הורשה + interface  קודם נגדיר את ההורשה ואח"כ את ה interface

·        Interface יורש interface ומי שירצה לממש את השני יצטרך לממש גם את הראשון

טיפ חשוב – כשיורשים Interface וצריכים לממש את כל ההצהרות לא צריך לכתוב אותם חדש! יש פונקציה של הVS שעושה את זה לבד.

לחיצה על ה Interface תציג מנורה נלחץ על המנורה > נבחר implement Interface > יפתח חלונית שתציג את כל הנתונים של שייווצרו > לחיצה על הכפתור תיצור השלד של כל המימושים

בתוך הפונקציה יהיה כתוב           ()  throw new NotImplementedException – (כתוב חדש - לא מומש)

System object

כל מחלקה יורשת מsystem object   ישירות או דרך מחלקה שממנה יורשת

ToString()  - פונקציה המתקבלת מ object   ביצוע הפונקציה על אובייקט מציג את הפרטים של האובייקט

Operator Overloading – ניתן לשנות את הפונקציה באמצעות Overloading שתציג מחרוזת טקסט שונה

לדוג'

public  String ToString()

        {

            string result = string.Empty;

            result = string.Format("widght and height are {0} and {1}" ,width ,height);

            return result;

        }

1.     הכרזנו על פונקציה בשם result ואתחלנו אותה

2.     מגדירים את המחרוזת

3.     מחזירים את הערך

  Console.WriteLine(shapes.ToString());

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

פונקציה רקורסיבית - עצרת

חישוב עצרת באמצעות פונקציה רקורסיבית

עֲצֶרֶת היא מכפלת כל המספרים הטבעיים מ־1 ועד למספר נתון. מוצג כ - N!

למשל, "4 עצרת" היא המכפלה

1*2*3*4=24

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

בכל פעם הפונקציה מכפילה את הערך שלה בקריאה לעצמה + הורדת המשתנה ב1 עד שמגיע ל1

ואז חוזר אחורה לחישוב

static int CalculateFactorial(int num)

        {

            if (num == 0)

                return 1;

            else

                return num * CalculateFactorial(num - 1)

}

לדוג' אם הערך הראשוני הוא 3 התוכנה יוצרת 3 פונקציות שכל אחת שולחת לבאה את הערך – 1 וממתינה לתשובה

כשהאחרונה תגיע ל0 היא חוזרת לזו שלפניה עם הערך 1 שמכפילה אותו ב2 וחוזרת לזו שלפניה שמכפילה אותו ב3

                                    

בנאי - הורשה - מערך אובייקטים

בנאי – דגשים

במידה ולא יוצרים בנאי יש בנאי ברירת מחדל של המערכת שמאתחל את כל השדות של האובייקט

אחרי שיצרנו בנאי – לא יתבצע יותר בנאי ברירת מחדל !

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

הורשה – כשבונים אובייקט מסוג בן  האתחול עובד ע"י אתחול אב ואח"כ בן (B נבנה מA+B)  ולכן חייבים לאתחל את השדות שהוגדרו באב

דוג'  לבנאי שמקבל 4 פרמטרים שלושה הוא מעביר לבנאי אב ואחד לעצמו

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

public ride(string name, int max, int minage , int lavel):base(name , max , min)

{

            this.fearLevel = lavel;

}

יצירת מערך של אובייקטים

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

שים לב!!!

הכרזת מערך אינה ממלאת אותו אלא רק מקצה מקום בזיכרון עבור מערך זה. כל עוד לא ביצענו השמה  למערך   הוא מכיל רק null.

דוג' – הגדרנו מערך של אובייקטים מסוג attraction

attraction[] a1 = new attraction[4];

אם ננסה לבצע המרה

a1[0].name = "dodo";

המערכת תעוף כיון שלא הוגדר האובייקט

לכן צריך לבצע הפניה לכל המערך באמצעות לולאה שתרוץ על כל המערך ותאתחל את כל אחד מהמקומות

for (int i = 0; i < a1.Length; i++)

     {

       a1[i] = new attraction();

     }                      

המילוי הזה יכול להעשות או ב   constructor   או ב-Main

יצירת מערך עם אובייקטים שונים

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

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

    attraction[] a1 = new attraction[4];

            a1[0] = new show();

            a1[1] = new show();

            a1[2] = new ride();

            a1[3] = new ride();

בדיקה אם אחד מהאברים הוא מסוג מסוים

if (a is show)

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

אתור מערך שבתוך מערך

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

1.     לולאה שרצה על כל המערך ובכל פעם מכניסה את האובייקט לA

2.     בדיקה - אם A  מסוג מופע תקרא לו באופן זמני S

3.     בדיקה – אם s.translation  = TRUE  - תבצע הפעולה

foreach (attraction a in a1)

            {

                if (a is show s)

                {

                    if (s.translation)

                    {

                        Console.WriteLine($"{s.name} is trans");

                    }

שים לב!! – כשמגדירים  אובייקט  A  כאובייקט B  המימוש שלו כמו הוא כמו B !! אומנם הוא מסוג A  אבל במימוש הוא שווה ל B   ולכן לא נוכל לגשת לפונקציות של A

בשביל לגשת לפונקציות של A יש לעשות המרה 

דוג' מהקוד שהובא מקודם

ב a1[3] נקבל רק את הפונקציות של attraction בשביל לקבל גם את הפונקציות של ride נצטרך לבצע המרה שאומרת תתייחס ל attraction כ ride

((ride)(a1[3])).fearLevel = 10;

Placeholder (מצביע מיקום {}) + $

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

השיעור למדנו לכתוב זאת בצורה יותר מועילה – שמים $ בתחילת המחרוזת שזה אומר לתוכנית להתייחס למה שבתוך ה{} כמשתנה ולא כחלק מהמחרוזת ומציבים את המשתנה  בתוך הסוגרים

Console.WriteLine($"circle {Circle.count}: radius is {radius}");

תזכורת

·        משתנה מתחיל באות קטנה ואם זה כמה מילים אז הראשונה בכל מילה תהיה גדולה

·        פונקציות ומחלקות מתחיל באות גדולה

·        משתנה לא יכול להתחיל במספר ולא להכיל רווח