מידע מורחב

  • תאריך
  • שעה 14:32
  • ע"י
  • צפיות 10142
  • תגובות 2
  • דירוג 0 /5

מושגים בסיסיים בתכנות מונחה עצמים ב- #C

Jul03
במאמר זה נסקור נושאים בסיסיים ב- #C הכוללים NameSapces, סוגי מחלקות כגון Interface, Abstract, סוגי משתנים כגון Public, Protect, Private, Static ונושאים נוספים הקשורים לתכנות מונחה עצמים וירושה ב- #C


NameSpace
עוטף את כל המחלקות בפרויקט ומאפשר חוסר התנגשות בין המחלקות השונות שאנשים שונים כתובים בתוכנית.
ניתן דוגמא פשוטה:
קובץ ראשון - Class1.cs
namespace TestLibrary
{
	public class Class1
	{
		// Rest of Class1's code....s
	}
}


קובץ ראשון - Class2.cs
namespace TestLibrary
{
	public class Class2
	{
		// Rest of Class2's code....s
	}
}


נשים לב שאומנם מדובר בשני קבצים שונים אך הם שייכים לאותו namespace שהוא TestLibrary


Abstract
נשתמש כאשר יש קוד משותף לכל המחלקות נשתמש בAbstract class, מטרתה העיקרית היא ליצור איזשהו סטנדרט לתוכנית, דבר כללי מאד, חסר מימוש, את הלוגיקה הכללית ביותר של התוכנית, את החיבור והקשר לתוכנית יבצעו כבר האובייקטים שיירשו ממנה.
לא ניתן ליצור אובייקט חדש מסוג המחלקה האבסטרקטית.
כיצד מגדירים Abstract Class ?
namespace TestLibrary
{
	public abstract class AbstractClassExample
	{
		public virtual void DoAction(int numOfAction) { }
		
		public virtual string CheckActionNumber(int ActionNamr)
		{
			string message = string.Empty;
			
			if (ActionNamr > 10)
			{
				message = "Not a valid number";
			}
			
			return message;
		}
	}
}

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


Interface
מחלקה אבסטרקטית שבה לא מוגדרים משתנים וכל הפונקציות בה הן אבסטרקטיות בלבד, מכילה חתימות של פונקציות בלבד.
דוגמא פשוטה ל Interface (מילה שמורה שמייצגת interface):
namespace TestLibrary
{
    public interface IAction
    {
        // some methods for example
        void setCurrentAction (int NumOfAction);
        int GetActionNumber(string ActionNamr);
    }
}


נשים לב כי ב IAction קיימים רק החתימות של שתי הפונקציות וכל אובייקט שיממש את IAction חייב לממש את שתי הפונקציות הנ"ל.


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


Virtual
הגדרת פונקציה מסוימת כvirtual היא בעצם הגדרת ברירת המחדל עבור אותה פונקציה, מחלקה היורשת ממחלקה המכילה פונקציה כזו יכולה להציע מימוש משלה לאותה פונקציה על ידי שימוש במילה השמורה override – פעולה המגדירה דריסה של הפונקציה במחלקה היורשת עם מימוש מיוחד משלה.
כיצד מגדירים זאת ?
public abstract class AbstractClassExample
{
    // for example

    public virtual void DoAction(int NumOfAction) { }
        
    public virtual int GetActionNumber(string ActionName)
    {
        return 0;
    }
}



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


Override
הגדרה למעשה של דריסה של פונקציה מסוימת, גם אם לפונקציה היה מימוש במחלקה הנגזרת ממנה כאשר נקרא לפונקציה נשתמש בלוגיקה שקיימת בפונקציה זו. בעצם overide מאפשר לממש את הפולימורפיזם המאפשר מימוש מאוחר יותר של לוגיקה מסוימת.
בהמשך לדוגמא שמלמעלה ניתן דוגמא נוספת שמגדירה את ה override בצורה המתאימה:
public class Class1 : AbstractClassExample
{
    // for example

    public override void DoAction(int NumOfAction) { }

    public override int GetActionNumber(string ActionNamr)
    {
        return 555;
    }
}


שימו לב לדריסה של אותה פונקציה! (עם אותו שם) רק שהפעם הלוגיקה שונה ולכן כשניצור מחלקה מהסוג class 1 הפונקציות האלה הם שיהיו בשימוש ולא הפונקציות שקיימות במחלקת האב ממנה יורשים.


Protected
הגדרת פונקציה או משתנה מסוג זה מאפשר גישה רק מאותה מחלקה ומחלקות הנגזרות ממנה בלבד.
כיצד מגדירים זאת ? (שימו לב לשימוש במילה השמורה protected לפני הגדרת טיפוס הפונקציה וכו'.
public class Class1
{
    protected void DoSomthing(int NumOfAction)
    {
        // Do some logic...
    }
}



Private
הגדרת פונקציה או משתנה מסוג זה מאפשר גישה מפונקציות של מחלקה בלבד.
נשים לב בדוגמא שרק פונקציות מהמחלקה עצמה עמו DoSomething יכולות להשתמש במשתנה הזה.
public class ExampleClassWithPrivateMember
{
    private int number;

    void DoSomthing(int NumOfAction)
    {
        Number = NumOfAction;
        // More logic...
    }
}


Public
הגדרת פונקציה או משתנה מסוג זה מאפשרים גישה אליה מכל מחלקה אחרת


Internal
הגדרת פונקציה או משתנה מסוג זה מאפשרים גישה אליה לכל פונקציה או מחלקה הנמצאים תחת אותו namespace. זוהי הגדרת ברירת המחדל עבור כל משתנה/פונקציה שניצור, לכן חשוב לציין את ההרשאה בכל יצירת משתנה/פונקציה.
כיצד מגדירים זאת ?
namespace TestLibrary
{
	public class ExampleClass
	{
		internal void DoSomething(int NumOfAction)
		{
			// This function will be available only in class that in
			// TestLibrary Namespace
		}
	}
}


כל מחלקה שמוגדרת תחת TestLibrary יכולה לגשת לפונקציה DoSomething


Sealed
הגדרת מחלקה כsealed אומרת שלא ניתן לרשת ממנה. כנ"ל לגבי מתודה sealed כלומר שלא ניתן לדרוס אותה, למצב זה קוראים מחלקה/מתוקה חתומה, נשתמש בזה כאשר נרצה לחסום את אפשרות הדריסה של פונקציה מסוימת באמצעות overide(מתאפשר כאשר מתודה היא virtual) – כלומר המחלקה היורשת אינה רשאית לדרוס פונקציה זו.
כיצד מגדירים זאת ?
namespace TestLibrary
{
	sealed class ClassThatCannotBeInherit
	{
		void DoSomething(int NumOfAction)
		{
			// This function is private only for this calss!
		}
	}
}



Static
הגדרת משתנה static פירושו משתנה של המחלקה, ו"אורך חייו" הוא כאורך חיי התכנית, פונקציה סטאטית היא פונקציה של המחלקה שניתן לקרוא לה מכל מקום בלי ליצור מופע של המחלקה.
ניתן דוגמא קלה :
namespace TestLibrary
{
	public class MyClass
	{
		public static int NumOfStudents;
	}
}


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

namespace TestLibrary
{
	public class OtherClass
	{
		public void UpdateNumber(int someNumber)
		{
			MyClass.NumberOfStudents = someNumber;
		}
	}
}


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

המאמר שם דגש על מושגים בסיסים בשפה ואני מקווה שהוא הועבר אליכם באופן ברור, הערות/הצעות לשיפור יתקבלו בברכה
עדיין לא נרשמת לאתר ? לחץ כאן להרשמה מהירה
נא המתן...
דירוג
  1. לא עברתי על הכל, אבל:
    "אורך חייו הוא כאורך חיי האובייקט"
    אמור להיות
    "אורך חייו הוא כאורך חיי התכנית"
  2. הערה התקבלה, העניין תוקן.
    תודה רבה :)


עליך להתחבר כדי להגיב. לחץ כאן להתחברות.