תכנות מונחה עצמים - מעשי

תכנות מונחה עצמים - מעשי

ליווי מקצועי : ארז קלר

www.corner.co.il

Web Services

(.Encapsulationהמחלקה )•(.Inheritanceהורשה )•.(Polymorphismרב צורתיות )•(.Interfaceממשקים )•

(Encapsulationהמחלקה )

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

מופע על לבצע שניתן ופעילויות נתונים בתוכו (Instance( של המחלקה הנקרא אובייקט )Object.)

ב- • מממשת את התכונה הראשונה של #Cהמחלקה OOP הכמסה – Encapsulation.

היא לא יותר מאשר אוסף של מחלקות #Cתוכנית ב- •וקשרים ביניהן.


.Private( תמיד יהיו Data Membersתכונות )•.Public וגם Private( יכולים להיות גם Methodsשיטות )•

אין חשיבות לסדר הגדרת חברי המחלקה.• מצייני גישה בנוסף 3 מגדירה #Cשפת •

:Public ו- Privateל- •Protected•internal• protected internal.

)עליהם נדון בהמשך הקורס(

public class ClassName{ private Type field1; private Type field2; … private Type fieldN; public Method 1)( { … } public Method 2)( { … } … public Method N)( { … } }


קוד המחלקה:public class Personדוגמה

{ private int m_ID; private string m_LastName; private string m_FirstName; private int m_Age;

public Person)( { . . . } public Person)int id( { . . . }

public SetPerson). . .( { . . . } public void Print)( { . . . } public WriteToFile)( { . . . } public ReadFromFile)( { . . . } . . .

}

כותרת המחלקה

תכונות המחלקה,Data Member

שיטות בונות - Constructor

שיטות המחלקה


קוד המחלקה:תכונות המחלקה מתארות את האובייקט.

בדוגמה: התכונות מתארות את פרטי אדם, שם פרטי שם משפחה ת"ז וכו'.

public class Person{ private int m_ID; private string m_LastName; private string m_FirstName; private int m_Age;

. . .}


קוד המחלקה:שיטות המחלקה מגדירות את ההתנהגות

של האובייקט.בדוגמה:

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

שינוי פרטים,כתיבה וקריאה מקבצים.

public class Person{ . . . public Person)( { . . . } public Person)int id( { . . . } public SetPerson). . .( { . . . } public void Print)( { . . . } public WriteToFile)( { . . . } public ReadFromFile)( { . . . } . . .}


דוגמה נוספת: מייצגת נקודה במרחב,Pointהמחלקה

המחלקה מספקת את כל הפונקציונאליות

public class Pointהנדרשת.{ private int m_X; private int m_Y; public Point )int x, int y( { . . . } public void Print)( { . . . } public Point SetPoint)Point p( {. . . } public bool IsValid)( { . . . } public WriteToFile)( { . . . } public ReadFromFile)( { . . . }}

כותרת המחלקה

תכונות המחלקה,Data Member

שיטה בונה - Ctor

שיטות המחלקה

(.Encapsulationהמחלקה )

בנאים•( או Constructorsהבנאים Ctor אשר מיוחדות, שיטות הינם )

ברגע שנוצר אובייקט.Data Membersתפקידם לאתחל את ה- הפעולה הראשונה שאובייקט מבצע במהלך חייו הוא קריאה ל- •

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

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

אשר אינו מקבל פרמטרים ותפקידו לאפס Default Ctorיתווסף .Data Membersאת ה-


בנאיםכללים ביצירת בנאים :

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

public.


בנאיםבנאים, דוגמה:

Public class Point{

int m_X; int m_Y; public Point )( { . . . } public Point )int x, int y ( { . . . }. . .

}

שם הבנאי כשם המחלקההבנאי אינו מחזיר ערך, גם לא

void,מאתחל את כל התכונות.


Ctorהפעלת ה-

public class App

{

public static void Main)(

{

Point p1 = new Point)(;

p1.Print)(;

Point p2 = new Point)3,7(;

p2.Print)(;

}

}

הפעלת בנאי ברירת מחדל

(Default Ctor)

הפעלת בנאי שמקבל פרמטרים.


העברת הביצוע מבנאי אחד לבנאי אחר(.Initializer List רשימת אתחול )Ctorניתן הוסיף ל- • Ctors יכול להיעזר ב- Ctorבאמצעות רשימת האתחול ה- •

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

המקורי Ctor המקורי, אלא בנוסף אליו. ה- Ctorביצועו של ה- יבוצע אחרון.


העברת הביצוע מבנאי אחד לבנאי אחר - המשך

public class Point{ …

public Point )( : this )0,0({ . . . }public Point )int x, int y( : this )x,y,”blue”( { this.x=x; this.y=y; } public Point )int x, int y, string c( { this.x=x; this.y=y; this.color=c; }

}


Private Constructorsבנאים פרטיים - (.Private Constructor כבנאי פרטי )Ctorניתן להגדיר •המטרה – למנוע ממחלקות אחרות להקצות אובייקט •

מהמחלקה.(.Static Methodשימושי כאשר כל המתודות הן סטאטיות )•

public class Math

{

public static int Cos)int x( { ... }

public static int Sin)int x( { ... }

private Math) ( { }

}


האובייקט( של מחלקה. ממחלקה ניתן Instanceאובייקט הוא מופע )•

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

( מוגדרים.Scope( וטווח הכרה )Life timeחיים )המחלקה היא "בית יוצר" לאובייקטים, ניתן לראותה גם •

כתבנית ממנה "יוצקים" אובייקטים בעלי מבנה זהה..Reference Typeאובייקטים הינם תמיד •


האובייקטהקצאת אובייקט הינו תהליך בן שני שלבים:

שלב א – הקצאת דינמית של האובייקט.• אשר מאתחל את האובייקט Constructorשלב ב – הפעלת •

בערכים ראשוניים.

לדוגמה:

Point p1 = new Point)3,7(;

, לא ניתן להימנע Constructorבהקצאת אובייקט תמיד יופעל מכך.


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


האובייקטC#:מאפשרת להגדיר מספר ייחוסים המיוחסים לאובייקט יחיד

Point p1 = new Point)3,7,Color.Red(; Point p2 = p1;


האובייקט

הקשר את לשחרר רצוי באובייקט צורך עוד אין כאשר בין הייחוס לאובייקט:

p = null פעולה זו אינה משחררת את האובייקט, האובייקט

ישחררו. Garbage Collectionישוחרר רק כאשר ה-


Methods Overloadingהעמסת שיטות – ניתן להגדיר במחלקה אחת מספר שיטות בעלות אותו השם.

•C # מבחינה בין שיטות שונות בעלות אותו השם באמצעות מספר הפרמטרים או טיפוס הפרמטרים.

לא ניתן להבחין ביניהן על פי הערך המוחזר.•public class ClassName{

public void Method )int n1( { . . . } public void Method )int n1, int n2( { . . . } public void Method )float fn1( { . . .}

}


Methods Overloadingהעמסת שיטות – ניתן )ואף רצוי( להעמיס גם בנאים.

לדוגמה:public class Point{ …

public Point )( { . . . } public Point )int x, int y( { . . . } public Point )int x, int y, string c( { . . . }

}


thisהאופרטור הקומפיילר מוסיף לרשימת הפרמטרים של השיטה פרמטר כאשר קוראים לשיטה,•

חשוב נוסף .. הפרמטר הנוסף הנו ייחוס לאובייקט שהפעיל את השיטה•(.static Methods, הוא מתווסף אוטומטית לכל השיטות )למעט ל-thisהייחוס נקרא •. הנה מילה שמורהthisהמילה • אולם ניתן להשתמש בו. (Implicitהייחוס נשלח לשיטה בצורה מרומזת )• this חובה להשתמש בייחוס Data Memberכאשר שם של פרמטר זהה לשם של •

(this.x=xעל מנת שהקומפיילר ידע להבחין ביניהם. )(color=c , אך אין זו חובה. )thisבשאר המקרים מותר להשתמש בייחוס •

void Move)int x, int y(לדוגמה :

{

this.x = x; this.y = y;

}


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

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

•C # ( מתירה להשתמש בחברי מחלקה קבועים Constants Data Members( וחברי מחלקה לקריאה בלבד )Read only Data Members.)

Staticהקבועים הם ברמת המחלקה, דהיינו , הם תמיד יהיו סטטיים )•const.)

משתני מחלקה לקריאה בלבד הם קבועים ברמת המחלקה, דהיינו, כל •.Data Memberאובייקט יכול להכיל ערכים שונים לאותו

,Compile Time נקבע ב- Constערך של משתנה • .Run Time נקבע ב- Read Onlyערך של משתנה •


Constקבועים - חברי מחלקה אלו הם קבועים ברמת המחלקה, ולכן הם תמיד יוגדרו כ- •

Static. •C# -מאפשרת להגדיר קבועים רק כ Data Members או כקבועים

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

דורש ערכים לקבועים על מנת להעבירם קומפילציה בהצלחה.•Const Data Members מגדירים באמצעות המילה השמורה const.

class Sampleלדוגמה:{ private const float PI = 3.14f; . . . }


Read Onlyקריאה בלבד – חברי מחלקה אלו הם קבועים ברמת האובייקט.••Read only Data member ,ניתנים לאתחול פעם אחת בלבד

בבנאי של המחלקה, ומאותה נקודה הם אינם ניתנים עוד לשינוי.

•Readonly Data Members מגדירים באמצעות במילה .Readonlyהשמורה

class Sample{ private readonly int m_ID ; . . . }


Propertiesמאפיינים ( Data Membersתכנון נכון של מחלקה מסתיר את התכונות )•

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

כאשר אדם עובר דירה? כאשר עובד מקבל העלאה במשכורת? וכו'

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

משכורתו של עובד וכו'במקרים אלו ,כמו ברבים אחרים, נזדקק למכניזם מסוים אשר •

( את הערכים הקיימים Run timeיאפשר לשנות בזמן ריצה )בתכונות.


Propertiesמאפיינים ( עונה הן על הצורך של השימוש בשיטות Propertiesמנגנון המאפיינים )•

לקביעת ערך של חבר מחלקה והן על הצורך בשיטות לגישה לערכו של חבר מחלקה

לשינוי set לגישה לערכו של חבר מחלקה ו- getהמאפיין יכיל שני בלוקים: •ערכו של חבר מחלקה

עבור התכונות או רק באחד מאותם Get והן ב- Setניתן להשתמש הן ב- •Accessors:

Read Only property מכונה getמאפיין שמגדיר רק בלוק

Write only property מכונה setמאפיין שמגדיר רק בלוק לא חובה להגדיר מאפיין עבור כל התכונות.••C# מאפשרת להגדיר גם Static Properties עבור תכונות סטאטיים

(Static Data Members.)


Propertiesמאפיינים

valueהנו משתנה אוטומטי שמוגדר

ונועד להשמת המידע החדש set בתוך

בשדה הרלוונטי.

Value הנה מילה שמורה והטיפוס ממנו

נוצר משתנה אוטומטי זה מוגדר

.Property של ה – Prototypeב –

private string data_member;public string PropertyName{

get { return data_member;

} set {

data_member = value; }}

השמת ערך בתכונה

החזרת ערך של תכונה


Propertiesמאפיינים השוואה בין מאפיינים לתכונות:

Logical Fieldsמאפיינים מכונים שדות לוגיים – •למאפיינים אין כתובת ואין ערך•מאחורי הקלעים מאפיינים הן שיטות לכל דבר ועניין•לא מומלץ להשתמש בשדות חישובים, לצורך כך ניתן להיעזר ב- •

Get Property של שימוש במאפיינים Syntaxמבחינת המשתמש במחלקה- ה- •

של שימוש במשתנים: "ללכת בלי להרגיש עם ... Syntaxזהה ל- "


Propertiesמאפיינים השוואה בין מאפיינים לשיטות:

דומהמכילים קוד•static או virtual, abstract, overrideיכולים להיות •מסתירים את המימוש•

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


Propertiesמאפיינים סוגים של מאפיינים:Read/write properties - מכיל הן גישתget והן גישת set.

Read-only properties - מכיל גישתget.בלבד, אינו קבוע

Write-only properties - מכיל גישתset.בלבד

Static properties - מתייחס למחלקה ומאפשר גישה

לחברי מחלקה סטטיים בלבד.


Propertiesמאפיינים לפני ביצוע ההשמה setתמיד נבדוק את המידע המגיע לבלוק •

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

.getאל מחוץ לגבולות המחלקה מתוך בלוק היא בנוחות השימוש במחלקה, Propertiesחשיבותם של ה- •

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

הקוד הרבה יותר קריא וקל לתחזוקה.•


public class Pointדוגמה{

private int m_X;private int m_Y;public Point)int x,int y( { … }public int X{

get{ return this.m_X;}set{ if)value >= 0 && value <=1024(

this.m_X = value;}

}

השמת ערך בתכונה

החזרת ערך של תכונה


יחסי הכלה בין אובייקטיםקיימים שלושה סוגים של יחסי הכלה בין אובייקטים:

Aggregation, Composition, Assication

Composition ( נקראת Parent( למחלקה מכילה )Childמערכת היחסים בין אובייקט מוכל )

Composition( כאשר אורך החיים Life Time של האובייקטים המוכלים תלוי )באורך חייו של אובייקט מהמחלקה המכילה. המחלקה המכילה מכונה גם

Container.

Aggregation Aggregation לאובייקט למחלקה מכילה מכונה Referenceמערכת היחסים בין

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


יחסי הכלה בין אובייקטיםAssociation

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

":Has Aיחסי הכלה מזוהים על ידי " יש מסך,מקלדת, ספק כוח, דיסק PCלדוגמה : למחשב

קשיח ...

למכונית יש מנוע, שלדה, הגה, גלגלים.


יחסי הכלה בין אובייקטיםדוגמה

.Pointהעצם המוכל מהמחלקה

class Point{

private int m_X;private int m_Y;public Point )( { . . . }public Point)int x,int y( { . . . }public int X{

set { . . . }get { . . . }

}public int Y{

set { . . . }get { . . . }

}public void Print)( { . . . }

}


יחסי הכלה בין אובייקטים.Circleדוגמה: המחלקה המכילה

class Circle{

private Point m_Center;private int m_Radius;public Circle)({

m_Center = new Point)(;m_Radius = 1;

}public Circle)int x,int y,int r({

m_Center = new Point)x,y(;m_Radius = r;

}. . .

}

האובייקט המוכל

הקצאת האובייקט המוכל

הקצאת האובייקט המוכל


יחסי הכלה בין אובייקטים - המשך.Circleדוגמה: המחלקה המכילה

class Circle{

private Point m_Center;private int m_Radius;. . .public void Print)({

m_Center.Print)(;Console.WriteLine)"Radius = {0}",m_Radius(;

}}

הדפסת האובייקט המוכל


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

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

הסרה, הדפסה )של כולם(, מיון, חיפוש, וכו'.מקובל להפריד בין מחלקה המטפלת ברמת האובייקט היחיד •

לבין המחלקה המטפלת ברבים. לדוגמה(, Circleמקובל שלמחלקה המטפלת ברמת היחיד )•

CircleArrayתיכתב מחלקה המטפלת ברמת הרבים ) לדוגמה(.


מחלקות אוסףדוגמה:

class Circle{ private Point m_Center; private int m_Radius; . . .}

מחלקה המטפלת באובייקט יחיד

class CircleArray{ private Circle[] m_Arr; private int m_Counter; . . .}

מחלקה המטפלת באוסף אובייקטים

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

מספר האיברים הנמצאים במערך.


מחלקות אוסףclass CircleArrayדוגמה , המשך:

{ private Circle[] m_Arr; private int m_Counter;

public CircleArray)( { . . . } public void Add)Circle Circle( { . . . } public void Add)int x,int y,int radius( { . . . } public void Delete)int x, int y( { . . . } public void Print)( { . . . }}

הטיפול במערך אובייקטים יכיל : הוספה

מחיקה הדפסת כל האובייקטים, ויכול להכיל

פעילויות נוספות כגון: מיון, חיפוש וכו'


(Inheritanceהורשה )

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

• - נגזרת מחלקה מכונה היורשת , class Derivedהמחלקה .class Baseהמחלקה המורישה מכונה מחלקה בסיסית -

" בין מחלקות.Is Aההורשה מממשת יחסי "•


תחביר:

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

class Base

{

}

class Derived: Base

{

}

מחלקת הבסיס

המחלקה הנגזרת


( ( מכירה את כל החלקים Derived Classהמחלקה הנגזרת (, Base class( של מחלקת הבסיס שלה )Publicהציבוריים )

( של Privateאולם המרכיבים הפרטיים )

מחלקת הבסיס חסומים גם בפניה. class Base{ private int m_BaseNum; . . .}class Derived : Base{ private int m_DerivedNum; public Derived)int bnum, int dnum( { m_BaseNum = bnum; this.m_DerivedNum = dnum; } . . .}

שגיאת קומפילציה


(Init Listרשימת אתחול ) וה-' Base נוצרים שני אובייקטים, ה- Derivedבהקצאת אובייקט מהמחלקה •

Derived. .Derived נוצר ראשון ולאחריו נוצר ה- Baseה- • , אחד של מחלקת הבסיס, והשני Ctorsבהקצאת האובייקט הנגזר מופעלים שני •

של Ctor . מכיוון שסדר הבנייה הוא מהבסיס לנגזרת ה- Derivedשל מחלקת .Derived של מחלקת ה- Ctor יופעל ראשון, ולאחריו יופעל ה- Baseהמחלקה

, נדאג לשלוח Mainעל מנת לייעל את תהליך בניית האובייקט המוקצה ב- •( , על Init List של מחלקת הבסיס באמצעות רשימת אתחול )Ctorפרמטרים ל-

.baseמנת לבצע זאת נשתמש במילה השמורה של המחלקה Ctor תפעיל את ה- Mainבמקרה זה הקצאת האובייקט ב- •

Derived -ה , Ctor -של מחלקה זו יפעיל את ה Ctor של מחלקת הבסיס אשר של המחלקה Ctorמקבל פרמטר בודד, ורק לאחר שהאחרון יחזור יבוצע ה-

הנגזרת.


Init Listדוגמה:

class Base{ private int m_BaseNum; public Base)int bnum( { m_BaseNum = bnum; } . . .}class Derived : Base{ private int m_DerivedNum; public Derived)int bnum, int dnum(:base)bnum( {

this.m_DerivedNum = dnum; } . . .}

רשימת אתחול, הפעלת הבנאי

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


Chain Inheritanceהורשה רב דורית – מחלקה נגזרת בעצמה יכולה לשמש, בתורה, כבסיס לגזירה על

ידי מחלקה אחרת וכו'class Base

{

public void PrintBase)({ … }

}

class Derived1:Base

{

public void PrintDerived1)( { … }

}

class Derived2:Derived1

{

public void PrintDerived2)( { … }

}


Chain Inheritanceהורשה רב דורית – נוצר ראשון אובייקט Derived2בהקצאת האובייקט מהמחלקה •

לאחר מכן נוצר אובייקט מהמחלקה Baseמהמחלקה Derived1 ולבסוף נוצר אובייקט מהמחלקה Derived2.

מודעת לכך שהיא יורשת את המחלקה Derived2המחלקה •Derived1 אולם אין היא מכירה את מבנהו הפנימי של , Derived1 ואין היא מודעת לקיומה של המחלקה ,Base .

מחלקת הבסיס שלה היא "קופסא Derived2מבחינתה של •שחורה"


Tree Inheritanceעץ הורשה –מחלקה יכולה לשמש כבסיס למספר רב של מחלקות


Tree Inheritanceעץ הורשה –לדוגמה:


Tree Inheritanceעץ הורשה –class BaseShape{ private int m_X; private int m_Y; private ConsoleColor m_Color; public BaseShape)( {. . .} public BaseShape)int x, int y, ConsoleColor c( {. . .} public void MoveTo)int x,int y( {. . .} public void PrintShape)( {. . .}}



Tree Inheritanceעץ הורשה –

class Circle:BaseShape{

private int m_Radius;public Circle)( { . . . }public Circle)int x, int y, ConsoleColor c, int r( : base)x, y, c( { . . . }public void Resize)int m_Radius( { . . . }public void PrintCircle)( { . . . }public int CalcArea)( { . . . }public int CalcPerimeter)( { . . . }

}

מחלקה נגזרת


Tree Inheritanceעץ הורשה –class Rectangle:BaseShape{

private int m_Height;private int m_Width;public Rectangle)( { . . . }public Rectangle)int x, int y, ConsoleColor c, int h, int w(

: base)x, y, c( { . . . }public void Resize)int h,int w( { . . . }public void PrintRectangle)( { . . . }public int CalcArea)( { . . . }public int CalcPerimeter)( { . . . }

}

מחלקה נגזרת


Generalization vs. Specializationככל שמחלקה היא בסיסית יותר, כך היא כללית יותר •

(Generalization .דהיינו, מייצגת רעיון כללי ולא ממוקד ,) ככל שנתקדם במורד "עץ ההורשה" נתקל במחלקות •

המייצגות רעיונות או עצמים מפורטים וממוקדים יותר, דהיינו, (.Specializationהתמחות )

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

היא מייצגת את המכנה המשותף שלהם.


Generalization vs. Specializationלדוגמה:

class BaseShape{ . . .}class Circle:BaseShape{ . . . }class Rectangle:BaseShape{ . . . }

מחלקת הבסיס, מייצגת צורה כללית ולא

ממוקדת.

המחלקה הנגזרת, מייצגת צורה מוגדרת

וברורה.

המחלקה הנגזרת, מייצגת צורה מוגדרת

וברורה.


Protected הרשאת גישה ( אינן יכולות Derived Classמתודות של מחלקות נגזרות )•

Baseלגשת לחברים הפרטיים של המחלקה הבסיסית )class.)

לעיתים נרצה שמחלקות נגזרות כן יוכלו לגשת לרכיבים •הפנימיים של המחלקות הבסיסיות, הסיבה יכולה להיות הרצון

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

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

גישה ישירה במקום קריאה למתודות מתבצעת מהר יותר.•


Protected הרשאת גישה •C # כמו שאר השפות מונחות האובייקטים מגדירה הרשאת

( נוספת על אלו שדנו בהן עד כה, Access modifierגישה )protected.

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

( כאילו היו protected membersחופשית לחברים המוגנים )public.

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


Protected הרשאת גישה חבר מחלקה מוגן

המחלקה הנגזרת יכולה כאילו הוא Numלגשת ל-

.Publicמוגדר כ-

הגישה הישירה חסומה בידי המחלקה

המכילה.


Protected הרשאת גישה דוגמה:

class Base{ protected int m_Num1; public Base)( { . . . } public Base)int n1( { . . . } public void PrintBase)( public int Num1 { set { . . . } get { . . . } }}


משתנה מחלקתי מוגן


Protected הרשאת גישה דוגמה:

class Derived : Base{ private string m_Str; public Derived)( { . . . } public Derived)int n1, string str( { m_Num1 = n1; this.m_Str = str; } public string Str{ . . . } public void PrintDerived)( { . . . } public void SetDataMembers)int n1, string str( { m_Num1 = n1; m_Str = str; }}

גישה ישירה למשתנה המחלקתי המוגן של

מחלקת הבסיס.


גישה ישירה למשתנה המחלקתי המוגן של

מחלקת הבסיס.


Protected Access Modifierהגישה • בהרשאת בזהירות protectedהשימוש להיעשות צריך

יתרה.

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

קשות לאיתור ולתיקון.

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

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

Protectedכאשר מדובר במתודות אין שום מניעה להגדירן כ- • .Privateבמקום כ-


Sealed Classes.sealedניתן למנוע ממחלקה לשמש כמחלקת בסיס על ידי הגדרתה כ- ••.NET מגדירה מספר מחלקות כאלו, למשל המחלקה string.על מנת לייצר מחלקה "חתומה" נגדיר את המחלקה באמצעות המילה •

.sealedהשמורה

sealed class MyClass

{

. . .

} משפרת את מהירות ביצוע המתודות Sealedהגדרת מחלקה כ- •

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


Methods Hiding(:Warningהתוכנית הבאה תגרור שגיאת קומפילציה )

public class Base

{

public void Print)( { … }

}

public class Derived : Base

{


}

למה?


Methods Hidingכאשר נכתוב מתודה במחלקה הנגזרת אשר תהיה זהה

בחתימתה למתודה אשר מוגדרת במחלקת הבסיס המהדר ידרוש שנחביא את השיטה של מחלקת הבסיס.

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


Methods Hidingעל מנת להסתיר את המתודה של מחלקת הבסיס נגדיר את

.newהמתודה במחלקה הנגזרת באמצעות המילה השמורה

לדוגמה:

public class Base

{


}


{

public new void Print)( { … }

}


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

המתודה של המחלקה הנגזרת.

לדוגמה:public class App

{

static public void Main)(

{

Derived d = new Derived)(;

d.Print)(;

}

}


Methods Hidingניתן להפעיל את המתודה של מחלקת הבסיס מתוך המתודה של

.baseהמחלקה הנגזרת על ידי המילה השמורה

לדוגמה:public class Base

{


}


{

public new void Print)(

{

base.Print)(;

}

}


(Polymorphismרב צורתיות )

הבסיס לרב צורתיות :

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

class Base

{

public void Func)( {…}

}

class Derived:Base

{

public new void Func)( {…}

}

class Program{ static void Main)( { Base b = new Derived)(; b.Func)(; }}

הבסיס לרב צורתיות


מדוע רב צורתיות?מדוע להגדיר ייחוס מטיפוס בסיס שמקבל כתובת של •

אובייקט ממחלקה נגזרת?

Base b = new Derived;)(מדוע לא להגדיר ייחוס מטיפוס המחלקה הנגזרת •

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

Derived d = new Derived;)(ישנן לא מעט סיבות לכך.•


יתרונות רב צורתיות - אבסטרקציהבראש ובראשונה אבסטרקציה של המערכת, לא תמיד נרצה

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

;Shape s1לדוגמה:s1 = new Circle)(;s1.CalcArea)(;s1 = new Rectangle)(;s1.CalcArea)(;

או אובייקט מהמחלקה Circle יכול להתייחס לאובייקט מהמחלקה s1הייחוס •Rectangle.

בעתיד נול להוסיף להיררכיה מחלקות חדשות המייצגות צורות נוספות .•

הייחוס יוכל להתייחס גם אליהם.•


יתרונות רב צורתיות – מערכים הטרוגנייםבמערכת גראפית נרצה לצייר מספר עיגולים ומספר מלבנים.

ניתן להגדיר:

Circle[] circle_arr = new Circle[100];

Rectangle[] rect_arr = new Rectangle[100];

צורות שונות:100ובמידה יהיו במערכת

Circle, Rectangle, Line, Triangle, pentagon, hexagon ,'וכו מערכים שונים.100נאלץ להגדיר

מאוד מסבך את התוכנית.


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

יכיל ייחוסים מטיפוס הבסיס.כל אחד מהאיברים שלו יוכל להכיל כתובת של אובייקט אחר •

מהיררכיית המחלקות.

Shape[] arr = new Shape[100];arr[0] = new Rectangle)...(;arr[1] = new Circle)...(;arr[2] = new Triangle)...(; ...arr[0].CalcArea)(;

הגדרת מערך הטרוגני


בעיה !ממחלקה אובייקט של כתובת לקבל יכול הבסיס מטיפוס ייחוס

Data Membersנגזרת, אולם אותו ייחוס יכיר רק את החברים )and Methods.אשר מוגדרים במחלקת הבסיס )

class Base

{

public void Func)( {…}

}

class Derived:Base

{

public new void Func)( {…}

}

class Program{ static void Main)( { Base b = new Derived)(; b.Func)(; }}

יופעל המימוש של מחלקת הבסיס


מתודות וירטואליות. : הפיתרון( הנה מתודה אשר מוגדרת Virtual Methodמתודה וירטואלית )•

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

נהוג לומר, שהמחלקה הנגזרת יכולה לדרוס/לרמוס •(Override.את המימוש הקיים במחלקת הבסיס )

הגדרת מתודה וירטואלית מתבצעת באמצעות המילה •, הגדרת מימוש הנוסף במחלקות הנגזרות virtualהשמורה

.overrideמחייבת שימוש במילה השמורה


מתודות וירטואליותדוגמה:

class Base

{

public virtual void Func)( {…}

}

class Derived:Base

{

public override void Func)( {…}

}

הגדרת מתודה וירטואלית

דריסת המתודה הוירטואלית


מתודות וירטואליותכאשר נפעיל מתודה וירטואלית יופעל המימוש המתאים לטיפוס

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

בכתובת ההקצאה.class Base

{

public virtual void Func)( {…}

}

class Derived:Base

{

public override void Func)( {…}

}

class Program{ static void Main)( { Base b = new Derived)(; b.Func)(; }} יופעל המימוש של



מתודות וירטואליותכללים במימוש מתודות וירטואליות:

החתימה של המתודה הוירטואלית המוגדרת במחלקת הבסיס חייבת •להיות זהה בכל )שם המתודה, פרמטרים, ערך מוחזר, הרשאת גישה(

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

מימושים נוספים בשאר המחלקות הנגזרות. מתייחס להתנהגות של virtual כוירטואליות. staticלא ניתן להגדיר מתודות •

אובייקטים . כוירטואליות, משום שלא ניתן יהיה privateלא ניתן להגדיר מתודות •

לממשם במחלקה הנגזרת. למרות שהיא virtual כ- overrideלא ניתן להגדיר בצורה מפורשת •

וירטואלית.


מתודות וירטואליותתפקיד המתודות הוירטואליות הוא להביא לידי ביטוי את

ההתמחות האלגוריתמית של כל אחת מהמחלקות הנגזרות.

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

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

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

את ההתנהגות הייחודית שלה לידי ביטוי.

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


מתודות וירטואליותclass Shapeדוגמה:

{ public virtual decimal CalcArea)( { … }}class Circle:Shape{ public override decimal CalcArea)( { … }}class Rectangle:Shape{ public override decimal CalcArea)( { … }}class Triangle:Shape{ public override decimal CalcArea)( { … }}

לכל הצורות יש התנהגות של חישוב שטח, מימוש ההתנהגות הוא באמצעות

.)(Shape.CalcAreaהמתודה

מכיוון שלכל צורה יש נוסחה מתמטית שונה, המתודה מוגדרת כוירטואלית.


מתודות וירטואליותדוגמה:

לא משנה עם איזו צורה נעבוד,

תמיד תופעל המתודה המתאימה.

Shape s1;s1 = new Circle)(;s1.CalcArea)(;s1 = new Rectangle)(;s1.CalcArea)(;s1 = new Triangle)(;s1.CalcArea)(;


המרות בין בסיס לנגזרת•C#( מאפשרת לבצע המרות Conversions מייחוס ממחלקת הבסיס )

לייחוס מהמחלקה הנגזרת ולהפך - מייחוס מהמחלקה הנגזרת לייחוס ממחלקת הבסיס.

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

Base b = new Derived;)(המרה הפוכה, מהמחלקה הבסיסית לייחוס של המחלקה הנגזרת, •

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

(.Explicitהמרה זו חייבים לבצע בצורה מפורשת )•

Derived d = )Derived(b;


המרות בין בסיס לנגזרתמטרת ההמרה מייחוס ממחלקת הבסיס לייחוס מהמחלקה

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

דוגמה:


המרות בין בסיס לנגזרתניתן לבצע זאת כך:

אולם מה יקרה עם נטעה?

Shape s = new Circle). . .(;

))Circle(s(.Move). . .(;

Shape s = new Circle). . .(;

))Rectangle(s(.Move). . .(;

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

. as, והאופרטור isהאופרטור


המרות בין בסיס לנגזרת :ISהמרה בצורה בטוחה באמצעות האופרטור

Shape b = new Rectangle)(;if )b is Rectangle({

r = )Rectangle( b;r.PrintRectangle)(;

}else{

c = )Circle( b;c.PrintCircle)(;

}


המרות בין בסיס לנגזרת :ASהמרה בצורה בטוחה באמצעות האופרטור

Shape b = new Circle)(;Rectangle r = b as Rectangle;if)r != null( r.PrintRectangle)(;Circle c = b as Circle;if)c != null( c.PrintCircle)(;


(Abstract Classesמחלקות מופשטות )מחלקה מופשטת )או מחלקה אבסטרקטית( הנה מחלקה אשר •

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

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

השמורה • המילה בעזרת מגדירים מופשטת מחלקה (Keyword )abstract.

abstract class BaseClassלדוגמה:{. . .}


(Abstract Classesמחלקות מופשטות )abstract class Baseדוגמה:

{public virtual void Print)({

Console.WriteLine)"Base class"(;}

}class Derived:Base{

public override void Print)({

Console.WriteLine)"Derived class"(;}

}

הגדרת מחלקה אבסטרקטית


(Abstract Classesמחלקות מופשטות )דוגמה:

class App{

static void Main)string[] args({

Base b = new base)(;

Base b1 = new Derived)(;b1.Print)(;

Derived d = new Derived)(;d.Print)(;

}}

שגיאת קומפילציה

תקין

תקין


(Abstract Methodsמתודות מופשטות )במחלקה מופשטת ניתן להגדיר כל מה שניתן להגדיר במחלקה רגילה:

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

בנוסף ניתן להגדיר גם מתודות מופשטות.

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

( ומתבצעת אוטומטית Implicitהגדרתם כוירטואליים היא הגדרה מרומזת )על ידי הסביבה.

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


(Abstract Methodsמתודות מופשטות )תחביר:

abstract class MyClass{

public abstract void AbstractMathod)(;public abstract int AbstractProperty{

get;set;

}}


(Abstract Methodsמתודות מופשטות )ההבדלים בין מתודה וירטואלית למתודה מופשטת

מתודה מופשטת מתודה וירטואלית

אסור לממש חייבים לממש מחלקת בסיס

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


(Abstract Methodsמתודות מופשטות )דוגמה:

abstract class BaseShape{ private int m_X; private int m_Y; private ConsoleColor m_Color; public virtual void PrintShape)( { . . . } . . . public abstract int CalcArea)(; public abstract int CalcPerimeter)(;}

הגדרת מחלקה מופשטת

הגדרת מתודות מופשטות אפשרית רק במחלקות

מופשטות



class Circle:BaseShape{ private int m_Radius; public override void PrintShape)( { . . .} public override int CalcArea)( {

return )int()Math.PI * Math.Pow) m_Radius,2((; } public override int CalcPerimeter)( {

return )int()2 * Math.PI * m_Radius(; }}

המחלקה הנגזרת חייבת לספק מימוש למתודות

המופשטות


(Abstract Methodsמתודות מופשטות )class Rectangle:BaseShapeדוגמה:

{ private int m_Height; private int m_Width; public override void PrintShape)( { . . . } public override int CalcArea)( { return m_Height * m_Width; } public override int CalcPerimeter)( { return 2*)m_Height + m_Width(; }}

המחלקה הנגזרת חייבת לספק מימוש למתודות

המופשטות



static void Main)string[] args({ BaseShape s = new Circle)100, 150,

ConsoleColor.DarkMagenta,40(; s.PrintShape)(; Console.WriteLine)"Area = {0}", s.CalcArea)((; Console.WriteLine)"Perimeter = {0}", s.CalcPerimeter)((; s = new Rectangle)150, 250, ConsoleColor.Blue, 60, 30(; s.PrintShape)(; Console.WriteLine)"Area = {0}", s.CalcArea)((; Console.WriteLine)"Perimeter = {0}", s.CalcPerimeter)((; }


(Interfaceממשקים )

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

( הנו מבנה לוגי המצהיר על מתודות מופשטות Interfaceממשק )•(Abstract Methods) ,( מאפיינים מופשטים או אירועיםEvents.)

.Data Membersממשק אינו יכול להכיל מתודות עם מימושים או •( בזה שלא Abstract classממשק דומה למחלקה אבסטרקטית )•

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

חברים מופשטים..publicבממשקים לא ניתן להגדיר הרשאות גישה הם תמיד •המימושים במחלקות הנגזרות לא חייבים להיות וירטואליים. •


תחביר:interface ISample{

void Method1)(;float Method2)(;object Method3)(;

. . .string MethodN)(;int Property1{

set;get;

}event DelegateName EventName;

}

הגדרת ממשק

הגדרת מתודות

הגדרת מאפיינים

הגדרת אירוע


interface IPrintדוגמה:{ void Print)(;}

class MyClass:IPrint { private byte m_Num;

. . . public void Print)( { Console.WriteLine)"Num = {0}", m_Num(; } }

הגדרת ממשק

מחלקה המממשת ממשק חייבת לספק מימוש לכל המתודות

המוגדרות בו


class MyClass:IPrint{

public virtual void Print)( { Console.WriteLine)"Num = {0}", m_Num(; }}

class MyClass:IPrint{

public void Print)( { Console.WriteLine)"Num = {0}", m_Num(; }}

המימוש יכול להיות וירטואלי

המימוש יכול להיות רגיל


מחלקה יכולה לממש מספר ממשקים:

interface IPrint{ void Print)(;}

interface IMath{ int Sum)(; float Avg)(;}

class MyClass:IPrint,IMath{ . . . public MyClass)( { . . . } public MyClass)byte n1,byte n2,byte n3( { . . . } public void Print)( { . . .} public int Sum)( { . . .} public float Avg)( { . . .}}

מימוש מספר ממשקים

IPrintהמימוש של

IMathהמימוש של


NET Framework.ממשקים המוגדרים ב- מגדירה אוסף גדול של ממשקים, חלק גדול NET Frameworkסביבת .

מממש את אותן הממשקים, או מצפה NET Frameworkמהמחלקות של .מאיתנו לממש ממשקים אלו על מנת שנוכל ליהנות משירותים שונים

שאותן מחלקות מציעות.

IComparable

IWin32Window

IFormattable

ISerializable

IConvertible

IComparrer

IDataAdapter

IDisposableIWebProxy


IComparableהממשק מגדיר מתודה אחת: IComparable הממשק

int CompareTo)Object(;. )Array.Sort)Array obj הנקראת Static מגדירה מתודהArrayמחלקה

( כל מערך של טיפוסים אשר ירשו qsort מתודה זו יודעת למיין )מממשת את אלגוריתם.)IComparable.CompareTo)object ויממשו את המתודה

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

?מתי ננצל ממשק זה

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

.NET Framework מגדירה מחלקה בשם System.Array , כל המערכים בסביבת פיתוח זו. System.Array יורשים את המחלקה


IComparableהממשק דוגמה:

public class Circle : IComparable{ private int m_X; private int m_Y; private int m_Radius; . . . public int CompareTo)object obj( { Circle c = null; if )obj is Circle( c = )Circle(obj; else return 1; return this.m_Radius - c.m_Radius; }}

מימוש הממשק IComparable

מימוש IComparable.CompareTo המבצעת השוואה בין שני

אובייקטים


IComparableהממשק )static void Main)string[] args דוגמה:

{ Circle[] arr = new Circle[5]; arr[0] = new Circle)10, 10, 100(; arr[1] = new Circle)10, 10, 50(; arr[2] = new Circle)10, 10, 20(; arr[3] = new Circle)10, 10, 70(; arr[4] = new Circle)10, 10, 40(; Array.Sort)arr(;

foreach )Circle c in arr( c.Print)(;

}

Array.Sortהמתודה משתמשת ב-

IComparable.CompareTo על מנת לבצע את פעולות

ההשוואה הנדרשות.

תכנות מונחה עצמים - מעשי


.עריכה מקצועית : ארז קלר

www.corner.co.il

Documents

תכנות מונחה עצמים - מעשי