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

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

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

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

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

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

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

8. 8 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() {... } }

9. 9 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

10. 10 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() {... } }

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

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

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

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

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

16. מימוש המחלקה של פעולה כללית 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; } 16

17. מימוש המחלקה של שחקן כללי 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; } 17

18. מימוש שחקן אקראי 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]; } 18

19. מימוש שחקן עיקבי 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]; } 19

20. 20 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(); … מימוש משחק כללי

21. 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); … 21 מימוש משחק כללי (המשך)

22. 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; } 22 מימוש משחק כללי (המשך)

23. מימוש המשחק אבן נייר ומספריים 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"); }... 23

24. 24 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); }

25. מימוש המשחק דילמת האסיר 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"); }... 25

26. 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); } 26

27. אוניברסיטת בן גוריון - מבוא למדעי המחשב27  ממשק מייצג רעיון מופשט.  הממשק (interface) הינו כלי ב -Java למימוש עיקרון ההפרדה בין הכרזה למימוש.  מבחינת המתכנת, ממשק הוא הצהרת כוונות או הבטחה שצריך למלא. ממשק קובע את הפונקציונאליות המשותפת לכל המחלקות המממשות אותו.

28. 28 הצהרה על ממשק : public interface { } 1. ממשקים מתארים שיטות ( ציבוריות ) ללא ישומן. 2. כל השיטות בממשק הן ציבוריות (public) - גם אם לא הוגדרו כך במפורש 3. הגדרת שיטה כפרטית בממשק היא טעות קומפילציה. הערה חשובה : המשתמש במחלקה המממשת ממשק אינו יכול לדעת את פרטי המימוש של השיטות, ואפילו רצוי שלא יצטרך לחשוב עליהם כדי שיוכל להתרכז במשימה שלפניו ולטפל בה ברמת מופשטות מתאימה.

29. 29 לדוגמה : public interface Predator { public boolean chasePrey(Prey p); public void eatPrey(Prey p); } 1. ממשקים מתארים שיטות ( ציבוריות ) ללא ישומן. 2. כל השיטות בממשק הן ציבוריות (public) - גם אם לא הוגדרו כך במפורש 3. הגדרת שיטה כפרטית בממשק תגרום לטעות קומפילציה.

30. 30 5. ממשק, בדומה למחלקה, מגדיר טיפוס. שדות, משתנים ופרמטרים יכולים להיות מוגדרים להיות מסוג ממשק. למשל, ניתן להצהיר על משתנה x להיות מסוג Predator: Predator x; 6. לא ניתן ליצור אובייקט מממשק. למשל : x = new Predator(); // will not compile !!!

31. 31 7. ניתן להצהיר על מחלקה כמימוש של ממשק כך : class Tiger implements Predator 8. מחלקה כזו צריכה לממש את כל שיטות הממשק ( שגיאת קומפילציה ). יוצאות מן הכלל הזה הן מחלקות אבסטרקטיות. 9. מחלקה יכולה לממש יותר מממשק אחד ! – נראה דוגמה בהמשך

32. 32 public interface Predator { public boolean chasePrey(Prey p); public void eatPrey(Prey p); } public class Tiger implements Predator { public boolean chasePrey(Prey p) { // code to chase prey p (specifically for a tiger) return runAfterPrey(p); } public void eatPrey (Prey p) { // code to eat prey p (for a tiger) chew(p); swallow(p); }... }

33. 33 public interface Predator { public boolean chasePrey(Prey p); public void eatPrey(Prey p); } public class Shark implements Predator { public boolean chasePrey(Prey p) { // code to chase prey p (specifically for a shark) return swimAfterPrey(p); } public void eatPrey (Prey p) { // code to eat prey p //(specifically for a shark) bite(p); swallow(p); }

34. 34  " טרף " הוא גם כן תאור כללי של יצור, המסוגל לבצע מספר פעולות בסיסיות. גם לו יהיה ממשק : public interface Prey { public boolean isAlive(); public void die(); public void runAway(); }  דוגמאות למחלקות שעשויות לממש " טרף ": public class Frog implements Prey { public void jump() {... } public void runAway() {... }... } public class Deer implements Prey {... }

35. 35  כריש הוא טורף וגם נמר הוא טורף.  בזכות הממשק המשותף אותו הם ממשים, אנחנו יכולים למשל, להחזיק מערך של טורפים ולהפעיל פעולות משותפות על כל אחד מהאיברים במערך. Predator[] preds = new Predator[3]; preds[0] = new Tiger(); preds[1] = new Shark(); preds[2] = new Shark(); Prey froggy = new Frog(); for (int i=0; i<preds.length && froggy.isAlive(); i=i+1) { froggy.runAway(); if (preds[i].chasePrey(froggy)) preds[i].eatPrey(froggy); }  ניתן לראות שיצרנו גם טרף – צפרדע, שנרדף ע " י הכרישים והנמר. האם ניתן היה להפעיל: froggy.jump() ?

36. 36  אך קודם נראה דוגמה כיצד ניתן לקבל טורף וטרף כפרמטר לפונקציה : public static void simulateChase(Predator predat, Prey prey) { prey.runAway(); if (predat.chasePrey(prey)) predat.eatPrey(prey); }  אנחנו יכולים להפעיל את הפעולות שטורף וטרף יודעים לעשות, למרות שאיננו יודעים איזה טורף או טרף קיבלנו בקריאה לפונקציה.

37. 37 Shark sharky1 = new Shark(); Frog kermit1 = new Frog(); simulateChase(sharky1, kermit1); שימו לב, ניתן גם לרשום : Predator sharky2 = new Shark(); Prey kermit2 = new Frog(); simulateChase(sharky2, kermit2); טיפוס המשתנה (reference type) קובע אילו שיטות חוקיות לביצוע עבור המשתנה (נבדק בזמן הידור). טיפוס האובייקט ((instance type בזיכרון שעליו מצביע המשתנה בזמן הריצה קובע איזו שיטה תופעל (כלומר, מאיזו מחלקה מממשת).

38. 38  ניתן, כמובן, להוסיף פעולות ( שיטות ) ומצב ( שדות ) למחלקות השונות, ללא קשר לממשק אותן ממשות. לדוגמה : public class Shark implements Predator { private String name; private int numOfTeeth; public Shark(String name) { this.name = name; numOfTeeth = 3000 + (int)(Math.random()*1000); } private void swallow(Prey p) { p.die(); } public int getNumOfTeeth() { return numOfTeeth; } public void swimForFun() {... } public void eatPrey (Prey p) { bite(p); swallow(p); }... }

39. 39 מימוש מספר ממשקים  ניתן לממש יותר מממשק אחד.  על המחלקה המיישמת לממש את הפונקציות של כל הממשקים.  אם מחלקה מיישמת שני ממשקים בעלי שיטה בעלת שם זהה נניח foo אז :  אם לשתי ה foo יש חתימה שונה אז המחלקה המיישמת חייבת לממש את שתיהן.  אם לשתי ה foo יש אותה חתימה ואותו טיפוס מוחזר אז המחלקה מיישמת רק foo אחד.  אם לשתי ה foo יש אותה חתימה אך טיפוס מוחזר שונה - טעות קומפילציה. ( לא ניתן לממש את שני הממשקים יחד ).  עד עתה חשבנו על צפרדע כטרף. אבל ניתן לחשוב עליו גם כטורף ( זבובים יהיו הטרף שלו במקרה זה ) public class Frog implements Prey, Predator { public boolean chasePrey(Prey p) {... } public void eatPrey (Prey p) {... }... }

40. 40 כעת הצפרדע יכולה לבצע את שני התפקידים : Shark sharky = new Shark(); Frog kermit = new Frog(); Fly bzzit = new Fly(); simulateChase(sharky, kermit); if(kermit.isAlive()) simulateChase(kermit, bzzit); sharky.swimForFun(); הערה: אף צפרדע (או זבוב) לא נפגע בהכנת התרגול האם ניתן היה להגדיר את sharky כ-Predator? האם ניתן היה להגדיר את kermit כ-Prey? האם ניתן היה להגדיר את bzzit כ-Prey? לא כן

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

42. 42 אופרטור instanceof instanceof זהו אופרטור המחזיר true אם ורק אם האובייקט משמאלו הוא מופע (instance) של המחלקה מימינו של האופרטור. דוגמאות : public class Cat {…} public interface ShowAnimal {…} public class Siamese extends Cat implements ShowAnimal {…}

43. 43 אופרטור instanceof public class Cat {…} public interface ShowAnimal {…} public class Siamese extends Cat implements ShowAnimal {…} System.out.println(myaoo instanceof Cat); System.out.println(mitzi instanceof Cat); System.out.println(myaoo instanceof "Cat"); Cat myaoo = new Cat(); Cat mitzi = new Siamese(); System.out.println(mitzi instanceof Siamese); System.out.println(myaoo instanceof Siamese); System.out.println(mitzi instanceof ShowAnimal); System.out.println(mitzi instanceof Object); //true //Compilation Error //true //false //true

44. 44 אופרטור instanceof public class Cat {…} public interface ShowAnimal {…} public class Siamese extends Cat implements ShowAnimal {…} System.out.println(mitzi instanceof myaoo); Cat myaoo = new Cat(); Cat mitzi = new Siamese(); System.out.println(!mitzi instanceof Cat); Cat pitzi = null; System.out.println(pitzi instanceof Cat); System.out.println(null instanceof String); //Compilation Error //Compilation Error: // operator ! cannot be applied to Cat //false System.out.println(!(mitzi instanceof Cat));