חלקי קוד מעניינים

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

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

שים לב גם לכך שעכשיו שתי הפונקציות זקוקות לפרמטר. המחלקה עבור פרמטר זה יוגדר בקרוב.

interface CallBack{
  public void recess(CallBackObjectClass obj);
  public void lunch(CallBackObjectClass obj);
  
  public void dummy1(CallBackObjectClass obj);
  public void dummy2(CallBackObjectClass obj);
  public void dummy3(CallBackObjectClass obj);
  public void dummy4(CallBackObjectClass obj);
  public void dummy5(CallBackObjectClass obj);
  public void dummy6(CallBackObjectClass obj);

}//end interface CallBack

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

class CallBackObjectClass{
  String data;
  
  CallBackObjectClass(String data){//constructor
    this.data = data;
  }//end constructor
}//end CallBackObjectClass

הקוד הבא הינו הגדרת המחלקה המתאמת עבור ממשק הקריאה לאחור. מחלקה זו מגדירה את כל פונקציות הממשק כפונקציות ריקות.

מחלקות אשר צריכות ליישם את הממשק יכולות עתה להרחיב במקום זאת את מחלקה זו ולבטל רק את הפונקציות הריקות בעלות העניין, ולהתעלם מאחרות. חשוב לציין שקיום מחלקה מתאמת לא מונע ממחלקה אחרת ליישם את הממשק במקום להרחיב את המחלקה המתאמת.

אובייקטים ממחלקה זו יכולים לקבל פוינטר לסוג הממשק לקריאה לאחור.

class CallBackAdapter implements CallBack{
  public void recess(CallBackObjectClass obj){};
  public void lunch(CallBackObjectClass obj){};
  
  public void dummy1(CallBackObjectClass obj){};
  public void dummy2(CallBackObjectClass obj){};
  public void dummy3(CallBackObjectClass obj){};
  public void dummy4(CallBackObjectClass obj){};
  public void dummy5(CallBackObjectClass obj){};
  public void dummy6(CallBackObjectClass obj){};  
}//end class CallBackAdapter

עתה נצטרך מחלקה אשר האובייקטים שלה יכולים להחזיק ברשימה של אובייקטים רשומים מסוג קריאה לאחור ויכולים להודיע לכל האובייקטים על הרשימה כאשר דבר מה מעניין מתרחש. למחלקה זו היכולת לעורר שתי פונקציות קריאה לאחור שונות: recess() ו- lunch().

מן הסתם, במידה ועקבת אחרי ההתפתחויות, תדע שזוהי המחלקה בשם מורה.

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

מכיוון שראית פונקציה זו מספר פעמים, ואתה אמור להכיר אותה, אני אמחק את רוב הקוד במחלקה ואראה לך רק את החלק אשר מעורר את פונקצית הקריאה לאחור recess() על כל האובייקטים ברשימה, תוך אתחול והעברת אובייקט מסוג CallBackObjectClass כפרמטר בכל מקרה.

class Teacher{
  //code deleted

  void callRecess(){
    //code deleted

    for(int cnt = 0; cnt < tempList.size(); cnt++){
      ((CallBack)tempList.elementAt(cnt)).recess(
                      new CallBackObjectClass(" Recess"));
    }//end for loop
  }//end callRecess()
  //code deleted

}//end class Teacher

זה מוביל אותנו לשלושת המחלקות המיישמות את ממשק הקריאה לאחור באופן עקיף על ידי הרחבת מחלקת CallBackAdapter.

אובייקטים משלושת מחלקות אלו יכולים להיות רשומים ברשימה המוחזקת בידי אובייקט ממחלקת מורה, ויקבלו הודעה כאשר האובייקט מעורר את פונקצית recess() או פונקצית lunch() על האובייקטים הרשומים ברשימה.

חלק מההודעה יהיה אובייקט המועבר כפרמטר לפונקצית הקריאה לאחור. קוד בפונקצית הקריאה לאחור יכול להתעלם מהאובייקט, או להוציא מידע מאובייקט זה ולהשתמש בו.

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

שים לב שמחלקה זו מרחיבה את מחלקת CallBackAdapter ולא מיישמת ממשקים.

בנוסף, שים לב שהוא רק מעמיס את פונקצית lunch() מהמחלקה המתאמת, תוך התעלמות מכל הפונקציות הריקות שהוגדרו במחלקה. לו לא הייתה מחלקה מתאמת במקרה זה, הגדרת מחלקת כלב זו הייתה נאלצת להגדיר שש פונקציות דמה ופונקצית recess() יחד עם הפונקציות הריקות. לכן, הזמינות של מחלקה מתאמת שכזו תיתן נוחות גדולה מאד למתכנת.

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

class Dog extends CallBackAdapter{
  String name; //store name here for later ID
  //-----------------------------------------------------//
  
  Dog(String name){//constructor
    this.name = name; //save the name to identify the obj
  }//end constructor
  //-----------------------------------------------------//

  public void lunch(CallBackObjectClass obj){//announce
    System.out.println(name + obj.data);
  }//end overridden lunch()
  //-----------------------------------------------------//
}//end class Dog

זה מוביל אותנו למחלקת הבקרה אשר מקשרת בין כל שאר החלקים ומפעילה אותם. מחלקת הבקרה בגרסה זו אינה שונה מזו בגרסת התוכנית הקודמת בשם קריאה לאחור03.

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

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

סיכום

לסיכום, יש לנו אובייקטים ממחלקות שונות הרשומים ברשימת קריאה לאחור משותפת בה כל אובייקט מקבל קריאה לאחור עבור כל סוג שונה של אירוע קריאה לאחור המקושר לרשימה.

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

סוגים שונים של קריאות לאחור מבוססות על ידי הכרזת פונקציות בממשק קריאה לאחור.

מחלקה מתאמת מוגדרת כמחלקה אשר מיישמת את ממשק הקריאה לאחור ומגדירה את כל הפונקציות שלו כפונקציות ריקות.

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

מחלקה שכזו יכולה בנוסף להתעלם מהמחלקה המתאמת וליישם את הממשק באופן ישיר כמו בשיעורים הקודמים.