מודל ההכלה - מחלקות פנימיות

ישנם כמה סוגי מחלקות אותן ניתן להגדיר בתוך מחלקה אחרת:

• מחלקות סטטיות.
• מחלקות חברות.
• מחלקות מקומיות.
• מחלקות אנונימיות.

מחלקה סטטית

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

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

public class A { public static void main(String[] args) { Father f = new Father(); Father.son s = new Father.Son(); } }

כלומר, יצירת עצם מסוג מחלקת Son מתבצעת תוך שימוש במרחב השמות של מחלקת Father, ש Son מוכלת בתוכה.

מחלקה חברה

חריגות

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

1. זריקת החריגה - הפונקציה תצהיר בהתחלה שהיא מתעלמת מטיפול בשגיאות, ע"י שימוש בהצהרת throws Exception. לדוגמא:
   

   public void func (int x) throws Exception { . . . }

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

   try { . . . } catch(IOException ioe) { . . . } catch(Exception e) { . . . }

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

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

try { . . . } catch(Exception e) { . . . } finally { . . . }

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

• Error - שגיאה חמורה. בד"כ מסיימת את ריצת התוכנית.
• Exception - חריגה, שגיאה קלה. בד"כ תטופל והתוכנית תמשיך לרוץ.

מחלקת האם של שתי המחלקות היא מחלקת Throwable שיש לה פונקציות אבחון כמו ( )printStackTrace - שמחזירה את מחסנית הקריאות, ( )getMessage, שתיתן תיאור של החריגה שהתגלתה, ועוד.

אמנם אמרנו שאין להשאיר חריגות לא מטופלות, אבל יש שגיאות שהמכונה המדומה (JVM) תטפל בהן בזמן הריצה. למשל:

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

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

מחלקות אוסף - Collection class

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

• Vector - מערך ללא הגבלת גודל.
• Stack - מחסנית.
• Hashtable - טבלה שמקשרת מפתח מסוים לערך מסוים אחר (למשל טבלה שתקשר את אותיות הא"ב עם הערך המספרי שלהם).

וקטור - Vector

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

• ( )addElement - הוספת איבר למערך.
• ( )elementAt - קבלת איבר שנמצא במקום מסוים במערך.
• ( )setElementAt - הכנסת איבר למקום מסוים במערך.
• ( )indexOf - החזרת המקום של איבר מסוים במערך (אם קיים).
• ( )removeAllElements - איפוס הווקטור.

דוגמא:

התוכנית תדפיס את ימי השבוע.

טבלה - Hashtable

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

• ( )put - הוספת מפתח + ערך נוסף לטבלה.
• ( )get - קבלת ערך בעזרת מפתח.
• ( )remove - הסרת מפתח בטבלה.
• ( )size - קבלת מספר האיברים בטבלה.

דוגמא:

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

מחסנית - Stack

מחלקת מחסנית - עיקרון last in first out) lifo).
הפונקציות הבסיסיות של המחלקה הן:

• ( )push - דחיפת איבר חדש למחסנית.
• ( )pop - הוצאת איבר מהמחסנית.
• ( )peek - "הצצה" מהו האיבר בראש המחסנית.
• ( )search - חיפוש איבר במחסנית.
• ( )empty - בדיקה אם המחסנית ריקה.

דוגמא:

התוכנית תדפיס את תוכן המחסנית.

קלט / פלט

לטיפול בפלט/קלט התקני (כלומר למסך וממנו), השתמשנו עד כה ב 3 עצמים של המחלקה System, שהיא מחלקת המערכת בג'אווה, ותפקידה לטפל במאפייני המערכת.

1. out - לטיפול בפלט התקני.
2. in - לטיפול בקלט התקני.
3. err - לטיפול בשגיאות.

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

• סוג המידע - בתים/תוים.
• מה מתבצע - מ/לאיזה מדיה הק/פ מגיע (מקלדת זכרון קבצים וכו'), ומהן הפעולות שמתבצעות בק/פ.

זרמי ק/פ עפ"י יצוג מדיה

זרמי ק/פ המבצעים עיבוד על הנתונים

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

פלט פשוט ע"י printWriter

הכרנו כבר את עצם הפלט התקני System.out. אפשר להעמיס אותו, בעזרת שימוש בפונקציה ()print.
נראה דוגמא:

int s[] = {10,11,12,13,14,15}; PrintWriter out = new PrintWriter(System.out); for(int i=0;i<s.length;i++) { out.print(s[i]); out.print('\t'); } out.close;

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

int s[] = {10,11,12,13,14,15}; PrintWriter out = new PrintWriter(new FileWriter("file.txt")); for(int i=0;i<s.length;i++) { out.print(s[i]); out.print('\t'); } out.close;

עכשיו התוכנית תדפיס את הפלט לקובץ file.txt.

קלט

נסביר קודם את המחלקה StringTokenizer.

StringTokenizer

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

הסבר:
העצם st מקבל 3 פרמטרים:

• str - מחרוזת לפירוק
• delim - מפרידים.
  למשל: "," ";" וכיו"ב. כלומר, המחרוזת str תחולק לחלקים, תתי מחרוזות, עפ"י המפריד שנבחר (אם בחרנו פסיק, המחלקה תחלק את המחרוזת עפ"י הפסיקים שיש בה). ניתן להגדיר כמה מפרידים ואז הם יכתבו ברצף בתור הפרמטר delim. למשל: ";,." יגרום לחלוקת המחרוזת str עפ"י פסיקים, נקודה-פסיק, או נקודה.
• true/false - ערך true יחזיר גם את המפרידים (כלומר את הפסיק למשל) בתור תת מחרוזת.

פונקציות במחלקה

• ( )st.nextToken - תחזיר את חלק המחרוזת הבא. היא יכולה לקבל מפריד מסוים, ואז תחלק את החלק הבא רק עפ"י המפריד הספציפי, ולא עפ"י המפרידים שהועברו בבנאי.
• ( )st.hasMoreToken - מחזיר true/false אם הסתיימה חלוקת המחרוזת.

קלט ע"י BufferedReader

סדרתיות - שמירת עצמים ע"ג מדיות - serialization

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

• ( )writeObject - שמחלקת ObjectOutputStream לכתיבה למדיה.
• ( )readObject - שמחלקת ObjectInputStream לקריאה מהמדיה.

שמירה תעשה בשלבים הבאים:

1. פתיחת קובץ לכתיבה.
2. פתיחת זרם ObjectOutputStream על גבי הקובץ שפתחנו.
3. קריאה לפונקציה ( )writeObject לכל עצם שמיועד לשמירה.
4. סגירת הקובץ.

שיחזור יעשה בשלבים הבאים:

1. פתיחת קובץ לקריאה.
2. פתיחת זרם ObjectInputStream על גבי הקובץ שפתחנו.
3. קריאה לפונקציה ( )readObject לכל עצם שמיועד לשמירה.
4. סגירת הקובץ.

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