השוואה בין Java ו – C++
- מבוא
- הקדמה
- דימיון ושוני
מבוא
סטודנטים בקורס הקדמה לתכנות Java אחראים לידיעת והבנת כל החומר בשעור זה
(חוץ מנושאים ספציפיים ב – C++).
הנושאים הספציפיים ב – C++ מוצעים כחומר משלים לטובת אלו שמכירים כבר
C++ ומבצעים הסבה ל – Java.
שעור זה בעיקרו מתוכנן לקריאה, והינו כללי, לכן לא נעשה כל מאמץ להתאימו לגרסת JDK כלשהי.
הקדמה
שיעור זה יציג את התכנות בשפת Java על-ידי הצגת מקצת מן הדומה והשווה בין Java ל‑++C.
מילות פתיחה אודות Java ו‑++C
נא עיין במבוא, הדן בקשר שבין Java ו‑++C, בכל הנוגע לחומר הלימוד בקורס זה. התלמידים בכיתות ה‑Java של פרופ' בולדווין אינם נדרשים, עקרונית, לכל ידע בשפת ++C.
דימיון ושוני
רשימה זו של הדומה והשווה מבוססת בעיקר על:
The Java Language Environment, A White Paper by James Gosling & Henry McGilton hppt://java.sun.com/doc/language_environment
וכן הספר, העומד לצאת לאורThinking in Java, by Bruce Eckel , hppt://www.EckelObjects.com/ .
אלה, מכל מקום, הם ה‑URLs הנכונים לזמנו. יש להביא בחשבון, שהרשת היא סביבה דינאמית וה‑URLs עשויים להשתנות בעתיד.
שפת Java אינה תומכת ב‑typedefs, defines או בעיבוד מוקדם (preprocessor).
היעדר עיבוד מוקדם, אין בנמצא אמצעים לכלול Header Files.
כיוון שאין ב‑Java עיבוד מוקדם, אין בה אף את המושגים #define marcos או קיום קבועים.
עם זאת, הצהרת קבועים נושאי-שמות נתמכת ב‑Java באמצעות שימוש במילת המפתח final.
Java אינה תומכת ב‑enums אך תומכת, כאמור, בקבועים נושאי-שמות.
Java תומכת במחלקות, אך לא ב‑structures או ב‑unions.
תוכניות ++C עצמאיות מחייבות כולן פונקציה בשם main ועשויות לכלול מספר רב של פונקציות אחרות, ובכלל זה פונקציות עצמאיות ופונקציות שהן איברים במחלקה. ב‑Java,
לעומת זה, אין פונקציות עצמאיות אלא רק פונקציות שהן איברי מחלקות, ואלה קרויות בדרך כלל מתודות. פונקציות גלובליות ונתונים גלובליים אינם מורשים ב‑Java.
כל המחלקות ב‑Java יורשות בסופו של דבר ממחלקת Object. זהו שינוי משמעותי ביחס ל‑++C, שבה ניתן ליצור עצי הורשה שאינם קשורים זה לזה לחלוטין.
כל הגדרות הפונקציות או המתודות ב‑Java נכללות במסגרת הגדרת המחלקה.
עבור מתכנתי ++C הן עשויות להיראות בהגדרות פונקציות inline, אלא שאין זה כך.
Java אינה מאפשרת למתכנת לבקש להפוך פונקציה לפונקציית inline, על כל פנים, לא ישירוֹת.
++C ו‑Java תומכות שתיהן בפונקציות או מתודות מחלקה (סטטיות), שניתן לקרוא להן בלא הצורך ליצור אובייקט של המחלקה.
מילת המפתח interface ב‑Java משמשת ליצירת שווה הערך של מחלקת בסיס מופשטת,
המכילה רק הצהרות על מתודות וקבועים. משתנים שהם איברי נתונים או מתודות אינם מורשים.
(גם ב‑Java ניתן ליצור מחלקות בסיס מופשטות אמיתיות). מושג ה‑interface אינו נתמך ב‑++C.
Java אינה תומכת בירושות מרובות. תכונת ה‑interface מספקת, בהיקף מוגבל, לתוכניות Java את התכונות הרצויות של ירושות מרובות, ללא חלק מן הבעיות הכרוכות בכך.
אף על פי ש‑Java אינה תומכת בירושות מרובות, הירושה הבודדת ב‑Java דומה למדי לזו
שב ‑ ++C, אם כי אופן היישום של הירושה שונה משמעותית, במיוחד במה שנוגע לשימוש בבנאים בתוך שרשרת הירושה.
נוסף על מגדירי-הגישה המוקדשים לאיברים הבודדים של כל מחלקה, ++C מאפשרת למתכנת לספק מגדיר-גישה נוסף בירושות מתוך מחלקה. מושג זה אינו נתמך ב‑Java.
Java אינה תומכת בפקודת goto (אם כי goto היא מילה שמורה). עם זאת, היא תומכת בפקודות break ו‑continue, תכונה שאינה נתמכת ב‑++C. במספר מצומצם של מצבים, ניתן להשתמש בפקודות break ו‑continue במקום להשתמש בפקודת goto.
Java אינה תומכת בהעמסת אופרטורים. Java אינה תומכת בהמרות טיפוס אוטומטיות (אלא במקרים בטוחים בלבד).
בניגוד ל‑++C, יש ב‑Java טיפוס String, ואובייקטים מטיפוס זה הינם אימוטביליים (אינם ניתנים לשינוי). מחרוזות הנתונות בין מירכאות מומרות אוטומטית לאובייקטֵי String.
ב‑Java קיים גם טיפוס ה‑StingBuffer. אובייקטים מטיפוס זה הינם ניתנים לשינוי, והשפה מספקת מיגוון של שיטות לטיפול במחרוזות.
בניגוד ל‑++C, Java מספקת מערכים אמיתיים כאובייקטים ממחלקה-ראשונה. איבר length מאפשר לך לדעת את גודלו של המערך. חריגה נזרקת כאשר ישנו ניסיון לגשת למערך מחוץ לגבולותיו.
כל המערכים נוצרים בזיכרון הדינמי, ומורשת הַשָׂמַה של מערך אחד למערך אחר. ואולם, השמה מסוג זה היא למעשה שתי הצבעות למערך אחד ויחיד, ועל כן, שינוי ערכו של איבר במערך אחד, משנה את ערכו בשני המערכים.
בניגוד ל‑++C, העובדה שבזיכרון הדינמי יש שני מחוונים או שתי הצבעות לאובייקט יחיד, אינה מהווה בהכרח בעיה (אם כי עלולה לגרום לבלבול מסוים). ב‑Java הזיכרון הדינמי מושבח אוטומטית,
אולם רק לאחר שכל ההצבעות לזיכרון זה הופכות ל‑NULL או חדלות להתקיים.
לכן, בניגוד ל‑++C, הזיכרון הדינמי המוקצב אינו הופך לבלתי-תקף כל עוד משתנה הצבעה כלשהו מצביע אליו.
Java אינה תומכת במחוונים (על כל פנים, אינה מאפשרת למתכנת לשנות את הכתובת הכלולה בהם או לבצע עליהם פעולות אריתמטיות). הצורך במחוונים נמנע בחלקו הגדול באמצעות קיום טיפוסים עבור מערכים ומחרוזות. לדוגמה, ההצהרה על המחוון char* ptr, שמרבים להשתמש בה ב‑++C לצורך הצבעה על התו הראשון ב"מחרוזת" המסתיימת ב‑NULL, אינו נחוצה ב‑Java, משום שב‑Java מחרוזת היא אובייקט אמיתי.
הגדרת מחלקה ב‑Java מזכירה למדי את זו ב‑++C, אלא שהיא אינה מסתיימת בנקודה-פסיק.
כמו כן, הצהרה מוקדמת על הצבעות, הנדרשת לעתים ב‑++C, אינה נדרשת ב‑Java.
האופרטור scope resolution (::), הדרוש ב‑++C, אינו קיים ב‑Java. הנקודה משמשת על מנת ליצור את כל ההצבעות המותרות. כמו כן, כיוון שאין מחוונים, אופרטור המחוון (<‑), שבו משתמשים ב‑++C, אינו דרוש ב‑Java.
ב‑++C, הקריאה לאיברי נתונים ופונקציות סטטיים נעשית תוך שימוש בשם המחלקה ובשם האיבר הסטטי הקשור באופרטור scope resolution. ב‑Java משמשת לצורך זה הנקודה.
בדומה ל‑++C, גם ב‑Java ישנם טיפוסים פרימיטיביים כגון, int, float וכו'. אך בניגוד ל‑++C,
הגודל של כל הטיפוסים הפרימיטיביים הוא זהה, ואינו תלוי בפלטפורמה.
ב‑Java לא קיים טיפוס unsigned integer. הדרישות לטיפוסים ב‑Java הן מחמירות בהרבה מאלו שב‑++C.
בניגוד ל‑++C, Java מספקת טיפוס בוליאני אמיתי.
ב‑Java ביטויי תנאי נדרשים לקבל ערך בוליאני, ולא מספר שלם כמו ב‑++C.
פקודות כגון if (x+y)... אינן מורשות ב‑Java משום שביטוי התנאי אינו מסתכם בערך בוליאני.
טיפוס char ב‑++C הוא בן 8‑סיביות, אשר ממופה באוסף התווים ASCII (או extended ASCII). טיפוס char ב‑Java הוא בן 16‑סיביות, ומשתמש באוסף התווים Unicode (הערכים 0-127 ב‑Unicode תואמים לאלה שב‑ASCII). למידע על אוסף התווים Unicode,
ראה hppt://www.stonehand.com/unicode.html.
בניגוד ל‑++C, האופרטור << ב‑Java הוא היסט "מסומן" של סיביות ימינה, ומכניס את סיבית הסימן במקום הסיבית שהתפנתה. ב‑Java קיים גם האופרטור <<<, אשר מכניס אפסים במקום הסיביות שהתפנו.
++C מאפשרת יצירת משתנים או אובייקטים מכל הטיפוסים הן בעת ההידור בזיכרון הסטטי,
והן בעת ההפעלה בזיכרון הדינמי. אולם, ב‑Java כל המשתנים של טיפוסים פרימיטיביים נדרשים להיווצר בעת ההידור, ואילו כל האובייקטים בזיכרון הדינמי נוצרים בעת ההפעלה.
קיימות מחלקות עוטפות לכל הטיפוסים הפרימיטיביים למעט byte ו‑short, על מנת שניתן יהיה ליצור אותם כאובייקטים בזיכרון הדינמי בעת ההפעלה.
++C מחייבת הצהרה על מחלקות ופונקציות בטרם השימוש בהן. ב‑Java, אין זה הכרחי.
סוגיות namespace, הנפוצות ב‑++C, מטופלות ב‑Java באמצעות הכללת הכול בתוך מחלקה, ואיסוף המחלקות לתוך חבילות (packages).
++C דורשת מהמתכנת להצהיר מחדש על איברי נתונים סטטיים מחוץ למחלקה.
Java אינה דורשת זאת.
ב‑++C, אם לא אִתחַלת במפורש משתנים של טיפוסים פרימיטיביים, הם יכילו זבל.
אף על פי שניתן לאתחל משתנים מקומיים של טיפוסים פרימיטיביים בהצהרה, איברי הנתונים הפרימיטיביים של מחלקה אינם ניתנים לאתחול בעת הגדרת המחלקה ב‑++C.
ב‑Java ניתן לאתחל איברי נתונים פרימיטיביים בעת הגדרת המחלקה. כמו כן, ניתן לאתחל אותם בבנאי. אם הם אינם מאותחלים על ידי המתכנת, הם מאותחלים כ‑0 (או שווה ערך) אוטומטית.
בדומה ל‑++C, Java תומכת בבנאים שניתן להעמיסם. כמו ב‑++C, אם המתכנת אינו מספק את הבנאי, מסופק בנאי של ברירת מחדל. אם המתכנת מספק את הבנאי, בנאי ברירת המחדל אינו מסופק אוטומטית.
כל האובייקטים ב‑Java מועברים באמצעות הצבעות, דבר זה פוטר מן הצורך בשימוש בבנאי העתקה המשמש ב‑++C.
ב‑Java אין שמדנים. זיכרון בלתי-מנוצל מוחזר למערכת ההפעלה באמצעות אוסף-האשפה, המופעל בתהליכון שונה מאשר התוכנית הראשית. דבר זה גורם לשלל שינויים עדינים אך משמעותיים ביותר בין Java ל‑++C.
כמו ++C, Java מאפשרת להעמיס פונקציות. אולם, ערכי ברירת המחדל אינם נתמכים ב‑Java.
בניגוד ל‑++C, Java אינה תומכת ב‑templates. משום כך אין ב‑Java פונקציות או מחלקות כלליות.
בניגוד ל‑++C, מספר מחלקות של מבנֵי נתונים נכללות בגירסה ה"סטנדרטית" של Java. למעשה,
הן נכללות בתוך ספריית המחלקות הסטנדרטית אשר מופצת יחד עם ה‑Java Development Kit
(JDK).
לדוגמה, הגירסה הסטנדרטית של Java מספקת את המחלקות Vector ו‑
גולשים מקוונים: 6