שאלות סיכום

ש: האם מערכים ומחרוזות ב‑Java הם אובייקטים אמיתיים? אם לא, הסבר מדוע לא.

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

ש: קל מאוד לכתוב מחוץ לגבולות של מחרוזת או מערך ב‑Java: אמת או שקר? אם שקר,
הסבר מדוע.

ת: שקר. ב‑Java קיימים טיפוס מערך אמיתי וטיפוס String אמיתי בעלי תכונות שמגינות מפני כתיבה מחוץ לגבולות הזיכרון שהוקצה למחרוזת או למערך.

ש: ב‑Java עליך להצהיר על מערך לפני שתוכל להשתמש בו. בהצהרה על המערך,

עליך לספק שתי פיסות מידע חשובות. מהן?

ת: בהצהרה על מערך עליך לספק את:

·       שם המערך

·       טיפוסי הנתונים שיאוחסנו בו

ש: הבא קטעי קוד שימחישו שני תחבירים שונים, שבאמצעותם ניתן להצהיר ב‑Java על מערך מטיפוס int ?

ת: ב‑Java ניתן להצהיר על מערך באמצעות שני תחבירים שונים, כמו בדוגמה הבאה:

int[] myArray;
int myArray[];

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

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

int[] myArray = new int[15];
int myArray[] = new int[25];

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

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

int[] myArray;
myArray = new int[25];

ש: האם אינדקסים של מערך ב‑Java מתחילים תמיד ב‑1? אם לא, הסבר.

ת: לא. אינדקסים של מערך ב‑Java תמיד מתחילים ב‑0.

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

ת: כל המערכים ב‑Java הם בעלי המאפיין length, שניתן לגשת אליו כדי לקבוע את מספר האיברים שבמערך, כפי שנראה בדוגמה הבאה:

for(int cnt = 0; cnt < myArray.length; cnt++) 
  myArray[j] = j;

ש: אילו טיפוסי נתונים ניתן לאחסן במערך ב‑Java ?

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

ש: האם, כמו בשפות אחרות, במערך רב-מימדי ב‑Java כל המערכים המשניים חייבים להיות בעלי גודל זהה? אם לא, נמק את תשובתך. הבא קטע קוד להמחשת תשובתך או הפנייה לתוכנית דוגמה ב‑Baldwin’s Java Tutorial שתמחיש זאת.

ת: לא. ניתן ליצור ב‑Java מערכים רב-מימדיים, שאפשר לראות אותם כמערך של מערכים.
עם זאת, המערכים המשניים אינם חייבים להיות כולם בעלי גודל זהה. ראה את התוכנית בשם array01.java שבשיעור Java028.html. בתוכנית זו מוצהר ונוצר מערך דו-מימדי מטיפוס integer כאשר הגודל הראשי (גודלו של המימד הראשון) הוא 3.
גודלם של המימדים המשניים (גודלו של כל תת-מערך) הם 2, 3 ו‑4, בהתאמה.

ש: האם, כמו בשפות אחרות, עליך להצהיר ב‑Java על גודלו של המימד המשני בעת ההצהרה על מערך דו-מימדי? אם לא, נמק את תשובתך. הבא קטע קוד להמחשת תשובתך או הפנייה לתוכנית דוגמה ב‑Baldwin’s Java Tutorial שתמחיש זאת.

ת: לא. בהצהרה על מערך דו-מימדי ב‑Java, אין זה הכרחי להצהיר גם על גודלו של המימד המשני. ניתן לדחות את ההצהרה על גודלו של כל תת-מערך למועד מאוחר יותר, כפי שממחישה התוכנית בשם array01.java שבשיעור Java028.html.

ש: Java מאפשרת לערוך השמה של מערך אחד לאחר. הסבר מה קורה כשאתה עושה זאת. הבא קטע קוד להמחשת תשובתך או הפנייה לתוכנית דוגמה ב‑Baldwin’s Java Tutorial שתמחיש זאת.

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

ש: תאר בקצרה את המושג הכללי מחרוזת, וציין את שמותיהן של שתי מחלקות ב‑Java שנועדו לשימוש עם מחרוזות?

ת: מחרוזת נחשבת בדרך כלל כרצף תווים שמאוחסנים בזיכרון ושניתן לגשת אליהם כאל יחידה אחת. Java משתמשת במחרוזות באמצעות שתי מחלקות הקרויות String ו‑StringBuffer.

ש: מהו התחביר הקיים ב‑Java לציון מחרוזת ליטראלית? הבא קטע קוד להמחשת תשובתך.

ת: המהדר של Java יחשיב סדרת תווים המוקפים במירכאות כמחרוזת ליטראלית, כמו בקטע הקוד הבא:

"This is a literal string in Java."

ש: הסבר את ההבדל בין אובייקטים מטיפוס String ואובייקטים מטיפוס StringBuffer.

ת: אובייקטים מטיפוס String אינם ניתנים לשינוי מרגע שנוצרו. באובייקטים מטיפוס StringBuffer ניתן להשתמש על מנת ליצור ולטפל בנתוני תווים בזמן ביצוע התוכנית.

ש: הבא קטע קוד שימחיש כיצד לחבר מחרוזות ב‑Java.

ת: Java תומכת בחיבור מחרוזות באמצעות האופרטור המועמס +, כפי שניתן לראות בקטע הקוד הבא:

"My variable has a value of " + myVar + " at this point in the program."

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

ת: ההוראה הבאה מצהירה ויוצרת מערך של הצבעות על שני אובייקטים מטיפוס String

String[] myArrayOfStringReferences = new String[2];

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

myArrayOfStringReferences[0] = new String(
  "This is the first string.");
myArrayOfStringReferences[1] = new String(
  "This is the second string.");

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

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

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

הצג הודעת סיום שבה יופיע שמך.

/*File SampProg10.java from lesson 28
Copyright 1997, R.G.Baldwin

Without reviewing the solution that follows, write a Java
application that illustrates the creation and manipulation 
of a two-dimensional array with the sub arrays being of 
different lengths.

Also cause your application to illustrate that an attempt
to access an array element out of bounds results in an 
exception being thrown.  Catch and process the exception.

Display a termination message with your name. 
**********************************************************/
class SampProg10 { //define the controlling class
  public static void main(String[] args){ //define main 
    //Declare a two-dimensional array with a size of 3 on 
    // the primary dimension but with different sizes on 
    // the secondary dimension.
    //Secondary size not specified
    int[][] myArray = new int[3][];
    myArray[0] = new int[2];//secondary size is 2
    myArray[1] = new int[3];//secondary size is 3
    myArray[2] = new int[4];//secondary size is 4

    //Fill the array with data
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < myArray[i].length; j++){
        myArray[i][j] = i * j;
      }//end inner loop
    }//end outer loop

    //Display data in the array
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < myArray[i].length; j++){
        System.out.print(myArray[i][j]);
      }//end inner loop
      System.out.println();
    }//end outer loop

    //Attempt to access an out-of-bounds array element
    try{
      System.out.println(
                  "Attempt to access array out of bounds");
      myArray[4][0] = 7;
    }catch(ArrayIndexOutOfBoundsException e){
      System.out.println(e);
    }//end catch
   
    System.out.println("Terminating, Dick Baldwin");     

  }//end main
}//End SampProg10 class.  Note no semicolon required