using System;

namespace Ex

{

    public class Program

    {

        public static void Main()

        {

            //Console.WriteLine("Hello World");

            // InterA a = new InterA ();   // לא ניתן ליצור עצמים מטיפוס ממשק!!!

            Student st = new Student();   // תקין

            InterA a11 = st;      // יצרנו עצם מטיפוס תלמיד, והמצביע איי מטיפוס הממשק מצביע על העצם תלמיד

            // שורה זו תקינה כי תלמיד מממש את הממשק

            /*

            Person p = new Person();

            InterA aa = p;    // לא תקין, כי המחלקה בן-אדם לא מממשת את הממשק

            */

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

            // קטע קוד 1

            /*

            A a = new A ();            // תקין - יצרנו עצם מטיפוס איי

            B b = new B ("hi");        // תקין - יצרנו עצם מטיפוס בי

            Console.WriteLine (a.ToString());  // x=1

            Console.WriteLine (b.ToString());  // x=1 name=hi

            // קטע קוד 2

            A a1 = new B ("hi");   

            קטע קוד תקין

            הבן בי יורש מהאב איי

            ויצרנו כאן עצם מטיפוס בי (הבן), אשר יש לעצם זה הפניה מטיפוס איי (האב)

            התבצעה כאן המרה אוטומאטית כלפי מעלה

            (מצביע מטיפוס אב יכול תמיד להצביע על עצם מטיפוס בן)

            // קטע קוד 3

            A a2 = (A)(new B ("hi"));

            תקין

            קוד שקול לחלוטין לקטע הקוד הקודם

            ביצענו כאן המרה כלפי מעלה

            */

        }

    }

}

​

​

// דוגמה

​

// ממשק

public interface InterA

{

    void Stam();   // כותרת הפעולה בלבד, ללא המילה השמורה פאבליק    

}

​

// מחלקה שמממשת את הממשק

public class Student : Person, InterA   

//אם מחלקה תלמיד יורשת מחלקה בן-אדם ומממשת ממשק, 

//אז בכותרת קודם חובה לרשום את שם המחלקה המורישה ורק אחר-כך את שם הממשק (לפי הסדר הזה בלבד)

{

    public void Stam ()           // מימוש הפעולה של הממשק - כותרת וגוף הפעולה

    {

        Console.WriteLine("Hello");

    }

}

​

public class Person

{

}

​

​

// דוגמה נוספת

// נרשום מחלקה בי שיורשת את המחלקה איי אשר מממשת ממשק

// המחלקה איי מממשת ממשק

​

// B -> A ---> InA

​

public interface InA

{

    void Mes ();    

}

​

public class A : InA

{

    protected int x;

    public A ()

    {

        this.x = 1;

    }

    public void Mes ()

    {

        Console.WriteLine("A implements InA");

    }

    public override string ToString ()

    {

        return "x = " +this.x;

    }

}

​

​

public class B : A

{

    private string s;

    public B (string s) : base ()

    {

        this.s = s;

    }

    public void Print ()

    {

        Console.WriteLine("bye");

    }

    public override string ToString ()

    {

        return base.ToString() + ", name = " + this.s;

    }

}

​

​

​

​

​

​

​

/*

מחלקות אבסטרקטיות

Abstract classes

מחלקה אבסטרקטית (מופשטת, מדומה) היא מחלקה מיבנית (שלדית),

שלא ניתן ליצור מהן אובייקטים.

​

ממשקים

Interface

ממשק הוא מחלקה אשר כל המתודות (פעולות) בה לא ממומשות,

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

(רושמים רק את כותרת הפונקציה בלבד, וללא המילה פאבליק)

למשל:

נניח נרצה לרשום פעולה שמדפיסה הודעה על המסך

void Mes ();

​

לא ניתן ליצור עצמים של ממשקים!!!

​

כל מחלקה שתירש ממשק כלשהו חייבת לממש את כל הפונקציות שלו

​

ניתן לרשת מספר ממשקים (יש להפריד ביניהם באמצעות פסיק),

כלומר כל מחלקה יכולה לממש ממשקים רבים

​

הערה: מחלקה מסוימת יכולה לרשת מחלקה אחרת ולממש ממשק (או כמה ממשקים).

במקרה כזה, תחילה עלינו לרשום את שם המחלקה שממנה יורשים, ורק לאחר-מכן את שם (או שמות) הממשקים אותם מממשים

(מופרדים בפסיקים ביניהם)

​

סימון:

(בתרשים UML)

חץ מקווקוו, כאשר ראש החץ נמצא בממשק, וזנב החץ נמצא במחלקה המממשת

​

מבנה הממשק:

public interface שם הממשק

{

    // כותרות של פעולות ללא גוף שלהן

}

​

מחלקה שמממשת ממשק תראה באופן הבא:

public class name_class : name_interface

{

    // מימוש כל הפעולות של הממשק

}

​

​

הערה - ממשק יורש ממשק

אם ממשק

B

יורש ממשק

A

ובנוסף, מחלקה

B

מממשת את הממשק

B

אז המחלקה

B

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

​

כמו-כן, אם מחלקה

C

יורשת מחלקה

B

אז מחלקה

C

לא התחייבה לממש את הממשקים

אבל היא כן יכולה להשתמש בפעולות הממשק שמומשו במחלקה

B

ממנה היא יורשת

​

​

תרשים המחלקות

ClassC -> ClassB ----->InterB -----> InterA

​

​

​

​

​

​

​

​

​

​

​

​

​

​

​

​

​

​

​

​

​

​

*/

​

​

​

​

​

​

​

​

​

​

​