שאלות סיכום

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

ת: אמת.

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

ת: אמת.

ש: בהגדרה של ממשק, ניתנים הן ההצהרות של מתודות והן היישומים הממשיים של המתודה
(גוף המתודות): אמת או שקר? אם שקר, הסבר מדוע.

ת: שקר. בהגדרת הממשק ניתנות רק ההצהרות של המתודות. היישומים הממשיים של המתודות (גוף המתודות) אינו ניתן בממשק.

ש: הגדרה של ממשק עשויה להכיל רק הצהרות על מתודות: אמת או שקר? אם שקר, הסבר מדוע.

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

ש: אם מחלקות Q,D,P משתמשות כולן בממשק X, ניתן להשׂים משתנה הצבעה על אובייקט ממחלקות Q,D,P למשתנה הצבעה מטיפוס X: אמת או שקר? אם שקר, הסבר מדוע.

ת: אמת.

ש: אם מחלקות Q,D,P משתמשות כולן בממשק X, אזי כל המתודות, שהוצהרו ב‑X, חייבות להיות זהות בדיוק בכל אחת מהמחלקות Q,D,P: אמת או שקר? אם שקר, הסבר מדוע.

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

ש: אם מחלקות Q,D,P משתמשות כולן בממשק X, ניתן להשׂים משתנה הצבעה על אובייקט ממחלקות Q,D,P למשתנה הצבעה מטיפוס X, ומשתנה הצבעה זה יוכל לגשת לכל מתודה של המחלקה המקורית (אם אינה מצוינת כבלתי נגישה על ידי public, private או protected):
אמת או שקר? אם שקר, הסבר מדוע.

ת: שקר. אם אחת, או יותר, מהמחלקות Q,D,P מגדירות מתודות מופע שאינן מוצהרות בממשק, משתנה מטיפוס X לא יוכל לגשת לאותן מתודות מופע. במשתני הצבעה מטיפוס X ניתן להשתמש רק כדי לגשת למתודות שהוגדרו בממשק X (או באחד מממשקי-העל שלו).

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

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

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

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

ש: בדומה למחלקות, גם הגדרות של ממשקים מרובים ניתן לשלב בתוך קובץ source יחיד:
אמת או שקר? אם שקר, הסבר מדוע.

ת: שקר. המהדר מחייב שהגדרות הממשקים יהיו בקבצים נפרדים.

ש: ציין ארבעה שימושים לממשק.

ת:

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

·       ללכוד את הדימיון בין מחלקות שאינן קשורות, מבלי לכפות עליהן קשר מחלקתי

·       להצהיר על מתודות, שבהן אמורות מחלקות שונות להשתמש

·       לחשוף את ממשק התכנות של אובייקט, מבלי לחשוף את המחלקה שלו (אובייקטים כאלה נקראים אובייקטים אנונימיים והם שימושיים כאשר אנו שולחים חבילה של מחלקות למְפַתחים אחרים).

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

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

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

ת: אמת.

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

ת: שקר. מחלקה יכולה להרחיב רק מחלקה אחרת אחת.

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

ת: שקר. ממשק אינו יכול להרחיב מחלקה.

ש: ממשק יורש את כל הקבועים והמתודות שלו ממשק-העל שלו: אמת או שקר?
אם שקר, הסבר מדוע.

ת: שקר. ממשק יורש את כל הקבועים והמתודות של ממשק-העל שלו, אלא אם כן:

·       הממשק מסתיר קבוע בקבוע אחר בעל שם זהה

·       הממשק מצהיר על מתודה מחדש.

ש: ההצהרה על מתודה בממשק מורכבת מהצהרת-המתודה ואחריה סוגריים {} צומדים ריקים:
אמת או שקר? אם שקר, הסבר מדוע.

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

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

ת: שקר. לא ניתן להשתמש ב‑private בהצהרה על חבר בממשק.

ש: כל המתודות, שמוצהרות בממשק, הן באופן בלתי מפורש public ו‑abstracrt: אמת או שקר?
אם שקר, הסבר מדוע.

ת: אמת.

ש: נוסף על הצהרה על מתודות, גוף הממשק יכול גם להגדיר קבועים. ערכי הקבועים, שמוגדרים בממשק, הם באופן בלתי מפורש public, static ו‑final: אמת או שקר? אם שקר, הסבר מדוע.

ת: אמת.

ש: השימוש בממשק נעשה על ידי הגדרת מחלקה, שמרחיבה ( extends ) את הממשק באמצעות שמו: אמת או שקר? אם שקר, הסבר מדוע.

ת: שקר. השימוש בממשק נעשה על ידי הגדרת implement, שמשמשת (ולא extend) בממשק באמצעות שמו.

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

ת: אמת.

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

ת: אמת.

ש: כאשר מתודה משתמשת בממשק, מותר לה להגדיר רק את המתודות שהוצהרו בממשק:
אמת או שקר? אם שקר, הסבר מדוע.

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

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

ת: ליצור אובייקט חדש מהטיפוס של הממשק.

ש: הסבר במילים שלך, את "השורה התחתונה" מבחינת התועלת של השימוש בממשקים.

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

ש: כתוב תוכנית העונה על הדרישות הבאות.

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

מַקֵם את הגדרות הממשקים שלך בקבצים בשם SampProg23Intfc1.java ו‑SampProg23Intfc2.java.

הממשק בשם SampProg23Intfc2.java מכיל שני קבועים בשם pi ו‑intConstant, שערכיהם 3.14 ו‑123, בהתאמה.

הממשק בשם SampProg23Intfc1.java מכיל הצהרות על set() ו‑get(). set()  מקבלת ערך int ומחזירה void.
 get() אינה מקבלת כלום ומחזירה int.

השתמש בשני הממשקים ב‑ClassA וב‑ClassB.

הגדר ב‑ClassA מתודה בשם show(), שאינה מוצהרת באף אחד מהממשקים.

המחש את העובדה, שהצבעה מהטיפוס של הממשק אינה יכולה לשמש להפעלת המתודה show().

/*File SampProg23.java from lesson 46
Copyright 1997, R.G.Baldwin
Without viewing the solution that follows, write a Java
application that illustrates the use of an interface.

Put your interface definitions in the files named 
SampProg23Intfc2.java and SampProg23Intfc1.java.

The interface named SampProg23Intfc2 contains two 
constants named pi and intConstant with values of 3.14
and 125 respectively.

The interface named SampProg23Intfc1 contains 
declarations for set() and get(). set() receives an int 
and returns void.  get() receives nothing and returns 
an int.

Implement both interfaces in ClassA and ClassB.

Implement different versions of set() and get() 
in ClassA and ClassB.

Define a show() method in ClassA that is not declared in
either interface.

Illustrate that a reference of the interface type cannot
be used to invoke the show() method.

The output from running the program should be (line breaks
were manually inserted to force the mater to fit the 
narrow format):
  
Instantiate objA of type ClassA, then set, and show data.
In set() method for classA, using pi: 12.28
In show() method for ClassA, data = 12.28

Assign objA to ref var of type SampProg23Intfc1 named 
objAA.
Invoke set() method on objAA to modify the data.
In set() method for classA, using pi: 24.56
Invoke get() method on objAA to display the modified data.
objA data = 24

Instantiate object of type ClassB named objB.  Assign
 the ref to a type SampProg23Intfc1 ref var.
Invoke its set() method to store some data.
In set() method for classB, using intConstant: 1375
Invoke its get() method to display the data.
objB data = 1375

Successfully assign objA to objB and display objB
objB data = 24

Invoke set() method on objAA to modify its data.
In set() method for classA, using pi: 98.24
Successfully assign objAA to objB and display objB
objB data = 98

Restore objB to its original type and value.
In set() method for classB, using intConstant: 1375
Successfully assign objB to objAA and display objAA
objAA data = 1375

Attempt to assign objB to objA fails because
  "Explicit cast needed to convert SampProg23Intfc1 to 
   ClassA."

Attempt to invoke show() method of objAA fails because
"Method show() not found in interface SampProg23Intfc1".
End of program.  

**********************************************************/

class ClassA implements SampProg23Intfc2,SampProg23Intfc1{
  double data;
  
  //Define versions of set() and get() appropriate to 
  // ClassA
  public void set(int inData){
    data = (double)inData*pi;//note use of pi
    System.out.println(
      "In set() method for classA, using pi: "+data);
  }//end set()
  
  public int get(){
    return (int)data;
  }//end get()
  
  //Define a show method for ClassA not declared 
  // in interface SampProg23Intfc1
  void show(){
    System.out.println(
      "In show() method for ClassA, data = " + data);
  }//end show() method
}//end ClassA
//=======================================================//
class ClassB implements SampProg23Intfc2,SampProg23Intfc1{
  int data;
  
  //Define versions of set() and get() appropriate to 
  // ClassB
  public void set(int inData){
    data = inData*intConstant;//note use of intConstant
    System.out.println(
      "In set() method for classB, using intConstant: "
        + data);
  }//end set()
  
  public int get(){
    return data;
  }//end get()
}//end ClassB
//=======================================================//
class SampProg23{
  public static void main(String[] args){
    System.out.println(
      "Instantiate objA of type ClassA, then set, and "
      + "show data.");
    ClassA objA = new ClassA();
    objA.set(2);
    objA.show();    
  
    System.out.println(
      "\nAssign objA to ref var of type SampProg23Intfc1 "
      + "named objAA.");
    SampProg23Intfc1 objAA = objA;
    System.out.println(
      "Invoke set() method on objAA to modify the data.");
    objAA.set(4);  
    System.out.println(
      "Invoke get() method on objAA to display the "
      + "modified data.");
    System.out.println("objA data = " + objAA.get());
    
    System.out.println(
      "\nInstantiate object of type ClassB named objB.  "
      + "Assign\n"
      + " the ref to a type SampProg23Intfc1 ref var.");  
    SampProg23Intfc1 objB = new ClassB();
    System.out.println(
      "Invoke its set() method to store some data."); 
    objB.set(11);
    System.out.println(
      "Invoke its get() method to display the data.");
    System.out.println("objB data = " + objB.get());

    System.out.println(
    "\nSuccessfully assign objA to objB and display objB");
    objB = objA;
    System.out.println("objB data = " + objB.get());

    System.out.println(
    "\nInvoke set() method on objAA to modify its data.");
    objAA.set(16);    
    System.out.println(
    "Successfully assign objAA to objB and display objB");
    objB = objAA;
    System.out.println("objB data = " + objB.get());
    
    System.out.println(
      "\nRestore objB to its original type and value.");
    objB = new ClassB();//objB already defined as type 
                        // SampProg23Intfc1
    objB.set(11);
    System.out.println(
    "Successfully assign objB to objAA and display objAA");
    objAA = objB;
    System.out.println("objAA data = " + objAA.get());

    System.out.println(
    "\nAttempt to assign objB to objA fails because\n"
      + "  \"Explicit cast needed to convert "
      + "SampProg23Intfc1 to ClassA.\"");
    //statement removed by making it a comment
    //objA = objB; 
    
    System.out.println(
      "\nAttempt to invoke show() method of objAA fails "
        + "because\n"
      + "\"Method show() not found in interface "
      + "SampProg23Intfc1\".");
    //statement removed by making it a comment
    //objAA.show();
    
    System.out.println("End of program.");

  }//end main
}//end class SampProg23

הגדרת ממשק עבור תוכנית SampProg23.java.

המחשה של שימוש בממשק.

/*File SampProg23Intfc1.java from lesson 46
Copyright 1997, R.G.Baldwin
Interface definition used to support SampProg23.java
Illustrates use of interface.
*/

public interface SampProg23Intfc1{
  void set(int inData);
  int get();
}//end interface SampProg23Intfc1.java
//==================================================

קובץ ממשק עבור קובץ SampProg23.java.

המחשה של שימוש בממשק.

/*File SampProg23Intfc2.java from lesson 46
Copyright 1997, R.G.Baldwin
Interface file to support File SampProg23.java
Illustrates use of interface.
*/

public interface SampProg23Intfc2{
  public final double pi = 6.14;
  public final int intConstant = 125;
}//end interface SampProg23Intfc2
//=============================================