Implementing Inheritance

1. Implementing Inheritance

2. Agenda • Simple Inheritance. • Protected Access Modifier. • Cross Language Inheritance. • Sealed Classes. • Methods Hiding.

3. Agenda • Simple Inheritance. • Protected Access Modifier. • Cross Language Inheritance. • Sealed Classes. • Methods Hiding.

4. Simple Inheritance • מנגנון ההורשה מגדיר יכולת של אובייקט לקבל בירושה את כל התכונות של אובייקט ממחלקה קיימת. מנגנון זה נתמך על ידי כל שפה המוגדרת כשפת OOP (C++ ,Java  Smalltalk , C#,VB.NET וכו'). • המחלקה היורשת מכונה מחלקה נגזרת - class Derived, המחלקה המורישה מכונה מחלקה בסיסית class – Base. • ההורשה מממשת יחסי "Is A " בין מחלקות.

5. Simple Inheritance Syntax : class Base { } class Derived:Base { } יחסי הורשה בין מחלקות מסמנים על ידי האופרטור : (נקודתיים)

6. Simple Inheritance המחלקה הנגזרת (Derived Class) מכירה את כל החלקים הציבוריים (Public) של מחלקת הבסיס שלה (Base class), אולם  המרכיבים הפרטיים (Private) של מחלקת הבסיס חסומים גם בפניה. class Base { privateint base_num; } class Derived:Base { privateint derived_num; public Derived(int b_num,int d_num) { base_num = b_num; this.derived_num = d_num; } } 

7. Simple Inheritance Init List • בהקצאת אובייקט מהמחלקה Derived נוצרים שני אוביייקטים, ה- Base וה- Derived . • ה- Base נוצר ראשון ולאחריו נוצר ה- Derived . • בהקצאת האובייקט הנגזר מופעלים שני Ctors , אחד של מחלקת הבסיס, והשני של מחלקת Derived . מכיוון שסדר הבנייה הוא מהבסיס לנגזרת ה- Ctor של המחלקה Base יופעל ראשון, ולאחריו יופעל ה- Ctor של מחלקת ה- Derived. • על מנת לייעל את תהליך בניית האובייקט המוקצה ב- Main , נדאג לשלוח פרמטרים ל- Ctor של מחלקת הבסיס באמצעות  Init List , על מנת לבצע זאת נשתמש במילה השמורה base . • במקרה זה הקצאת האובייקט ב- Main תפעיל את ה- Ctor של המחלקה Derived , ה- Ctor של מחלקה זו יפעיל את ה- Ctor של מחלקת הבסיס אשר מקבל פרמטר בודד, ורק לאחר שהאחרון יחזור יבוצע ה- Ctor של המחלקה הנגזרת.

8. Simple Inheritance class Base { privateint base_num; public Base(int num) {this.base_num = num;} } class Derived:Base { int derived_num; public Derived(){} public Derived(int b_num,int d_num):base(b_num) { this.derived_num = d_num; } } לדוגמה:

9. Simple Inheritance הורשה רב דורית – Chain Inheritance • מחלקה נגזרת בעצמה יכולה לשמש, בתורה,  כבסיס לגזירה על ידי מחלקה אחרת וכו' class Base { publicvoid PrintBase(){ … } } class Derived1:Base { publicvoid PrintDerived1() { … } } class Derived2:Derived1 { publicvoid PrintDerived2() { … } }

10. Simple Inheritance הורשה רב דורית – Chain Inheritance • בהקצאת האובייקט מהמחלקה Derived2 נוצר ראשון אובייקט מהמחלקה Base לאחר מכן נוצר אובייקט מהמחלקה Derived1 ולבסוף נוצר אובייקט מהמחלקה Derived2 . • המחלקה Derived2 מודעת לכך שהיא יורשת את המחלקה Derived1 , אולם אין היא מכירה את מבנהו הפנימי של Derived1, ואין היא מודעת לקיומה של המחלקה Base . • מבחינתה של Derived2 מחלקת הבסיס שלה היא "קופסא שחורה"     

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

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

13. Simple Inheritance עץ הורשה –Tree Inheritance לדוגמה: enum Color:byte{Red,Green,Blue,White,Black,Cyan,Yellow,Orange} class BaseShape { . . . public BaseShape() { } public BaseShape(int x,int y,Color c) {. . .} publicvoid MoveTo(int x,int y) { . . . } publicvoid PrintShape() { . . . } }

14. Simple Inheritance Generalization vs. Specialization • ככל שמחלקה היא בסיסית יותר, כך היא כללית יותר (Generalization), דהיינו, מייצגת רעיון כללי ולא ממוקד. • ככל שנתקדם במורד "עץ ההורשה" נתקל במחלקות המייצגות רעיונות או עצמים מפורטים וממוקדים יותר, דהיינו, התמחות (Specialization). • ניתן להבין מכך, שככל שמחלקה היא בסיסית יותר היא מתאימה לייצוג מספר רב יותר של מקרים, משום שלמעשה היא מייצגת את המכנה המשותף שלהם.     

15. Simple Inheritance Generalization vs. Specialization לדוגמה: class Person { } class Employee:Person { } class Worker:Employee { } class SalesMan: Worker { }

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

17. Simple Inheritance עץ הורשה –Tree Inheritance לדוגמה: enum Color:byte{Red,Green,Blue,White,Black,Cyan,Yellow,Orange} class BaseShape { privateint m_X; private int m_Y; private Color color; public BaseShape() { } public BaseShape(int x,int y,Color c) {. . .} public void MoveTo(int x,int y) { . . . } public void PrintShape() { . . . } }

18. Simple Inheritance עץ הורשה –Tree Inheritance המשך דוגמה: class Circle:BaseShape { privateint m_Radius; public Circle(){…) public Circle(int x,int y,Color c,int r): base(x,y,c) {…} publicvoid Resize(int m_Radius){…} publicvoid PrintCircle() {…} publicint CalcArea() {…} publicint CalcPerimeter() publicvoid PrintRectangle(){…} }

19. Simple Inheritance עץ הורשה –Tree Inheritance המשך דוגמה: class Rectangle:BaseShape { privateint m_Height; privateint m_Width; public Rectangle(){} public Rectangle(int x,int y,Color c,int h,int w):base(x,y,c) publicvoid Resize(int h,int w){…} publicvoid PrintRectangle() {…} publicint CalcArea() {…} publicint CalcPerimeter() {…} }

20. Agenda • Simple Inheritance. • Protected Access Modifier. • Cross Language Inheritance. • Sealed Classes. • Methods Hiding.

21. Protected Access Modifier • מתודות של מחלקות נגזרות (Derived Class) אינן יכולות לגשת לחברים הפרטיים של המחלקה הבסיסית (Base class). • לעיתים יתכן ונרצה שמחלקות נגזרות כן יוכלו לגשת לרכיבים הפנימיים של המחלקות הבסיסיות, הסיבה יכולה להיות הרצון לשפר ביצועים. • במקום שמתודות במחלקה הנגזרת יקראו למתודות של המחלקה הבסיסית, נרצה שתהיה להן גישה ישירה וחופשית למשתנים החברים של מחלקת הבסיס, או רק לחלק מהן. • גישה ישירה במקום קריאה למתודות מתבצעת מהר יותר. • C# כמו שאר השפות מונחות האובייקטים מגדירה הרשאת גישה (Access modifier) נוספת על אלו שדנו בהן עד כה, protected . • חברי מחלקה המוגדרים כ- protected הנם חברים מוגנים. • הרשאת הגישה protected מאפשרת למחלקות הנגזרות גישה חופשית לחברים המוגנים (protected members) כאילו היו public . • הגישה של שאר מרכיבי האפליקציה אל החברים המוגנים חסומה, כאילו אותם חברים מוגנים הם פרטיים.

22. Protected Access Modifier לדוגמה: class Base { privateint m_Num1; protectedint m_Num2; publicint m_Num3; public Base() {} public Base(int n1,int n2,int n3) {...} protectedvoid PrintBase(){...} publicint Num1 { set {…} get {…} } }

23. Protected Access Modifier המשך: class Derived:Base { public Derived() {…} public Derived(int n1,int n2,int n3):base(n1,n2,n3){...} publicvoid PrintDerived() { base.PrintBase(); } publicvoid SetDataMembers(int n1,int n2,int n3) { Num1 = n1; m_Num2 = n2; m_Num3 = n3; } }

24. Protected Access Modifier השימוש בהרשאת הגישה protected צריך להיעשות בזהירות יתרה. הוא מאפשר עקיפה של בדיקת תקינות ואיכות המידע, המידע מוסתר אבל באופן חלקי ביותר, מה שעלול לגרום לשגיאות לוגיות קשות לאיתור ולתיקון. להרשאת הגישה protected יש ערך מוסף אולם קיימת סכנה בצידה, לכן כאשר בוחרים להגדיר משתנה מחלקתי תחת הרשאת הגישה protected יש לעשות זאת בזהירות רבה , אחרת שכרנו עלול לצאת בהפסדנו. כאשר מדובר במתודות אין שום מניעה להגדירן כ- Protected במקום כ- Private .

25. Agenda • Simple Inheritance. • Protected Access Modifier. • Cross Language Inheritance. • Sealed Classes. • Methods Hiding.

26. Cross Language Inheritance • נכון להיום ישנן למעלה מ- 30 שפות שונות התומכות ב- .NET (C# , VB.NET, Jscript.NET, J#, Managed C++, Cobol.NET ועוד). • כל השפות חייבות לעמוד בתקן אחיד וכולם מורצות על ידי ה- CLR. • תשתית ה- .NET מאפשרת לכתוב מחלקת Base בשפת .NET כלשהיא ולרשת אותה במחלקת Derived שנכתבה בשפת .NET אחרת. • יכולת זו מכונה Cross Language Inheritance .

27. Cross Language Inheritance לדוגמה: מחלקה בסיסית שנכתבה ב- VB.NET . PublicClass BaseProduct Private producer AsString Private price AsSingle Private name AsString PublicSubNew() EndSub PublicSubNew(ByVal producer AsString, ByVal price AsSingle, ByVal name AsString) Me.producer = producer Me.price = price Me.name = name EndSub . . .

28. Cross Language Inheritance לדוגמה: המשךמחלקה הבסיס. . . . PublicSub PrintBaseProduct() Console.WriteLine("Producer : {0}", producer) Console.WriteLine("Price : {0:C}", price) Console.WriteLine("Name : {0}", name) EndSub EndClass

29. Cross Language Inheritance לדוגמה: המחלקה הנגזרת נכתבה ב- C#. publicclass ElectronicProduct:BaseProduct { privateint watt; privateint voltage; public ElectronicProduct() {} public ElectronicProduct(string producer,float price, string name, int watt,int volt):base(producer,price,name) { this.watt = watt; this.voltage = volt; } publicvoid PrintElec() { base.PrintBaseProduct();Console.WriteLine("Watt : {0}",watt); Console.WriteLine("Volt : {0}",voltage); } }

30. Cross Language Inheritance • למעשה אין מדובר בהורשה בין מודולים הכתובים בשפות שונות , למרות שכך הדבר נראה כאשר בוחנים את הצד הטקסטואלי של התוכנית. • כאשר מקמפלים מודול, ולא משנה באיזו שפה הוא נכתב הקומפיילר של אותו שפה מייצר קובץ (exe או dll) הכתוב בשפת MSIL . • האמת היא שלאחר הקומפילציה מחלקה הכתובה בשפתMSIL יורשת מחלקה אחרת הכתובה, גם היא, בשפת MSIL . • קוד ה- MSIL אינו מתייחס לשפה בה נכתב ה- Assembly , בנוסף ה- CLR כמעט ומרוקן את שפות ה- .NET מתוכן. הסתמכות על ה- CLR יוצרת שפות דומות מאוד שהשוני היחידי ביניהן הוא ה- Syntax של השפה. • לא יתכן מצב ששפה אחת תגדיר רכיב שלא יוכר בשפות אחרות. • הערה: VB.NET כמו קודמותיה היא לא Case Sensitive , לכן מומלץ מאוד שלא להסתמך על אותיות גדולות או קטנות במתן שמות.

31. Agenda • Simple Inheritance. • Protected Access Modifier. • Cross Language Inheritance. • Sealed Classes. • Methods Hiding.

32. Sealed Classes • ניתן למנוע ממחלקה לשמש כמחלקת בסיס על ידי הגדרתה כ- sealed. • .NET מגדירה מספר מחלקות כאלו, למשל המחלקה string. • על מנת לייצר מחלקה "חתומה" נגדיר את המחלקה באמצעות המילה השמורה sealed. sealed class MyClass { . . . } • הגדרת מחלקה כ- Sealed משפרת את מהירות ביצוע המתודות המוגדרות בה , משום שנחסך הצורך ב- Late Binding . • כל ניסיון לרשת מחלקה חתומה יגרור שגיאת קומפילציה.

33. Agenda • Simple Inheritance. • Protected Access Modifier. • Cross Language Inheritance. • Sealed Classes. • Methods Hiding.

34. Methods Hiding • התוכנית הבאה תגרור שגיאת קומפילציה: publicclass Base { publicvoid Print() { … } } publicclass Derived : Base { publicvoid Print() { … } } למה?

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

36. Methods Hiding על מנת להסתיר את המתודה של מחלקת הבסיס נגדיר את המתודה במחלקה הנגזרת באמצעות המילה השמורה new. לדוגמה: publicclass Base { publicvoid Print() { … } } publicclass Derived : Base { publicnewvoid Print() { … } }

37. Methods Hiding כאשר נקצה אובייקט מהמחלקה הנגזרת נוכל להפעיל רק את המתודה של המחלקה הנגזרת. לדוגמה: publicclass App { staticpublicvoid Main() { Derived d = new Derived(); d.Print(); } }

38. Methods Hiding ניתן להפעיל את המתודה של מחלקת הבסיס מתוך המתודה של המחלקה הנגזרת על ידי המילה השמורה base . לדוגמה: publicclass Base { publicvoid Print() { … } } publicclass Derived : Base { publicnewvoid Print() { base.Print(); } }

39. Methods Hiding על מנת להפעיל ישירות את המתודה המוגדרת במחלקת הבסיס מתוך Main נאלץ לבצע Casting. לדוגמה: publicclass App { staticpublicvoid Main() { Derived d = new Derived(); ((Base)d).Print(); } } שימוש בטכניקה זו יכול לרמז על שגיאה תכנונית.

40. Agenda • Simple Inheritance. • Protected Access Modifier. • Cross Language Inheritance. • Sealed Classes. • Methods Hiding.

41. www.corner.co.il Books Corner – הוצאת ספרים מקוונת