תכנון השעור מבוסס על שאלה 3 במבחן המסכם ( מועד א ' ) 2010

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

המשימה נתון ממשק FunctionInterface המגדיר פונקציה חד מקומית y = f(x) public interface FunctionInterface { /** * Returns the function’s value at “x”. */ public double valueAt(double x); } השיטה valueAt(x) מחזירה את ערך הפונקציה בנקודה x. כלומר אם y = f(x) = 2x+3 וגם x=5 השיטה תחזיר את הערך 13.

המשימה הלקוח מבקש ארבע מחלקות המיישמות את הממשק : 1.LinearFunction המייצגת את הפונקציה y=a*x+b ( הבונה שלה יקבל את a ו - b כפרמטרים. 2. ConstantFunction המייצגת את הפונקציה y = c ( הבונה שלה יקבל את c כפרמטר. 3. SinFunction המייצגת את הפונקציה y = a*sin(f*x+p) ( הבונה יקבל את a, f ו - p כפרמטרים ). 4. CosFunction כנ " ל בנוסף ליישום הממשק FunctionInterface צריכות המחלקות האלו להכיל גם שיטת square() המחזירה את ערך הפונקציה בריבוע, שיטת derivativeAt(double x) המחזירה את הנגזרת של הפונקציה ( בעמדה x) ולבסוף המחלקות האלו צריכות לדרוס את שיטת toString() של המחלקה Object באופן הגיוני.

המשימה LinearFunction(double a, double b) double valueAt(double x) double square(double x) double derivativeAt(double x) CosFunction(double t) double valueAt(double x) double square(double x) Function derived() ConstantFunction(double c) double valueAt(double x) double square(double x) double derivativeAt(double x) SinFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivativeAt(double x)

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

LinearFunction(double a, double b) double valueAt(double x) double square(double x) double derivativeAt(double x) trigoFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivativeAt(double x) ConstantFunction(double c) double valueAt(double x) double square(double x) double derivativeAt(double x) Function double valueAt(double x) double square(double x) double derivativeAt(double x) abstract class? Interface? CosFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivativeAt(double x) SinFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivativeAt(double x)

LinearFunction(double a, double b) double valueAt(double x) double square(double x) double derivativeAt(double x) trigoFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivativeAt(double x) ConstantFunction(double c) double valueAt(double x) double square(double x) double derivativeAt(double x) Function double valueAt(double x) double square(double x) double derivativeAt(double x) abstract class? Interface? CosFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivatiativeAt(double x) SinFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivativeAt(double x)

עקרונות לתכנון איך קשורות השיטות זו לזו : double valueAt(double x) double square(double x) double derivativeAt(double x) האם יש שיטה אחת שבה משתמשות שיטות אחרות ?

LinearFunction(double a, double b) double valueAt(double x) double square(double x) double derivativeAt(double x) trigoFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivativeAt(double x) ConstantFunction(double c) Function() abstract double valueAt(double x) double square(double x) double derivativeAt(double x) abstract class CosFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivativeAt(double x) SinFunction(double a, double f, double p) double valueAt(double x) double square(double x) double derivativeAt(double x)

LinearFunction(double a, double b) double valueAt(double x) double derivativeAt(double x) trigoFunction(double a, double f, double p) double valueAt(double x) ConstantFunction(double c) Function() abstract double valueAt(double x) double square(double x) double derivativeAt(double x) abstract class CosFunction(double a, double f, double p) double valueAt(double x) double derivativeAt(double x) SinFunction(double a, double f, double p) double valueAt(double x) double derivativeAt(double x) )

מה לגבי TrigoFunction? המחלקות המרחיבות אותה יכולות ליישם כך את valueAt public class SinFunction extends TrigoFunction{ : public double valueAt(double x) { return amplitude*Math.sin(frequency*x+phase); } public class CosFunction extends TrigoFunction{ : public double valueAt(double x) { return amplitude*Math.cos(frequency*x+phase); }

עדיף public abstract class TrigoFunction extends Function{ : protected abstract double elementaryTrygoFunction(double x); public double valueAt(double x) { return amplitude * elementaryTrygoFunction (frequency*x+phase); }

עדיף public class SinFunction extends TrigoFunction{ : protected double elementaryTrygoFunction(double x) { return Math.sin(x); } public class CosFunction extends TrigoFunction{ : protected double elementaryTrygoFunction(double x) { return Math.cos(x); }

LinearFunction(double a, double b) double valueAt(double x) double derivativeAt(double x) trigoFunction(double a, double f, double p) Abstract double elementary(.) double valueAt(double x) ConstantFunction(double c) Function() abstract double valueAt(double x) double square(double x) double derivativeAt(double x) abstract class CosFunction(double a, double f, double p) double elementary (double x) double derivativeAt(double x) SinFunction(double a, double f, double p) double elementary(double x) double derivativeAt(double x)

LinearFunction(double a, double b) double valueAt(double x) Function derivative() trigoFunction(double a, double f, double p) double valueAt(double x) ConstantFunction(double c) Function() abstract double alueAt(double x) double square(double x) double derivedAt(double x) abstract Function derivative() abstract class CosFunction(double a, double f, double p) double elementary(double x) Function derivative() SinFunction(double a, double f, double p) double elementary(double x) Function derivative()

מה עם דריסה של ?toString

עקרונות לתכנון 1. השיטה Squre פועלת באותו אופן בשלושת המחלקות. בהיותנו עצלנים נרצה לכתוב אותה רק פעם אחת. 2. קבוע ((ConstantFunction הוא מקרה פרטי של ישר (LinearFunction) כאשר השיפוע הוא אפס. אם נשתמש בזה, מן הסתם לא נצטרך בעצם לכתוב הרבה במחלקה הזו. 3. השיטה valueAt עושה דברים מאוד שונים ב - SinFunction וב - LinearFunction. כנראה שאין ברירה אלא ממש לכתוב אותן בנפרד.

public interface FunctionInterface { public double valueAt(double x); }

public abstract class Function implements FunctionInterface{ public double square(double x) { double v = valueAt(x); return v*v; } public double deriveativeAt(double x){ return derivative().valueAt(x); } protected abstract Function derivative(); }

public abstract class TrigoFunction extends Function{ protected double amplitude, frequency, phase; public TrigoFunction(double amplitude, double frequency, double phase) { this.amplitude = amplitude; this.frequency = frequency; this.phase = phase; } public double valueAt(double x) { return amplitude* trigoElementaryFunction(frequency*x+phase); } protected abstract double trigoElementaryFunction(double x); }

public class SinFunction extends TrigoFunction{ public SinFunction(double amplitude, double frequency, double phase) { super(amplitude, frequency, phase); } protected double trigoElementaryFunction(double x) { return Math.sin(x); } protected Function derivative() { return new CosFunction(amplitude*frequency, frequency, phase); }

public class LinearFunction extends Function { private double a,b; public LinearFunction(double a, double b) { this.a = a; this.b = b; } public double valueAt(double x) { return a*x+b; } protected Function derivative() { return new ConstantFunction(a); }

public class ConstantFunction extends LinearFunction { private double c; public ConstantFunction(double c) { super(0,c); }

public abstract class Function implements FunctionInterface{ : public double derivedAt(double x){ return derivative().valueAt(x); } : } האם גמרנו לתכנן?

חבילות packages 26

חבילות (Packages) חבילה היא יחידה ארגונית של קוד. כשם המחלקה מאגדת שדות ושיטות אשר כולם קשורים לאותו סוג של עצמים, כך חבילה מאגדת מספר מחלקות הקשורות באותו הנושא או אותה הפונקציונאליות. –לדוגמה : ניתן לאגד את המחלקות "Tank", "Box" ו -"Cylinder" לחבילה "tanks". כל המחלקות השייכות לאותה חבילה חייבות להימצא באותה הספריה, אשר שמה זהה לשם החבילה. –לדוגמה : המחלקות הנ " ל יימצאו בספריה C:\src\tanks

חבילות (Packages) package tanks; public abstract class Tank{ //... } Tank.java package tanks; public class Box extends Tank{ //... } Box.java package tanks; public class Cylinder extends Tank{ //... } Cylinder.java

יבוא קוד (import) ניתן " לייבא " קוד אשר נכתב בעבר על ידינו או על ידי אחרים לתוך התוכנית החדשה שאנו כותבים, ע " י הפקודה import. בדרך זו, ניתן לייבא מחלקה או חבילת מחלקות.

יבוא קוד (import) package tanks; import java.lang.*; import java.util.Scanner; public class Box { Scanner sc = new Scanner(System.in); //... } יבוא חבילה יבוא מחלקה

Visibility modifiers of classes כל מחלקה בחבילה יכולה להיות " ציבורית " או " חבילתית " –מחלקה ציבורית – בכותרתה מופיעה המילה public. ניתן להגשת למחלקה כזו גם מחוץ לחבילה –מחלקה חבילתית – כותרתה מתחילה מייד במילה class. ניתן להגשת למחלקה כזו רק בתוך החבילה. 31

Visibility modifiers of class members לכל רכיב במחלקה ( שדה או שיטה ) יכולים לתת " דרגת הפומביות " : public, protected, private ואפשר גם לא לרשום כלום ואז נאמר שרכיב הוא “package private” 32

Visibility modifiers of class members יהי x שדה או שיטה במחלקה C בחבילה P –אם x פרטי (private) ניתן לגשת אליו רק מתוך המחלקה C עצמה –אם x חבילתי ניתן לגשת אליו מכל מקום בחבילה, אך הוא אינו נראה מחוץ לחבילה –אם x מוגן (protected) ניתן להגשת אליו מכל מקום בחבילה P, ומכל מחלקה ( גם מחבילה אחרת ) אשר יורשת את C –אם x ציבורי (public) ניתן לגשת אליו מכל מקום ממנו ניתן להגשת ל -C. 33

Visibility modifiers access levels WorldSub-classPackageClass  public X  protected XX  No-modifier (package-private) XXX  private

סיכום – השוואה בין הורשה לממשקים שניהם משמשים לתיאור מצב בו לטיפוסים שונים של אובייקטים יש מאפיינים משותפים. שניהם מאפשרים פולימורפיזם. 35

סיכום – השוואה בין הורשה לממשקים ממשקים : –הנדסת תוכנה. –הגדרת יכולות משותפות לאובייקטים. מכנה משותף לוגי. –ניתן לממש הרבה ממשקים במחלקה אחת. הורשה : –שימוש מחדש בקוד. –מכנה משותף טכני יותר. –ניתן לרשת מחלקה אחת בלבד. 36

סיכום חוקי גישה לשיטות ושדות בהורשה ב Java בקריאה לשיטה שאינה פרטית המופיעה במחלקת - אב ובתת - מחלקה, אם ע " י קריאה ישירה או ע " י שימוש באופרטור השייכות (.), הקוד המופעל נקבע בזמן ריצה בהתאם למחלקת האובייקט בפועל (instance type) שעליו מופעלת השיטה ( ומשם בסריקה מלמטה למעלה לפי היררכית ההורשה ). בגישה לשדה ( קריאה או השמה ) שאינו פרטי, הגישה לשדה נקבעת בזמן קומפילציה לפי ה -scope בו ממוקמת הגישה ( ומשם בסריקה מלמטה למעלה לפי היררכית ההורשה ). 37

סיכום חוקי גישה לשיטות ושדות בהורשה ב Java שיטה או שדה פרטיים נגישים רק בתוך המחלקה בה הם מוגדרים. טיפוס המשתנה ( טיפוס המצביע / reference type) קובע בזמן קומפילציה אילו שיטות ניתן להפעיל על המשתנה ולאילו שדות של המשתנה ניתן לגשת. 38

Visibility modifiers of class members שיטה במחלקה יורשת בעלת שם זהה לשיטה במחלקת האב לא יכולה להצר את רמת הנגישות. –לדוגמה : אסור ששיטה getGrade() במחלקה Milgay תיהיה private/protected, אם במחלקה Student יש getGrade() שהיא public.

40 Concluding example public class Musician { private String name; public String instrument; public Musician(String name, String instrument){ this.name = name; this.instrument = instrument; } public String getInstrument() {return instrument;} public String getName() {return name;} private String getClassName(){return "Musician";}

41 public void play(){ System.out.println("[M] " + getName() + " plays music."); } public void printInfo(){ play(); System.out.println("[M] Class name: " + getClassName()); System.out.println("[M] Instrument: " + getInstrument()); } } //class Musician

42 public class RockMusician extends Musician{ public String instrument; public RockMusician(String name, String instrument) { super(name, instrument); this.instrument = instrument + " and drums"; } public String getClassName(){return "RockMusician“;} public void play(){ super.play(); System.out.println("[RM] " + getName() + " breaks his “ + super.getInstrument() + "!"); } } //class RockMusician

43 public static void func(Musician m){ System.out.println("I've got a musician!"); } public static void func(RockMusician m){ System.out.println("I've got a rock musician!"); } public static void main(String[] args) { Musician m1 = new Musician("Gershwin", "piano"); RockMusician rm = new RockMusician("Lennon", "guitar"); Musician m2 = new RockMusician("McCartney", "bass"); func(m1); func(rm); func(m2); func((RockMusician) m2); I've got a musician! I've got a rock musician! I've got a musician! I've got a rock musician!

44 m1.play(); rm.play(); m2.play(); m1.printInfo(); rm.printInfo(); System.out.println(rm.instrument); System.out.println(m2.instrument); System.out.println( ((RockMusician)m2).instrument); [M] Gershwin plays music. [M] Lennon plays music. [RM] Lennon breaks his guitar! [M] McCartney plays music. [RM] McCartney breaks his bass! [M] Gershwin plays music. [M] Class name: Musician [M] Instrument: piano [M] Lennon plays music. [RM] Lennon breaks his guitar! [M] Class name: Musician [M] Instrument: guitar guitar and drums bass bass and drums

45 public class IsraelyRockMusician extends RockMusician { public IsraelyRockMusician(String name, String instrument) { super(name, instrument); } public String getInstrument() {return instrument;} public String getName(){ return super.getName() + " the king"; } public String getClassName() { return "IsraelyRockMusician"; } } //class IsraelyRockMusician

46 Musician m3 = new IsraelyRockMusician("Chanoch", "guitar"); m3.printInfo(); [M] Chanoch the king plays music. [RM] Chanoch the king breaks his guitar! [M] Class name: Musician [M] Instrument: guitar and drums