תוכנית דוגמא של השלכה כללית

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

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

התוכנית מגדירה מחלקת מורה בעלת היכולת

        ·   ליצור ולהחזיק ברשימה של אובייקט אחד (בלבד) של סוג הממשק
    (אובייקטים מרובים הם בשלב מאוחר יותר),

        ·  לידע אובייקט זה שמשהו מעניין התרחש על ידי עוררות פונקצית ()callBack .

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

התוכנית מגדירה מחלקה בשם תלמיד אשר מיישמת את ממשק ה- CallBack . אובייקטים של מחלקת תלמיד ניתן לרשום על גבי הרשימה המוחזקת בידי אובייקט ממחלקת מורה, ויכולים לקבל הודעה מהאובייקט במחלקת מורה בכל פעם שדבר מה מעניין מתרחש. הודעה תקבל צורה של התעוררות פונקצית ה- callBack() על האובייקט.

את גוף פונקצית ה-callBack() ניתן לתכנן כך שיעשה כל דבר, אבל במקרה זה על מנת לשמור על הפשטות , הוא פשוט מכריז על כך שקראו לו.

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

התוכנית נבדקה תוך שימוש ב-JDK 1.1.3.  תחת Win95.

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

חלקי קוד מעניינים של השלכה כללית

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

interface CallBack{   public void callBack(); }//end interface CallBack

אחר כך אנו זקוקים למחלקה שהאובייקטים שלה יכולים להחזיק ברשימת אובייקטים מסוג קריאה לאחור (אובייקטים שהמחלקה שלהם מיישמת את ממשק CallBack).

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

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

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

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

אחת הפונקציות המכונה register()  שמה אובייקט ברשימה.

הפונקציה השניה בשם calltheRoll() מעוררת את פונקצית callBack() על האובייקט ברשימה זו.

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

class Teacher{  CallBack obj; //list of objects of type CallBack   //-----------------------------------------------------//   //Method to add objects to the list.   void register(CallBack obj){     this.obj = obj;  }//end register()   //-----------------------------------------------------//     //Method to notify all objects on the list   void callTheRoll(){     obj.callBack();   }//end callTheRoll()   //-----------------------------------------------------// }//end class Teacher

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

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

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

class Student implements CallBack{  String name;   //-----------------------------------------------------//     Student(String name){//constructor     this.name = name;  //save the name to identify the obj   }//end constructor   //-----------------------------------------------------//    public void callBack(){     System.out.println(name + " here");   }//end callBack() }//end class Student

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

פונקצית main() במחלקה זו:

        · מאתחלת אובייקט ממחלקת מורה בשם missJones ,

        · מאתחלת אובייקט תלמיד אנונימי בשם Joe ורושמת את האובייקט על הרשימה
  המוחזקת בידי missJones

        · ומעוררת את פונקצית ()callTheRoll על missJones על מנת לגרום לאובייקטים ברשימה 
  לקבל הודעה (גורם לעוררות פונקצית ה- callBack() שלהם).

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

class Callback01{   public static void main(String[] args){     //Instantiate Teacher object    Teacher missJones = new Teacher();     //Instantiate and register a Student object with the     // Teacher object     missJones.register(new Student("Joe"));     //Cause the Teacher object to do a callBack on the     // Student object.     missJones.callTheRoll();   }//end main() }//end class Callback01