תרגול 10 המשך תכנות מונחה עצמים
היום בתרגול הורשה פולימורפיזם כללי הרשאות בהורשה (visibility modifiers)
הורשה
הורשה המחלקה מתארת את מרחב המצבים ואת ההתנהגויות האפשריות לאובייקט. הורשה: הגדרת מחלקה על בסיס מחלקת אב. דוגמה: מחלקה המגדירה אופניים תגדיר אובייקטים בעלי שני גלגלים, כידון ופדלים. תתי מחלקות (subclasses), יורשות, מרחיבות: אופני הרים, אופני מרוץ ואופניים עם גלגלי עזר הן סוג של אופניים (עם מאפיינים ויכולות שונות). (מתי כדאי לחשוב על הורשה? כאשר יש יחס של is a) מחלקת האופניים היא מחלקת אב (superclass) של מחלקות אופני הרים ואופני מרוץ.
הורשה כל תת מחלקה יורשת ממחלקת אב, שלה התנהגות ומאפייני מצב. לכל מחלקות האופניים קיימים: מאפייני מצב (שדות) משותפים כמו: מהירות מקסימלית, צבע התנהגויות (שיטות) משותפות כמו: עצירה, נסיעה, החלפת הילוכים. התנהגות תתי המחלקות אינה מוגבלת להתנהגות מחלקת האב. תתי מחלקות יכולות להוסיף שדות ושיטות משלהן, למשל: אופני הרים יכולות לנסוע בשטח לאופניים עם גלגלי עזר יש גלגלי עזר, וכו'.
הורשה ככל שנוסיף התנהגויות ומשתני מצב נהפוך את המחלקה לספציפית יותר (כללית פחות). ככל שיורדים בעץ ההורשות, כך המחלקה יותר ספציפית. אופני מרוץ מגדירים קבוצה מדויקת יותר מאשר אופניים כלליים. תתי מחלקות יכולות לדרוס את השיטות אותן הן יורשות. שיטת החלפת הילוכים אשר קיימת במחלקה אופניים, תהיה שונה עבור מחלקת אופני מרוץ אשר יש להם הילוכים מיוחדים, וכו' הורשה אינה מוגבלת לרמה אחת. ניתן להגדיר תת מחלקות עבור תת המחלקות וכן הלאה. אופני הרים מושלגים
הורשה - כללים רשימת כללים להורשה 1. מחלקה יכולה להרחיב (לַרשת) רק מחלקה אחת. (ניתן להשתמש בממשקים אם יש צורך בהתנהגויות מרובות) אופניים עם גלגלי עזר אופניים משחקי ילדים
הורשה - כללים 2. מחלקה B תרחיב את A אם נכון לומר "B הוא סוג של A". ב-Java נכתוב: class B extends A אופניים A אופני מרוץ B
הורשה - כללים A B אופני מרוץ אופניים אופניים אופני מרוץ 3. אובייקט מרחיב (מטיפוס B) מכיל בתוכו את האובייקט המורחב (מטיפוס A). 4. A היא ה-parent class או ה-super class של B B היא ה-child class או ה-subclass של A אופני מרוץ - public void race() אופניים A אופניים - color = Red speed = 50 km/h - public void ride() אופני מרוץ B
אוניברסיטת בן גוריון - מבוא למדעי המחשב הורשה - כללים 5. B יורשת את כל השיטות והמשתנים שאינם private ב-A מלבד הבנאים. לא ניתן לגשת בתוך B לשיטות או שדות פרטיים ב-A, על אף שהם קיימים (עבור שיטות נראה דוגמה בהמשך הקורס, כשנדבר על protected) public class Bicycle { private int wheelsNum; } public class TrainingBicycle extends Bicycle { private int trainingWheelsNum; public TrainingBicycle() { wheelsNum=2; trainingWheelsNum = 1; // compilation error
הורשה - כללים 6. בנאים אינם עוברים בהורשה! לכן יש להגדיר בנאים חדשים. אוניברסיטת בן גוריון - מבוא למדעי המחשב הורשה - כללים 6. בנאים אינם עוברים בהורשה! לכן יש להגדיר בנאים חדשים. 7. כשיוצרים אובייקט חדש מסוג B, הבנאי של מחלקה A חייב להיקרא. ניתן לקרוא לו באופן מפורש, אחרת נקרא באופן אוטומטי הבנאי ללא הפרמטרים של A. קריאה מפורשת נעשית ע"י super(…). super הינה מילה שמורה בשפת Java,אשר מייצגת את מחלקת האב. public class Bicycle { private int wheelsNum; public Bicycle(int i) { wheelsNum = i; } public class TrainingBicycle extends Bicycle { private int trainingWheelsNum; public TrainingBicycle() { super(2); trainingWheelsNum = 1; } //calls the constructor of Bicycle
הורשה - כללים מה קורה במקרה זה? זו שגיאת קומפילציה! אוניברסיטת בן גוריון - מבוא למדעי המחשב הורשה - כללים מה קורה במקרה זה? public class Bicycle { private int wheelsNum; public Bicycle(int i) { wheelsNum = i; } public class TrainingBicycle extends Bicycle { private int trainingWheelsNum; public TrainingBicycle() { trainingWheelsNum = 1; } זו שגיאת קומפילציה! no empty constructor for Bicycle: Cannot find symbol: constructor Bicycle()
הורשה - כללים 8. הקריאה ל-super חייבת להיות השורה הראשונה בבנאי של B. אוניברסיטת בן גוריון - מבוא למדעי המחשב 8. הקריאה ל-super חייבת להיות השורה הראשונה בבנאי של B. מה קורה במקרה זה? public class Bicycle { private int wheelsNum; public Bicycle(int i) { wheelsNum = i; } public class TrainingBicycle extends Bicycle { private int trainingWheelsNum; public TrainingBicycle() { trainingWheelsNum = 1; super(2); } הקומפיילר יראה זאת כ- 2 שגיאות קומפילציה! Cannot find symbol: constructor Bicycle() Call to super must be first statement in constructor
הורשה - כללים 11. ניתן ליצור הירארכיה בעזרת הורשה, כך שמחלקת בן של מחלקה אחת יכולה להיות מחלקת אב של מחלקה אחרת.
הורשה - כללים 12. כל מחלקה מרחיבה בצורה ישירה או עקיפה את המחלקה Object, והיא השורש בהירארכית הירושה. Object
הורשה - כללים דריסה – Overriding דריסה תתרחש כאשר מחלקת הבן מגדירה שיטה בעלת חתימה זהה לשיטה המוגדרת במחלקת האב כאשר מדובר בדריסה, הטיפוס של המופע (instance) – מה שנמצא בקצה החץ בטבלת המשתנים והזיכרון – מגדיר איזו פונקציה תופעל. במקרים אחרים מופעלת הפונקציה לפי הרפרנס (reference) – מה שרשום כטיפוס המשתנה בטבלת המשתנים דריסה תתרחש רק בשיטות שאינן private. super - אם רוצים לקרוא באופן מפורש לפונקציה של האב ניתן להשתמש במילה super.
TrainingBicycle Bicycle public class TrainingBicycle extends Bicycle{ אוניברסיטת בן גוריון - מבוא למדעי המחשב דוגמה 1: public class Bicycle { private int wheelsNum; public Bicycle(int i) { wheelsNum = i; } public int countWheels() { return wheelsNum; public class TrainingBicycle extends Bicycle{ private int trainingWheelsNum; public TrainingBicycle() { super(2); trainingWheelsNum = 1; public int countWheels() { // overrides countWheels() of Bicycle int regWheelsNum = super.countWheels(); //fetch regular # return trainingWheelsNum + regWheelsNum; //return their sum TrainingBicycle - trainingWheelsNum=1 - int countWheels() Bicycle - wheelsNum = 2 int countWheels()
The return type is incompatible with Bicycle.countWheels() אוניברסיטת בן גוריון - מבוא למדעי המחשב דוגמה 2: public class Bicycle { private int wheelsNum; public Bicycle(int i) { wheelsNum = i; } public int countWheels() { return wheelsNum; public class TrainingBicycle extends Bicycle{ private int trainingWheelsNum; public TrainingBicycle() { super(2); trainingWheelsNum = 1; public void countWheels() { int regWheelsNum = super.countWheels(); System.out.println(trainingWheelsNum + regWheelsNum); לא ניתן לדרוס שיטה עם חתימה זהה וטיפוס החזרה שונה: TrainingBicycle - trainingWheelsNum=1 - int countWheels() Bicycle - wheelsNum = 2 void countWheels() שגיאת קומפילציה The return type is incompatible with Bicycle.countWheels()
TrainingBicycle Bicycle לא ניתן לדרוס שיטה עם חתימה זהה וטיפוס אוניברסיטת בן גוריון - מבוא למדעי המחשב דוגמה 2: public class Bicycle { private Object wheelsNum; public Bicycle(Object i) { wheelsNum = i; } public Object countWheels() { return wheelsNum; public class TrainingBicycle extends Bicycle{ private int trainingWheelsNum; public TrainingBicycle() { super(2); trainingWheelsNum = 1; public String countWheels() { Object regWheelsNum = super.countWheels(); return regWheelsNum.toString(); לא ניתן לדרוס שיטה עם חתימה זהה וטיפוס החזרה שונה: TrainingBicycle - trainingWheelsNum=1 - Object countWheels() Bicycle - wheelsNum = 2 String countWheels() הערה: זה חוקי כאשר טיפוס ההחזרה הוא אובייקט ויורש מטיפוס ההחזרה של השיטה הנדרסת.
Overriding (דריסה) vs Overloading (העמסה) העמסה היא כאשר ישנן מספר הגדרות לפונקציה בעלת אותו שם אך עם פרמטרים שונים (במילים אחרות - חתימה שונה) באותה המחלקה. דריסה היא הגדרה של שתי שיטות בעלות חתימה זהה, אחת במחלקת האב ואחת במחלקת הבן. העמסה מאפשרת פעולה דומה עבור data שונה. דריסה מאפשרת לבצע פעולה דומה עבור טיפוס אובייקט שונה.
פולימורפיזם (רב צורתיות) התייחסות לעצמים שונים (instance) כדברים דומים (reference) בעלי מכנה משותף. אם נרצה למשל להחזיק מערך של ספרים, אשר יוכל להחזיק ספרים מסוגים שונים, נוכל להגדיר מערך של מצביעים (reference) מטיפוס Book. משתנה (מצביע) מטיפוס מסוים יכול להצביע על כל אובייקט שטיפוסו הוא צאצא של טיפוס זה. לכן, מערך של מצביעים מטיפוס Book יוכל להצביע על אובייקטים מטיפוסים שיורשים את Book. Book Dictionary Cookbook
public Book(String name, int p){ this.name = new String(name); Dictionary Cookbook public class Book { private String name; private int pages; public Book(String name, int p){ this.name = new String(name); this.pages = p; } public String getName(){ return this.name; public void message() { System.out.println(this.name +": " + this.pages + " pages");
/* A Dictionary is a kind of Book with definitions */ Cookbook /* A Dictionary is a kind of Book with definitions */ public class Dictionary extends Book { private int definitions; public Dictionary(String name, int pages, int defs) { super(name, pages); this.definitions = defs; } public void message() { System.out.println(getName() + ": " + definitions + " definitions"); public int getDefinitions(){ return this.definitions;
/* A Cook Book is a kind of Book with recipes */ Dictionary Cookbook /* A Cook Book is a kind of Book with recipes */ public class Cookbook extends Book { private int recipes; public Cookbook(String name, int pages, int recipes) { super(name, pages); this.recipes = recipes ; } public void message() { System.out.println(getName() + ": " + this.recipes + " recipes ");
שימוש בפולימורפיזם התייחסות לספרים שונים באופן אחיד לפי יכולות מחלקת האב: public static void main(String[] args) { Book [] books = new Book[3]; // new above is for the array, not Book objects books[0] = new Dictionary("Webster“, 690, 45056); books[1] = new Cookbook("Naked Chef“, 100, 50); books[2] = new Book("War and Peace“, 1000); for (int i=0; i<books.length; i=i+1) books[i].message(); } books Output Webster: 45056 definitions Naked Chef: 50 recipes War and Peace: 1000 pages
שימוש בפולימורפיזם התייחסות לספרים שונים באופן אחיד לפי יכולות מחלקת האב: public static void main(String[] args) { Book [] books = new Book[3]; // new above is for the array not Book objects books[0] = new Dictionary("Webster“, 690, 45056); books[1] = new Cookbook("Naked Chef“, 100, 50); books[2] = new Book("War and Peace“, 1000); books[0].getDefinitions(); // what would this line do ? } books // compilation error - no getDefinitions() for Book בעזרת Casting איך ניתן בכל זאת להפעיל שיטה ספציפית? ((Dictionary)books[0]).getDefinitions(); שימו לב: תכנון נכון של המחלקות יכלול דריסת פונקציות במקום Casting
פולימורפיזם הינו "חד-כיווני" משתנה מטיפוס Cookbook לא יכול להכיל אובייקט מטיפוס Book. (כי טיפוס מחלקת האב הוא כללי יותר) השורה: Cookbook deserts = new Book("War and Peace“, 1000) תיתן שגיאת קומפילציה Book Dictionary Cookbook
כללי הרשאות (visibility modifiers) בהורשה public – שדות ושיטות המוגדרים כ-public ניתנים לגישה מתוך ומחוץ למחלקה. protected – שדות ושיטות המוגדרים כ-protected ניתן לגישה מתוך המחלקה וממחלקות היורשות מהמחלקה אך אינם ניתן לגישה ממחלקות אחרות *. (* ממחלקות אחרות הנמצאות ב package אחר. protected מתנהג כמו public באותו package) private – שדות ושיטות המוגדרים כ-private אינם ניתנים לגישה מחוץ למחלקה. ניסיון לגשת לשדה או שיטה כזו מחוץ למחלקה יעורר שגיאת קומפילציה.
כללי הרשאות (visibility modifiers) בהורשה שיטות לא יכולות להידרס ע"י שיטה מרמת שיתוף נמוכה יותר, זו שגיאת קומפילציה. כלומר: לא ניתן לדרוס שיטה public עם protected או private לא ניתן לדרוס שיטה protected עם שיטה private public class Book { public String getName() { … } public class Dictionary extends Book { protected String getName() { … } Compilation Error שאלה: מה ההיגיון מאחורי שגיאה זו? Book b = new Dictionary(); System.out.println (b.getName() );
כללי הרשאות (visibility modifiers) בהורשה משתנים אינם עוברים דריסה בהורשה. שיטות שאינן private עוברות בהורשה. שיטות פרטיות נועדו למימוש פנימי של מחלקת האב, ואינם ניתנים לשימוש ע"י תת מחלקה. תת-המחלקה לא מכירה את המשתנים והשיטות הפרטיות של המחלקת האב, ממנה היא יורשת, ולכן עשויה גם להכריז על משתנים ושיטות פרטיות בעלי אותו שם וחתימה. דוגמה: חנות היא סוג של עסק עסק: דמי שכירות, עובדים, הוצאות חודשיות חנות: פריטי סחורה, הוצאות חודשיות הכוללות אחזקת מלאי. כל אחד מהם מומש ע"י מתכנת אחר בכל אחד מימוש שונה לשיטה פרטית - calcSum()
public class Business { protected Employee[] employees; protected double monthlyRent; ...... // calculates total monthly expenses public double monthlyExpenses() { double salaries = calcSum(); return this.monthlyRent + salaries; } // calculates monthly salaries private double calcSum() { double sum = 0; for (int i=0; i<this.employees.length; i=i+1) { sum = sum + this.employees[i].getSalary(); return sum; קריאה לשיטה פרטית
public class Shop extends Business { protected Item[] items; ...... // override: calculates total monthly expenses public double monthlyExpenses() { double itemPrices = calcSum(); return itemPrices + super.monthlyExpenses(); } // No override: calculates total item prices private double calcSum() { double sum=0; for (int i=0; i<this.items.length; i=i+1) { sum = sum + this.items[i].getPrice(); return sum; קריאה לשיטה פרטית שאלה: אם נשנה את המאפיין של calcSum ל-protected מה תחשב monthlyExpenses?
סיכום חוקי גישה לשיטות ושדות בהורשה ב Java: טיפוס המשתנה (טיפוס המצביע/ reference type) קובע בזמן הידור אילו שיטות ניתן להפעיל על המשתנה ולאילו שדות של המשתנה ניתן לגשת. בקריאה לשיטה שאינה פרטית המופיעה במחלקת-אב ובתת-מחלקה, אם ע"י קריאה ישירה או ע"י שימוש באופרטור השייכות (.), הקוד המופעל נקבע בהתאם למחלקת האובייקט בפועלinstance type) ) שעליו מופעלת השיטה (ומשם בסריקה מלמטה למעלה לפי היררכית ההורשה). שיטה פרטית נגישה רק בתוך ה- scope של המחלקה בה היא מוגדרת. בקריאה לשיטה פרטית, הקוד המופעל נקבע לפי ה -scope בו ממוקמת הקריאה. בגישה לשדה (קריאה או השמה), ע"י גישה ישירה (ללא אופרטור השייכות), הגישה לשדה נקבעת לפי ה-scope בה ממוקמת הגישה (ומשם בסריקה מלמטה למעלה לפי היררכית ההורשה). בגישה לשדה (קריאה או השמה) שאינו פרטי, ע"י אופרטור השייכות, בהתאם למחלקת טיפוס המשתנהreference type) ) שעליו מופעלת השיטה (ושם בסריקה מלמטה למעלה לפי היררכית ההורשה).
דוגמה להורשה (שאלה ממבחן)
public class A { private int x; public int y; public A(int x) { this.x = x; this.y = 2*x; } public int getX() { return x; } public int doubleX() { return 2 * getX(); } public int tripleX() { return 3 * x; } private int subXhelper() { return x - 1; } public int subX() { return subXhelper(); public class B extends A { private int x; public int y; public B(int xA, int xB) { super(xA); this.x = xB; this.y = xA + xB; } public int getX() { return x; } public int superX() { return super.getX(); public int tenTimesX() { return 10*x; } private int subXhelper() { return x-2; } A a = new A (1); A b = new B (2, 22); Output / Notes System.out.println(a.getX()); System.out.println(b.getX()); System.out.println(b.superX()); 1 22 Compilation Error !! if (b instanceof B) System.out.println(b.superX()); Compilation Error !!
public class A { private int x; public int y; public A(int x) { this.x = x; this.y = 2*x; } public int getX() { return x; } public int doubleX() { return 2 * getX(); } public int tripleX() { return 3 * x; } private int subXhelper() { return x - 1; } public int subX() { return subXhelper(); public class B extends A { private int x; public int y; public B(int xA, int xB) { super(xA); this.x = xB; this.y = xA + xB; } public int getX() { return x; } public int superX() { return super.getX(); public int tenTimesX() { return 10*x; } private int subXhelper() { return x-2; } A a = new A (1); A b = new B (2, 22); Output / Notes B bb = (B)b; System.out.println(bb.superX()); 2 System.out.println(((B)b).superX()); 2 System.out.println(a.tripleX()); System.out.println(b.tripleX()); 3 6
public class A { private int x; public int y; public A(int x) { this.x = x; this.y = 2*x; } public int getX() { return x; } public int doubleX() { return 2 * getX(); } public int tripleX() { return 3 * x; } private int subXhelper() { return x - 1; } public int subX() { return subXhelper(); public class B extends A { private int x; public int y; public B(int xA, int xB) { super(xA); this.x = xB; this.y = xA + xB; } public int getX() { return x; } public int superX() { return super.getX(); public int tenTimesX() { return 10*x; } private int subXhelper() { return x-2; } A a = new A (1); A b = new B (2, 22); Output / Notes Run-time Error: ClassCastException: A cannot be cast to B System.out.println(((B)a).tenTimesX()); System.out.println(((B)b).tenTimesX()); System.out.println(b.doubleX()); 220 44 System.out.println(b.subX()); 1
public class A { private int x; public int y; public A(int x) { this.x = x; this.y = 2*x; } public int getX() { return x; } public int doubleX() { return 2 * getX(); } public int tripleX() { return 3 * x; } private int subXhelper() { return x - 1; } public int subX() { return subXhelper(); public class B extends A { private int x; public int y; public B(int xA, int xB) { super(xA); this.x = xB; this.y = xA + xB; } public int getX() { return x; } public int superX() { return super.getX(); public int tenTimesX() { return 10*x; } private int subXhelper() { return x-2; } A a = new A (1); A b = new B (2, 22); Output / Notes System.out.println(a.y); System.out.println(b.y); System.out.println(((B)b).y); B bb= (B)b; System.out.println(bb.y); System.out.println(((A)bb).y); 2 4 24