1. תרגול 11 המשך תכנות מונחה עצמים 1

2. היום בתרגול כללי הרשאות בהורשה חריגות מחלקות אבסטרקטיות 2

3. כללי הרשאות (visibility modifiers) בהורשה public – שדות ושיטות המוגדרים כ-public ניתנים לגישה מתוך ומחוץ למחלקה. protected – שדות ושיטות המוגדרים כ-protected ניתן לגישה מתוך המחלקה וממחלקות היורשות מהמחלקה אך אינם ניתן לגישה ממחלקות אחרות *. (* ממחלקות אחרות הנמצאות ב package אחר. protected מתנהג כמו public באותו package) private – שדות ושיטות המוגדרים כ-private אינם ניתנים לגישה מחוץ למחלקה. ניסיון לגשת לשדה או שיטה כזו מחוץ למחלקה יעורר שגיאת קומפילציה. 3

4. שיטות לא יכולות להידרס ע"י שיטה מרמת שיתוף נמוכה יותר, זו שגיאת קומפילציה. כלומר: –לא ניתן לדרוס שיטה public עם protected או private –לא ניתן לדרוס שיטה protected עם שיטה private public class Book { public String getName() { … } public class Dictionary extends Book { protected String getName() { … } Compilation Error שאלה: מה ההיגיון מאחורי שגיאה זו? 4 Book b = new Dictionary(); System.out.println (b.getName() ); כללי הרשאות (visibility modifiers) בהורשה

5. משתנים אינם עוברים דריסה בהורשה. שיטות שאינן private עוברות בהורשה. –שיטות פרטיות נועדו למימוש פנימי של מחלקת האב, ואינם ניתנים לשימוש ע"י תת מחלקה. –תת-המחלקה לא מכירה את המשתנים והשיטות הפרטיות של המחלקת האב, ממנה היא יורשת, ולכן עשויה גם להכריז על משתנים ושיטות פרטיות בעלי אותו שם וחתימה. דוגמה: –חנות היא סוג של עסק עסק: דמי שכירות, עובדים, הוצאות חודשיות חנות: פריטי סחורה, הוצאות חודשיות הכוללות אחזקת מלאי. –כל אחד מהם מומש ע"י מתכנת אחר –בכל אחד מימוש שונה לשיטה פרטית - calcSum() 5 כללי הרשאות (visibility modifiers) בהורשה

6. 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; }...... } 6  קריאה לשיטה פרטית

7. 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; }...... } 7 שאלה: אם נשנה את המאפיין של calcSum ל-protected מה תחשב monthlyExpenses?  קריאה לשיטה פרטית

8. סיכום חוקי גישה לשיטות ושדות בהורשה ב Java: 1.טיפוס המשתנה (טיפוס המצביע/ reference type) קובע בזמן הידור אילו שיטות ניתן להפעיל על המשתנה ולאילו שדות של המשתנה ניתן לגשת. 2.בקריאה לשיטה שאינה פרטית המופיעה במחלקת-אב ובתת-מחלקה, אם ע"י קריאה ישירה או ע"י שימוש באופרטור השייכות (.), הקוד המופעל נקבע בהתאם למחלקת האובייקט בפועלinstance type) ) שעליו מופעלת השיטה (ומשם בסריקה מלמטה למעלה לפי היררכית ההורשה). 3.שיטה פרטית נגישה רק בתוך ה- scope של המחלקה בה היא מוגדרת. בקריאה לשיטה פרטית, הקוד המופעל נקבע לפי ה -scope בו ממוקמת הקריאה. 4.בגישה לשדה (קריאה או השמה), ע"י גישה ישירה (ללא אופרטור השייכות), הגישה לשדה נקבעת לפי ה-scope בה ממוקמת הגישה (ומשם בסריקה מלמטה למעלה לפי היררכית ההורשה). 5.בגישה לשדה (קריאה או השמה) שאינו פרטי, ע"י אופרטור השייכות, בהתאם למחלקת טיפוס המשתנהreference type) ) שעליו מופעלת השיטה (ושם בסריקה מלמטה למעלה לפי היררכית ההורשה). 8

9. דוגמה להורשה (שאלה ממבחן) 9

10. A a = new A (1); A b = new B (2, 22); System.out.println(a.getX()); System.out.println(b.getX()); System.out.println(b.superX()); 1 22 Compilation Error !! Output / Notes if (b instanceof B) System.out.println(b.superX()); Compilation Error !! 10 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; } }

11. A a = new A (1); A b = new B (2, 22); Output / Notes 11 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; } } 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

12. System.out.println(b.subX()); System.out.println(((B)b).tenTimesX()); System.out.println(b.doubleX()); 220 44 1 12 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; } } System.out.println(((B)a).tenTimesX()); Run-time Error: ClassCastException: A cannot be cast to B Output / Notes A a = new A (1); A b = new B (2, 22);

13. 13 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; } } Output / Notes A a = new A (1); A b = new B (2, 22); 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 4

14. חריגות (Exceptions) חריגה היא אירוע המתרחש במהלך תוכנית המפר את תהליך הריצה הנורמאלי של פקודות התוכנית. לעיתים חריגות מתרחשות בגלל תקלות בלתי צפויות, כגון בעיה בקובץ אליו כותבים (למשל אין הרשאות כתיבה), ולעיתים בגלל תקלות תוכנה, כגון שליחת פרמטר לא מתאים לפונקציה. 14

15. כבר נתקלנו ב-RuntimeExceptions ArithmeticException: ניסיון חלוקה באפס IndexOutOfBoundsException: חריגה ממערך NullPointerException: ניסיון לפעול על משתנה שאינו פרימיטיבי בעל ערך null 15 וראינו כי ניתן לזרוק RuntimeException באמצעות throw

16. Throw RuntimeException public class Car { private final int MAX_SPEED = 210; private final int MIN_SPEED = -20; private int speed; … public void setSpeed(int speed){ if ((speed >= MIN_SPEED) && (speed <= MAX_SPEED)) this.speed = speed; else throw new RuntimeException(“Illegal speed”); } 16 public static void main(String[] args) { Car car = new Car(); car.setSpeed(300); } Output: Exception in thread "main" java.lang.RuntimeException: Illegal Speed at Car.setSpeed(Car.java:11) at Car.main(Car.java:17)

17. סוגי Exceptions 17 Exception IOExceptionRuntimeException NullPointerException Object

18. Exception ניתן לייצר חריגה ע"י פקודת throw המייצרת את אירוע החריגה. ישנן שתי דרכים לטפל בחריגה: –לתפוס את ה- Exception על ידי שימוש במילים השמורות try ו-catch –להעביר את ה- Exception הלאה על ידי שימוש במילה השמורה throws בכותרת הפונקציה שאנו כותבים. (טיפול בחריגות לא הכרחי עבור (RuntimeExceptions 18

19. Throw and Catch Exceptions public class Car { private final int MAX_SPEED = 210; private final int MIN_SPEED = -20; private int speed; … public void setSpeed(int speed) throws Exception { if ((speed >= MIN_SPEED) && (speed <= MAX_SPEED)) this.speed = speed; else throw new Exception(“Illegal speed”); } 19 public static void main(String[] args) { Car car = new Car(); car.setSpeed(100); } Compilation Error

20. Throw and Catch Exceptions public class Car { private final int MAX_SPEED = 210; private final int MIN_SPEED = -20; private int speed; … public void setSpeed(int speed) throws Exception { if ((speed >= MIN_SPEED) && (speed <= MAX_SPEED)) this.speed = speed; else throw new Exception(“Illegal speed”); } 20 public static void main(String[] args) { Car car = new Car(); try{ car.setSpeed(300); System.out.println("Broke the speed limit !"); } catch(Exception e){ System.err.println("Caught Exception: "+e.getMessage()); } System.out.println("Current speed is "+car.getSpeed()+” km/h); } Output:Caught Exception: Illegal Speed Current speed is 0 km/h

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

22. מחלקות אבסטרקטיות public abstract class { public abstract void (... ); … } במחלקה אבסטרקטית יכולות להיות שיטות רגילות, כמו בכל מחלקה. בנוסף יכולות להיות לה שיטות אבסטרקטיות: שיטות שההגדרה שלהן קיימת אבל אין להן מימוש. אנו מכריזים על מחלקה או על שיטה כאבסטרקטית בעזרת המילה השמורה abstract. 22

23. מחלקות אבסטרקטיות מחלקה אבסטרקטית -לא ניתן ליצור ממנה מופעים. public abstract class Game { public Game() { … } … } Game g = new Game(); // Compilation error! מחלקה שמרחיבה מחלקה אבסטרקטית ולא מממשת את כל השיטות האבסטרקטיות, חייבת להיות אבסטרקטית בעצמה. 23

24. Spy Robot (רובוט מעקב) הינו רובוט הנשלט מרחוק ומאפשר צילום תמונות ושלחתם. רובוט מעקב יכול לבצע את הפעולות הבאות: –לצלם תמונות ולשדר אותן –לזוז קדימה / אחורה –להסתובב ימינה / שמאלה 24 Spy Robot

25. נסתכל על 2 רובוטי מעקב שניהם יכולים לצלם תמונות ולשדר באותה דרך אך הם זזים בדרכים שונות. 25 Spy Robot

26. 26 Spy Robot public abstract class SpyRobot { private String model; public SpyRobot(String model) { this.model=model; } public String getModel() { return this.model; } public abstract void moveForward(); public abstract void moveBackward(); public abstract void turnLeft(); public abstract void turnRight(); public void takePicture() {... } public void chargeBattery() {... } }

27. 27 Roboquad – Spy Robot public class LegsSpyRobot extends SpyRobot { public LegsSpyRobot() { super("Roboquad"); } public void moveForward() { for(int i=0; i<4; i++) this.moveLeg(i, 1); } public void moveBackward() { for(int i=0; i<4; i++) this.moveLeg(i, -1); } public void turnLeft() { this.moveLeg(0,-1); this.moveLeg(1,-1); this.moveLeg(2,1); this.moveLeg(3,1); } // direction {1=forward, -1=backward} private void moveLeg(int legId, int dir) {... }; } public void turnRight() { this.moveLeg(0,1); this.moveLeg(1,1); this.moveLeg(2,-1); this.moveLeg(3,-1); } 0 1 2 3

28. 28 Spyke – Spy Robot public class WheelsSpyRobot extends SpyRobot { public WheelsSpyRobot() { super("Spyke"); } public void moveForward() { this. turnWheels(1,1); } public void moveBackward() { this. turnWheels(-1,-1); } public void turnLeft() { this. turnWheels(0,-1); } public void turnRight() { this. turnWheels(-1,0); } // direction {1=forward, 0=stop, -1=backward} private void turnWheels(int rightDir,int leftDir) {... }; // move features public void waveHands() {... } }

29. 29 Fly – Spy Robot את זה אתם כבר יכולים לממש לבד ?

30. מחלקות אבסטרקטיותממשקים לא ניתן ליצור מופעים שימוש ע"י ירושה extendsשימוש ע"י מימושו implements יכולה להכיל קוד של חלק מהשיטותהכרזה של שיטות בלי מימוש יורשי מחלקה זו יהיו בעלי קוד משותף וכן בעלי התנהגויות שונות (השיטות האבסטרקטיות) ממשק הוא הכרזה על תכונה מופשטת, למממשים אין קוד משותף. מחלקה יכולה לרשת מחלקה (אבסטרקטית) אחת בלבד מחלקה יכולה לממש מספר ממשקים אין הגבלה על שדותרק קבועים וסטאטיים 30

31. נממש משחקים מתורת המשחקים ע"י הורשה: –משחק מוגדר על ידי מערכת של פעולות אפשריות ושיטת ניקוד. –במשחק משחקים שני שחקנים כאשר שני השחקנים בוחרים פעולה בו-זמנית. –בהינתן שתי הבחירות של השחקנים יקבלו השחקנים ניקוד ע"פ בחירתם. 31 דוגמא נוספת

32. דוגמה: אבן נייר ומספריים בחירה מבין שלוש הפעולות האפשריות (אבן, נייר או מספריים). –אבן שוברת מספריים. –מספריים גוזרים נייר. –נייר עוטף אבן. 32

33. דוגמה: דילמת האסיר המשטרה עוצרת שני עבריינים שביצעו פשע משותף, ומפרידה ביניהם לצורך חקירה. המשטרה מציעה לכל אחד מהם להעיד נגד רעהו, וכפרס מובטח לעד עונש מופחת. בחירה מבין הפעולות האפשריות: להעיד או לשתוק. ניקוד: –אם שניהם יעידו, ייכנס כל אחד מהם לכלא לחמש שנים. –אם רק אחד מהם יעיד ורעהו ישתוק, העד יצא מיד לחופשי וחברו ייכלא ל-15 שנה. –אם שניהם ישתקו, יכנס כל אחד מהם לשנה בכלא. 33

34. המחלקות שעלינו לממש פעולה Action –שם הפעולה ("אבן") שחקן Player –שם השחקן (" Andrea Farina ") –מספר נקודות –בחירת פעולה(מהלך) מתוך קבוצת פעולות אפשריות. משחק Game – קבוצת פעולות אפשריות –שיטת ניקוד – 2 שחקנים – שם המשחק 34

35. מימוש המחלקה של פעולה כללית public class Action { private String name; public Action(String name) { this.name = name; } public String getName(){ return this.name; } public boolean equals(Object other) { boolean ans = false; if(other instanceof Action) ans = this.name.equals(((Action)other).name); return ans; } 35

36. מימוש המחלקה של שחקן כללי public abstract class Player { private String name; private int score; public Player(String name){ this.name = name; this.score = 0; } public abstract Action selectAction(Action[] actions); public boolean isWinner(Player p){ return (this.score > p.getScore()); } public void updateScore(int score){ this.score = this.score + score; } public int getScore(){ return this.score; } 36

37. מימוש שחקן אקראי public class RandomPlayer extends Player{ public RandomPlayer(String name) { super(name); } public Action selectAction(Action[] actions){ int randIdx = (int)(Math.random()*actions.length); return actions[randIdx]; } 37

38. מימוש שחקן עיקבי public class ConsecutivePlayer extends Player { private int lastIdx; public ConsecutivePlayer(String name) { super(name); this.lastIdx = 0; } public Action selectAction(Action[] actions) { this.lastIdx = (this.lastIdx + 1) % actions.length; return actions[this.lastIdx]; } 38

39. 39 public abstract class Game { private Player p1, p2; private String name; //game name protected Action[] actions; // the set of actions public Game(Player p1, Player p2, String name){ this.p1 = p1; this.p2 = p2; this.name = name; this.initActions(); } // There is no real list of actions in a general game protected abstract void initActions(); … מימוש משחק כללי

40. public abstract class Game { … public void play(int turnCount) { for (int i=0; i<turnCount; i=i+1) this.playSingleTurn(); } private void playSingleTurn() { /* the selection order is not important * as each player does not * know the choice of the other player */ Action a1 = this.p1.selectAction(actions); Action a2 = this.p2.selectAction(actions); this.rewardPlayers(a1, a2); } // There is no real scoring strategy in a general game protected abstract void rewardPlayers(Action a1, Action a2); … 40 מימוש משחק כללי (המשך)

41. public abstract class Game { … public Player getWinner () { if (this.p1.isWinner(this.p2)) return this.p1; else return this.p2; } protected Player getFirstPlayer() { return this.p1; } protected Player getSecondPlayer() { return this.p2; } 41 מימוש משחק כללי (המשך)

42. מימוש המשחק אבן נייר ומספריים public class RockPaperScissors extends Game{ public RockPaperScissors(Player p1, Player p2) { super(p1, p2, "Rock Paper Scissors"); } protected void initActions(){ this.actions = new Action[3]; this.actions[0] = new Action("rock"); this.actions[1] = new Action("paper"); this.actions[2] = new Action("scissors"); }... 42

43. 43 protected void rewardPlayers(Action a1, Action a2) { int p1score = 0; if (!(a1.equals(a2))) {// Different actions if ((a1.getName().equals("rock") && a2.getName().equals("scissors")) || (a1.getName().equals("paper") && a2.getName().equals("rock")) || (a1.getName().equals("scissors") && a2.getName().equals("paper"))) { p1score = 1; } else { p1score = -1; } this.getFirstPlayer().updateScore(p1score); this.getSecondPlayer().updateScore(-p1score); }

44. מימוש המשחק דילמת האסיר public class PrisonerDilemmas extends Game{ public PrisonerDilemmas(Player p1, Player p2) { super(p1, p2, "Prisoner's Dilemma"); } protected void initActions(){ this.actions = new Action[2]; this.actions[0] = new Action("silent"); this.actions[1] = new Action("blame"); }... 44

45. protected void rewardPlayers(Action a1, Action a2) { if (a1.equals(a2)) { // Same actions if (a1.getName().equals("blame") { // blame & blame this.getFirstPlayer().updateScore(-5); this.getSecondPlayer().updateScore(-5); } else { // silent & silent this.getFirstPlayer().updateScore(-1); this.getSecondPlayer().updateScore(-1); } } else { // Different actions if (a1.getName().equals("blame") { // blame & silent this.getFirstPlayer().updateScore(0); this.getSecondPlayer().updateScore(-15); } else { // silent & blame this.getFirstPlayer().updateScore(-15); this.getSecondPlayer().updateScore(0); } 45