פרק 1:

 

 

Let’s start

 

 

ההתחלה...

 

 

·           הקדמה           

·           applications ו- applets

·           ארגון המחלקות בpackages-

·           הכרות עם הjavadoc-

·           הjava Virtual Machine-

·           הGarbage Collector-

               

 

 

 

הקדמה

 

קצת היסטוריה…

 

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

 

בשנת 95, עם התפתחות ה-web, JAVA החלה לצבור תאוצה הודות לאפשרות לכתוב applets (תכניות JAVA קטנות אשר נשלחות מן השרת אל הדפדפן ופועלות בו).  

כיוון שתכניות אשר כתובות ב-JAVA יכולות לפעול בכל פלטפורמה (ובלבד שיותקן בה JVM – יוסבר בהמשך) ה-applets אפשרו את פיתוחם של אתרי אינטרנט מתוחכמים.

 

במהלך השנים האחרונות, אחוז השימוש ב-applet בפיתוחם של אתרי אינטרנט הלך ופחת. טכנולוגיות אחרות (כגון JavaScript, DHTML, FLASH, ASP ואחרות..) סיפקו את האפשרות לבצע חלק מן הפעולות, שבעבר ביצעו באמצעות applets,  בדרך זולה יותר (שכרם של מתכנתי JAVA גבוה יותר משכרם של מתכנתים בשפות אחרות) ולעתים גם יותר טובה וגם יותר מהירה. כך למשל, רוב האנימציה באתרי אינטרנט מפותחת כיום באמצעות FLASH, ולא באמצעות Java Applets כפי שהיה נהוג לפני מספר שנים. כיום, פיתוחם של Java Applets, לצורך אנימציה, רלוואנטי רק באותם מקרים שבהם מסתתרת מאחורי האנימציה תכנית מתוחכמת או באותם מקרים שבהם לא ניתן לקבל את האנימציה הנדרשת באמצעות FLASH או טכנולוגיות אחרות. יתר על כן, הופעתה של Visual J++  (גרסתה של Microsoft  ל-JAVA אשר זהה ל-Java רק באופן חלקי) והעובדה שמיקרוסופט ניצחה במלחמת הדפדפנים (רוב הדפדפנים כיום הם מסוג IE) תרמו גם הם לשימוש ההולך ופוחת ב-Java Applets.

 

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

 

ובכן,

 

אם השימוש ב-Java Applets רק הולך ופוחת, אז למה להשקיע זמן וללמוד JAVA ?

 

 

היתרונות של JAVA כשפת תכנות

 

       ü          אי תלות בפלטפורמה שעליה התכנית רצה
המטרה העיקרית שעמדה לנגד עיניהם של מפתחי השפה הייתה ליצור שפה אשר מאפשרת לכתוב את התכנית פעם אחת ולאחר מכן להריץ אותה  בכל מחשב מבלי לבצע שינויים.
קובץ קוד המקור של תכנית ב-JAVA מתורגם ל- JAVA BYTE CODE  שנשמר בקובץ ששמו זהה  (בדרך כלל) לשמו של קובץ קוד המקור, והסיומת שלו class. קובץ ה- class ניתן להרצה בכל מחשב הודות ל- JVM (Java Virtual Machine). ה- JVM היא תכנית שנכתבה במיוחד למערכת הפעלה מסוימת (קיימות גרסאות של ה- JVM  כמעט לכל מערכת הפעלה קיימת). תכנית זו מסוגלת לתרגם את קובץ ה-Java Byte Code (הקובץ עם הסיומת class) לשפת המכונה של המחשב שבו היא פועלת. בדרך זו מושגת אחידות שלא הייתה קיימת בשפות אחרות. ב C++ ניתן היה לכתוב תכנית במחשב אחד ולהריצה באחר רק לאחר ביצוע השינויים הדרושים ולאחריהם קומפילציה מחדש.
בדרך זו, ל-JAVA יש רמת תאימות גבוהה לא רק בכל הקשור ל-source code, אלא גם בכל הקשור לקובץ שמוכן להרצה.

 

 

 







       ü         קלות בפיתוחן של אפליקציות בתחום התקשורת
ב-JAVA קיימות מחלקות מוכנות אשר כוללות מתודות/פונקציות שמקלות על כתיבתן של תכניות אשר מתקשרות עם תכניות אחרות (במחשבים שונים).  המחלקות המוכנות ב-Java כוללות תמיכה במגוון רחב של פרוטוקולים (HTTP, TCP\IP, UDP, SMTP ואחרים).

       ü         מנגנוני הגנה מפני וירוסים
ל-JAVA קיימים מנגנונים רבים אשר מקטינים את הסכנות הקיימות בדמותם של ווירוסים מזיקים (“I LOVE YOU...”(.

       ü         שפה מודולרית
כיוון שתכנית ב-JAVA מורכבת ממחלקות, אופן השדרוג של תכניות ב-JAVA פשוט בהרבה מאופן השדרוג של תכניות אשר כתובות ב- C++. שדרוג תכנית ב-JAVA נעשה באמצעות החלפת מחלקה אחת באחרת.

       ü          שפה קלה ופשוטה ללמידה ולשימוש
כדי להשיג מטרה זו, התבססו בפיתוחה על C++.  C++ היא אחת השפות הפופולריות ביותר (נכון לשנות ה-90) ומשום הדמיון שיש בינה לבין JAVA, למתכנתי  C++ קל לעבור ל- JAVA. כללי התחביר כמעט זהים לחלוטין, ותפיסת תכנות מונחה העצמים ממשיכה להתקיים. כדי להקל על השימוש ב-JAVA הנושאים הבעייתיים שקיימים בC++ כגון עבודה עם מצביעים וטיפול בזיכרון שמוקצה באופן דינמי לא אומצו.
אחת הפעולות שמעיקות על כל מתכנת הוא כתיבת התיעוד לתכנית שכתב. מפתחי השפה חשבו על בעיה זו מראש, ופיתחו כחלק מהשפה את ה- javadoc. ה-javadoc היא תכנית שבעת הפעלתה על תכנית בכתובה ב-JAVA  היא יוצרת דפי HTML אשר מכילים תיעוד מפורט לתכנית עפ"י ההערות המתאימות שנשתלות בקוד המקור. ה-API שמשמש כ-help לכל מפתח ב-JAVA נוצר באמצעות הפעלת ה-javadoc על קבצי קוד המקור של המחלקות שיש ב-JAVA.

       ü          שפה שמצמצמת את האפשרות לבאגים
כדי שהשפה החדשה, אכן תאפשר לפתח תכניות עם מספר קטן ככל האפשר של באגים (באגים מצד המתכנת) הטיפול בהקצאת הזיכרון הדינמית הוצא מתחום אחריותו של המתכנת. ב-JAVA קיים רכיב בשם Garbage Collector אשר פועל כל הזמן במקביל לפעולת התכנית, ומשחרר את הזיכרון שהוקצה ושאין בו עוד שימוש. ב C++  האחריות לשחרר את הזיכרון שהוקצה באופן דינמי, כאשר אין בו עוד שימוש, מוטלת על המתכנת.
שיפור נוסף שבוצע ב JAVA הוא מניעת האפשרות לחרוג מגבולותיו של מערך. בעוד שבC++ ניתן לחרוג מגבולותיו של המערך מבלי שהתכנית תתריע על כך, ב-JAVA זה לא אפשרי. ניסיון לחרוג מגבולותיו של מערך ב-JAVA יגרום לשגיאה. שיפור נוסף שבוצע ב-JAVA הוא האפשרות לבצע הורשה יחידה בלבד (כל מחלקה יכולה לרשת ממחלקה אחת בלבד). לא ניתן לבצע הורשה מרובה ב-JAVA. האפשרות לבצע הורשה מרובה ב C++   גרמה, לא אחת, לתקלות קשות. תכנון נכון של המחלקות מתממש בהורשה יחידה בלבד. אם אינך יודע מהי הורשה, אל דאגה. באחד הפרקים הבאים נקדיש לנושא את תשומת הלב הראויה.
שיפור אחר שבוצע ב JAVA מצוי באופן ביצוע ה-casting (שינוי טיפוס של ערך). בעוד שב- C\C++ ערך מטיפוס כלשהו, אשר אמור לשנות את טיפוסו בעקבות השמתו למשתנה/פרמטר מטיפוס אחר, עובר casting באופן אוטומאטי גם כאשר שינוי הטיפוס עלול לגרום לשינוי בערך (השמה של ערך מספרי ממשי לתוך משתנה מטיפוס מספרי שלם) - ב-JAVA, ה-casting מתבצע באופן אוטומאטי רק כאשר אין כל סכנה לפגיעה בערך (השמה של ערך מטיפוס long לתוך משתנה מטיפוס int לא תעבור קומפילציה).

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

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

       ü          יכולות גרפיות משופרות
האפשרויות המגוונות ביצירת GUI (ממשק משתמש גראפי) באמצעות Java מציבים אותה בתור אחת השפות המתאימות ביותר ליצירת GUI (אם לא הטובה ביותר !).

       ü          קישוריות לטכנולוגיות אחרות
כיוון שתכנית ב-JAVA יכולה לפעול בכל פלטפורמה והודות לכך ש-JAVA כוללת מחלקות רבות מוכנות, קיימת האפשרות לשלב קוד Java עם טכנולוגיות רבות אחרות. כך למשל, ניתן לכתוב תכנית ב-JAVA אשר תתחבר לבסיס נתונים – כמעט מכל סוג – לרבות Access (באמצעות ODBC). אפשרויות אחרות כוללות את האפשרות לכתוב תכנית ב-Java שתשולב כ-ActiveX בתכנית אחרת שכתובה ב-Visual Basic. אין כל בעיה בכתיבת חלק מן המתודות/פונקציות שמוגדרות בתכנית לעשות שימוש בקטעי קוד אשר כתובים ב- C\C++.

       ü          תמיכה מובנית בUNICODE-
בעוד שתכניות אשר כתובות ב- C\C++ עושות שימוש בטבלת ה-ASCII (מסוגלת לתאר רק את האותיות באנגלית ואת האותיות של השפה המקומית שמותקנת במחשב – בישראל זוהי העברית), תכניות שכתובות ב-JAVA יכולות לעשות שימוש בטבלת ה-UNICODE אשר כוללת כ-65000 תווים לתיאור מרבית השפות בעולם ומרבית הסימנים הגרפיים אשר קיימים בתחומי המדעים השונים).

       ü          "מצעד הבאגים"

כבכל טכנולוגיה, גם ב-Java קיימים באגים. ההבדל באופן הטיפול בבאגים שקיימים ב-Java לעומת טכנולוגיות אחרות מצוי באופן השיתוף של המתכנתים בתהליך התיקון שלהם. בעוד שבאגים אשר קיימים ב-ASP, Visual J++, Visual C++, Visual Basic ובטכנולוגיות אחרות מתוקנים רק על ידי המפתחים של אותן טכנולוגיות, ב-Java הליך מציאת הבאג הדיווח עליו והצעת התיקון שלו יכולים להיעשות (וכך זה גם מתבצע) על ידי מפתחים מרחבי העולם. באתר המרכזי של Java, www.javasoft.co.il, קיים מדור שלם אשר מפרט באגים שדווח עליהם. אופן הטיפול המיוחד בבאגים שקיימים ב-Java  מתאפשר הודות לכך שכל קוד המקור של המחלקות שכבר הוגדרו (ויש הרבה הרבה הרבה מחלקות כאלה...) גלוי לעיניו של כל מפתח. קבצי קוד המקור של המחלקות הקיימות נגישים לכולם באופן חופשי.

       ü          פופולריות עצומה
הודות לפופולריות העצומה של השפה (לשם ההשוואה, בכל 6 שנות קיומה נכתבו עליה יותר ספרים משנכתבו על C++ אשר קיימת למעלה מ-10 שנים) מרבית המתכנתים מעדיפים לתכנת באמצעותה (במקום C++ ושפות אחרות). תכונה זו מקנה לחברות שמפתחות ב-Java יתרון תחרותי עסקי ברור על חברות אחרות אשר מעדיפות לפתח באמצעות שפות אחרות ופחות פופולריות כגון C++ ו- Visual Basic: מיטב המוחות עתיד להימצא – בשנים הקרובות-באותן חברות אשר ישכילו לפתח ב-Java.

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

 

במהדורות הבאות של הספר ייסקרו יתרונות נוספים...

 

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

 

 

מגוון השימושים שקיימים לשפה

 

בחלק זה ייסקרו מספר תחומים שבהם Java נותנת מענה:

 

 

טלוויזיה אינטראקטיבית JavaTV -

 

JAVA כוללת מחלקות מוכנות שיכולות לשמש לכתיבת תכניות אשר יפעלו בתוך מכשיר הטלוויזיה או בתוך הקופסה שתותקן מעליו (set top box). חברות רבות בעולם משתמשות ב-Java לצורך פיתוח בתחום זה: TOSHIBA, SAMSUNG, PHILIPS, SONY, MATSUSHITA ואחרות...  לאחרונה קיבל ה-DVB (Digital Video Broadcasting project) את ההחלטה להשתמש ב-Java לצורך פיתוחה של הטלוויזיה האינטראקטיבית. ה-DVB הנו גוף אשר מאגד בתוכו למעלה מ-250 חברות אלקטרוניקה/תקשורת גופי תקינה וספקיות תוכן מלמעלה מ-30 מדינות אשר התאגד מתוך מטרה לגבש במשותף את התקנים ואת הסטנדרטים לפעולתה של הטלוויזיה הדיגיטאלית. יתר על כן, SONY קיבלה, לאחרונה, את ההחלטה לשלב במכשירים מתוצרתה JVM וזאת מתוך כוונה שתכניות שתכתבנה ב-JAVA יפעילו אותם. החלטה זו התקבלה לאחר ש-SONY החליטה להימנע מלאמץ את הצעתה של Microsoft להתקין במכשיריה מערכת הפעלה מגרסה מיוחדת של Windows CE.

 

להלן מספר תמונות מתוך הדגמות פועלות של טלוויזיה אינטראקטיבית אשר עושה שימוש ב-Java:

 

 

 

 

 

 

 

 

 

 

דמיינו פרסומת שמופיעה בטלוויזיה תוך כדי הצגת כתובת הסניף הקרוב למקום המגורים ....

 

 

 

 

 

 

 

 

 


 

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

 

 

 

 

 

 

 

 

 

 

 

 


דמיינו את האפשרות לצפות בסדרת הטלוויזיה האהובה עליכם תוך צפייה בשערי המניות ...

 

 

 

 

 

 

 

 

 

 

 

 

 


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

 

 

 

 

 

 

 

 

 

 

 

 

 


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

 

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

 

 

 

JINI – המהפכה האמיתית

 

סקירה תופיע באחת המהדורות הבאות ...

 

 

 

גרפיקה תלת ממדית Java3D API -

 

סקירה תופיע באחת המהדורות הבאות ...

 

 

 

גרפיקה דו מימדית Java2D API -

 

סקירה תופיע באחת המהדורות הבאות ...

 

 

 

JavaCard – כתיבת תכניות ב-Java אשר יפעלו בכרטיסים זעירים

 

סקירה תופיע באחת המהדורות הבאות ...

 

 

 

קישור לבסיס נתונים - JDBC

 

סקירה תופיע באחת המהדורות הבאות ...

 

 

 

שילוב מולטימדיה – JMF (Java Media Framework)

 

סקירה תופיע באחת המהדורות הבאות ...

 

 

נושאים נוספים שטרם הוזכרו יופיעו – גם הם – במהדורות החדשות ...

 

 

 

 

סביבת הפיתוח JDK

 

כדי לתרום להגברת הפופולריות של השפה, נכון לזמן כתיבת הספר, ניתן להוריד בחינם מהאינטרנט את כל סביבת הפיתוח הבסיסית של השפה. לסביבת הפיתוח הבסיסית נהוג לקרוא בשמות JDK (Java Development Kit) ו- SDK (Software Development Kit).

בשנת 1995 הופיעה הגרסה הראשונה של JAVA, שנקראה בשם: JDK1.0. גרסאות תיקון אשר הוצאו לגרסה זו נקראו בשמות: JDK1.0.1, JDK1.0.2 ואילך ...

כעבור פרק זמן, הופיעה הגרסה השניה של JAVA, שנקראה בשם: JDK1.1. גם לגרסה זו פורסמו גרסאות תיקון אשר נקראו בשמות: JDK1.1.1, JDK1.1.2 ואילך...

בדצמבר 1998 הופיעה הגרסה השלישית של JAVA, שנקראה בשם JDK1.2. כיוון שבין גרסה זו לגרסה הקודמת חלו שינויים די רבים, שונה השם של JAVA לשם החדש: JAVA 2. גם בגרסה השלישית היו מספר גרסאות תיקון שנקראו, בדומה לגרסאות התיקון שהוצאו לגרסאות הקודמות בשמות: JDK1.2.1 וכו'...

במרץ 2000 הופיעה הגרסה הרביעית של JAVA, תחת השם JDK1.3. מרבית השינויים בין גרסה זו לגרסה הקודמת מתמקדים באופן פעולת ה-JVM. JDK1.3 כולל JVM יעיל באופן מיוחד.

 

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

 

הסביבות ויזואליות כוללות, בין היתר, את הסביבות הבאות:

Symantec’s Visual Café

JBuilder

VisualAge

JDeveloper

Forte

ואחרות…

 

Visual J++ איננה JAVA. השימוש ב-Visual J++  רלוואנטי רק כאשר מפתחים applets שאמורים לפעול ב-web מבלי שהגולש יידרש להתקין במחשבו את ה-Java Plugin.

 

 

The World Wide Web (www)

 

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

 

רשת ה-WWW (World Wide Wev) היא רשת וירטואלית שבנויה על בסיס רשת האינטרנט. ניתן לראות ברשת הזו מערכת של שרת-לקוח:

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

פרוטוקול התקשורת שמשמש את השרתים ואת הלקוחות ברשת ה-WWW הוא הפרוטוקול http.

 

 

טכנולוגיות אחרות

 

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

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

 

 

 

applications וapplets-

 

הקדמה

 

ב- JAVA  ניתן לזהות ארבעה סוגים עיקריים של תכניות:

1.                   Java Applications

2.                   Java Applets

3.                   Java Servlets

4.                   JSP

 

JSP דומה ל-ASP בכך שבשתי הטכנולוגיות מדובר בהשתלתן של שורות קוד בתוך מסמך ה-HTML אשר יבוצעו על ידי השרת ויוחלפו בתוצאה שתתקבל ובכך ייווצרו, למעשה, מסמכי HTML באופן דינאמי. ההבדל הוא שבעוד שב-ASP מדובר בשילובן של פקודות Script פשוטות, ב-JSP מדובר בשילובן של פקודות אשר נכתבות ב-JAVA, ועל כוחה של JAVA לעומת שפת סקריפט פשוטה אין כל צורך להרחיב. יתר על כן, בשימוש ב-JSP ניתן לעשות שימוש בכל אחד ממרכיביה החדשים של השפה (jdk 1.3) – להבדיל מ-applets אשר פועלים על פי מגבלותיו של הדפדפן  (כאשר הם פועלים בתוך Internet Explorer עליהם להיכתב על פי כלליה של Visual J++ וכאשר הם פועלים בתוך Netscape Nevigator עליהם לפעול על פי גרסת ה-JVM אשר מותקן בו).

 

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

 

הדיון ב-JSP וב-Servlets חורג מגבולות הדיון של ספר זה. הספר מתרכז ביסודותיה של השפה תוך התמקדות באופן כתיבתם של Java Applications ו- Java Applets.

 

תכניות מסוג Java Applications יכולות לפעול לבדן, וללא סיועו של הדפדפן. כל מה שצריך הוא interpreter מותקן במחשב (JVM שיתרגם את התכנית). כפי שניתן לפתח תכניות (stand alone) כגון WORD , EXCELL  ואחרות, כך גם ניתן לעשות זאת באמצעות Java.

 

תכניות מסוג Java Applets הן תכניות שניתן להריץ רק באמצעות הדפדפן (או באמצעות ה-appletviewer כפי שנראה בהמשך).  ה-applet מיועד להרצה מתוך מסמך HTML שבתוכו ישנה קריאה להפעלתו. הקריאה להפעלת ה-applet (או בשמו העברי: ישומון) משובצת במסמך ה-HTML בדומה לתמונה.

 

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

 

 

דוגמא לפיתוחו של Application

 

השלבים הטכניים הבסיסים ביותר בכתיבתו של Application הם:

1.                   להשיג עורך טקסט ולכתוב את קוד המקור של ה-Application.

       2.         באמצעות ה-JDK להדר את קוד המקור, ולקבל כתוצאה מכך קובץ שמכיל java byte code , ששמו זהה לשמו של קובץ קוד המקור אך הסיומת היא class.

                                                                 ההידור נעשה באמצעות תכנית ההידור ששמה: javac
על שם הקובץ להיות זהה בדיוק לשם המחלקה תוך מתן תשומת לב לאותיות גדולות וקטנות (המהדר רגיש לאותיות קטנות וגדולות).

       3.         באמצעות ה-interpreter ניתן להריץ את קובץ ה-java byte code שהתקבל.
           ההרצה נעשית באמצעות תכנית ההרצה שנקראת: java

 

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

שלב א' : כתיבת קוד המקור
בדומה ל C++, גם ב- JAVA התכנית מאורגנת בתוך מחלקות.
עם זאת, בעוד שב C++ התכנית מורכבת מקבצים שיכולים להכיל גם משתנים/פונקציות גלובאליות (פונקציות שלא שייכות לאף מחלקה), ב-JAVA כל המשתנים/פונקציות הקיימים/ות חייבות להיות שייכות למחלקה מסוימת.
דמיון נוסף בין שתי השפות הוא הצורך בקיומה של מתודה עיקרית בשם main, אשר בעצם הפעלתה האפליקציה מתחילה לרוץ. ה- main מהווה מעין נקודת התחלה לאפליקציה.
הפעל את עורך הטקסט שברשותך, וכתוב לתוך הקובץ החדש את התכנית הבאה:


//filename:HelloIsrael.java

 

//Copyright © 2000 Haim Michael & Zindell Publishing House, Ltd.

//All rights reserved. No part of the contents of this program may be

//reproduced or transmitted in any form or by any means without the

//written permission of the publisher.

 

 

class HelloIsrael

{

        public static void main(String args[])

        {

                System.out.println("Hello Israel !");

        }

}

 

בשמירת הקובץ חייבים לתת לו שם שזהה לשם המחלקה שמוגדרת בו (בהמשך נראה שכלל זה לא תמיד מחייב). הסיומת שנותנים לקובץ חייבת להיות : java.

במקרה זה, אנו נשמור את הקובץ תחת השם : HelloIsrael.java

 

שלב ב' : הידור קובץ קוד המקור וקבלת קובץ ה-java byte code
שמה של התכנית שמבצעת קומפילציה ב-JDK הוא: javac. כדי להפעילו מתוך סביבת העבודה DOS יש לכתוב את שם התכנית (javac) ומייד אחריו את שם הקובץ שרוצים להדר.

כך, למשל, כדי לבצע קומפילציה לקובץ HelloIsrael.java יש להקליד בשורת הפקודה:

javac HelloIsrael.java

ולהקיש ENTER.

ה- java compiler יוצר קובץ  חדש ששמו זהה לשמו של קובץ קוד המקור, והסיומת שלו class. הקובץ הזה מכיל למעשה את ה- java byte code.

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

כדי שהתכנית javac תפעל בהצלחה יש לוודא שהספרייה שמכילה אותה נמצאת ב-path של המחשב. אם קובץ קוד המקור מכיל יותר ממחלקה אחת, אז ה-javac ייצור יותר מקובץ אחד. הוא ייצור קבצים שמספרם כמספר המחלקות. כל מחלקה תתורגם ל-java byte code שיישמר בקובץ נפרד, אשר שמו זהה לשם של המחלקה והסיומת שלו היא class.

 

שלב ג' : הרצת התכנית
כדי להריץ את ה-application שנכתב יש להשתמש ב-interpreter, התכנית אשר מתרגמת את ה-java byte code לשפה שהמחשב מסוגל להבין. בסביבת העבודה של JDK קיימת התכנית java. הפעלתה מתוך שורת הפקודה של DOS וכתיבת שם הקובץ שרוצים להריץ מיד אחרי שמה תגרום לתכנית לעבוד. כדאי לשים לב לכך ששם הקובץ הוא, למעשה, גם השם של המחלקה שמהווה application (על שום שהיא מכילה מתודת main). אחרי המילה java יש לרשום את שם המחלקה בלבד, כלומר, את שם הקובץ שמכיל את ה-java byte code של אותה מחלקה (ללא הסיומת שלו). 

בדוגמא זו יש לרשום בשורת הפקודה:  

java HelloIsrael

ולהקיש ENTER.

כיוון שה-interpreter צריך גם לתרגם את ה-java byte code לשפת המכונה שעליה התכנית רצה, תכניות שכתובות ב-JAVA רצות לאט יותר.

התכנית java  נמצאת באותה ספריה שבה נמצאת התכנית  javac. יש לוודא שהספרייה הזו כלולה ב-path. אם התקנת SDK מגרסה 1.3 אז התכניות java ו-javac נמצאות בתיקיה c:\jdk1.3\bin ולכן יש לוודא שהיא מופיעה ב-path.

כפי שנראה בהמשך, ניתן להעביר אל התכנית משורת הפקודה (בדומה לתכניות שכתובות ב-C\C++ ) ערכים בעת הפעלתה.

 

דוגמא לפיתוחו של Applet

 

השלבים הטכניים הבסיסים ביותר ביצירתו של Java Applet הם:

       1.            להשיג עורך טקסט ולכתוב את קוד המקור של ה-Applet.

       2.            באמצעות ה-JDK להדר את קוד המקור, ולקבל כתוצאה מכך קובץ שמכיל java
byte code , ששמו זהה לשמו של קובץ קוד המקור אך הסיומת היא class.
ההידור יעשה בדומה להידור ה-application, באמצעות התכנית javac.

       3.            באמצעות עורך טקסט לכתוב קובץ HTML מתאים אשר יכיל קריאה להפעלת ה-applet.

       4.            הרצת ה-applet באמצעות ה-appletviewer או באמצעות העלאת מסמך ה-HTML בדפדפן.

 

כעת ניגש לכתיבת היישומון הראשון שלנו:

שלב א' : כתיבת קוד המקור
בדומה לכתיבת ה-application, גם ה-applet יאורגן במחלקות. רוב ה-applet מכילים את שתי שורות ה-import שמופיעות בדוגמה לעיל. ב-applet אין מתודת main כמו שיש ב-application. רוב ה- applets מכילים את המתודה paint אשר גורמת להופעת הטקסט, ולהופעת צורות גרפיות אחרות על המסך.  מחלקה שמתעתדת להיות יישומון (applet) חייבת לרשת מהמחלקה Applet. אנו נייחד ל-applets פרק מיוחד בהמשך.

הפעל את עורך הטקסט שברשותך וכתוב לתוכו את שורות הקוד הבאות:

 

//filename: HiIsrael.java

 

 

//Copyright © 2000 Haim Michael & Zindell Publishing House, Ltd.

//All rights reserved. No part of the contents of this program may be

//reproduced or transmitted in any form or by any means without the

//written permission of the publisher.

 

 

import java.applet.*;

import java.awt.*;

 

 

 

 

public class HiIsrael extends java.applet.Applet

{

        public void paint(java.awt.Graphics g)

        {

                g.drawString("Hi Israel !",50,25);

        }

}

 

 

קובץ זה יש לשמור עפ"י הכללים שאמורים לגבי application תחת שם שזהה לשם המחלקה : HiIsrael.java.

 

שלב ב' : הידור קובץ קוד המקור וקבלת קובץ ה-java byte code
כל מה שנאמר בנוגע להידור של תכנית שהיא application נכון גם לגבי תכנית שהיא applet. ההידור נעשה באותו אופן, ולכן, מה שיש לרשום בשורת הפקודה הוא:javac HiIsrael.java

 

שלב ג' : כתיבת קובץ HTML שמיועד להפעיל את ה-applet שכתבנו.
כדי להריץ יישומון שכתבנו יש לייצור מסמך HTML מתאים אשר מכיל בתוכו את התגית <APPLET> שמיועדת להפעיל את היישומון. לא ניתן להריץ יישומון מבלי שיהיה קובץ HTML מתאים אשר מפעיל אותו.

הפעל את עורך הטקסט שברשותך והעתק לתוך קובץ חדש שתיצור את שורות הקוד הבאות:

<applet code="HiIsrael.class"

        width=200 height=100>

</applet>

 

הענק לקובץ שיצרת שם ושמור אותו עם הסיומת html.

width ו- height מבטאים את גודל החלון שבו יוצג ה-applet.

בסביבות פיתוח מתקדמות מסמך ה-HTML אשר מכיל את הקריאה להפעלת ה-applet נוצר באופן אוטומאטי.

 

שלב ג' : הרצת היישומון (ה-applet)
את היישומון שכתבת ניתן להריץ בשתי דרכים:

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

דרך שניה להפעלת היישומון היא הפעלתו באמצעות ה-appletviewer. בחבילת הפיתוח JDK קיימת התכנית appletviewer אשר בהפעלתה על קובץ ה- HTML שמכיל קריאה להפעלת APPLET  מופעל ה-Applet. כדי להפעיל את ה-appletviewr על התכנית שהנך כותב כעת, יש לרשום בשורת הפקודה:

appletviewer HiIsrale.html

ההבדל הבולט בין שתי הדרכים הוא שבדרך השניה לא רואים את מסמך ה-HTML אלא רק את ה-applet שמופעל מתוכו בעוד שבדרך הראשונה כן רואים את מסמך ה-HTML. הבדל נוסף שקיים בין שתי הדרכים הוא שבדרך השניה, כאשר ה-appletviewer מופעל על מסמך HTML  שכולל יותר מ-applet אחד אז הוא גורם להופעתם של כל אחד מה-applets בחלון נפרד, בעוד שבדפדפן היה ניתן לראות את כולם באותו חלון.

 

 

ארגון המחלקות ב-Packages

 

הקדמה

 

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

 

Packages

 

קבוצה של מחלקות נקראת בשם package .

כדי שמחלקה או מחלקות שנכתבות בקובץ מסוים יהיו שייכות ל- package מסוים יש להוסיף בתחילת קוד המקור את משפט ה-package.

 

לדוגמא:

//filename: Gulu.java

package abba;

 

class Gulu

{

            .

            .

            .

}

 

בהוספת שורה זו, המחלקה (או המחלקות אם יש יותר ממחלקה אחת בקובץ) יהיו שייכים ל-package ששמו abba.

 

אם לא מציינים באמצעות משפט ה-package כי המחלקה/ות בקובץ מסוים שייכות ל-package מסוים אז המחלקות יהיו שייכות ל- default package.

 

משפט ה-package בנוי באופן הבא:                    package package name

 

נהוג לתת ל-package שם באותיות קטנות. נהוג גם לייצור היררכיה של packages – יוסבר בהמשך.

 

כל  קבצי ה-class של מחלקות ששייכות ל-  package מסוים יישמרו בספריה (תיקיה) ששמה זהה לשם של ה-package. קיימת אפשרות ש-package  או אפילו קבוצה של packages תישמר בקובץ אחד מכווץ, אך באפשרות זו לא נדון בשלב זה.

 

לאחר כתיבת קובץ קוד המקור שמכיל מחלקות ששייכות ל-package מסוים יש להדר אותו כך שקבצי ה-class שיווצרו יישמרו בספריה ששמה זהה לשם של ה-package. כדי לעשות זאת יש להדר באמצעות הוספת התגית –d למילה javac. כמו כן, יש לרשום אחרי התגית –d את ה-path שבו אנו רוצים שתיווצר הספריה (אם היא עדיין לא קיימת שם) של קבצי ה-package.

לדוגמא (המשך הדוגמא הקודמת):

javac  –d  c:\  Gulu.java

 

כתיבת שורה זו בשורת הפקודה תגרום לכך שקובץ ה-class שיווצר ישמר בספריה ששמה abba, והספריה הזו תיווצר בספריית השורש c:\.

 

כפי שכבר ציינתי, ניתן לייצור היררכיה של packages. כלומר, package אשר יכיל packages אחרים וכך הלאה…

היררכיה של packages תבוא לידי ביטוי בהיררכיה מתאימה של ספריות.

לדוגמא:

//filename: Jojo.java

package abba.gold;

 

class Gulu

{

            .

            .

            .

}

 

בהוספת שורה זו, המחלקה (או המחלקות אם יש יותר ממחלקה אחת בקובץ) יהיו שייכים ל-package ששמו gold אשר יימצא בתוך ה-package ששמו abba.

 

בביצוע הקומפילציה לקובץ זה בתוספת התגית –d וציון path , תיבנה היררכית הספריות המתאימה (אם היא לא קיימת) ב-path שצוין.

לדוגמא:

javac –d c:\ Gulu.java

 

כתיבת שורה זו בשורת הפקודה תגרום לכך שקובץ ה-class שיווצר ישמר בספריה ששמה gold, וספריה זו תיווצר כתת ספריה בספריה abba אשר תיווצר בספרית השורש c:\. כל אחת מספריות אלה תיווצר רק אם היא לא קיימת.

 

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

המשך הדוגמא:

כעת שמה המלא של המחלקה Gulu יהיה: abba.gold.Gulu.

 

מלבד ה-path קיים במחשב משתנה סביבה חשוב נוסף, ששמו classpath. ה-classpath מכיל את רשימת ה-pathים שבהם java ו- javac יחפשו מחלקה, מחלקה שרוצים להריץ או מחלקה שנעשה בה שימוש על ידי מחלקה אחרת שעוברת קומפילציה.

כאשר javac מחפש מחלקה (שנעשה בה שימוש בקובץ שאותו היא מהדרת) הוא מחפש אותה, קודם כל, בספריה הנוכחית. אם הוא לא מוצא אותה אז הוא מחפש אותה בספריות שבה נמצאים קבצי ה-class ששייכים ל-java core. אם גם שם הוא לא מוצא אותה אז הוא מחפש אותה בכל אחד מה-pathים שמופיעים במשתנה ה-classpath , והוא עושה זאת עפ"י סדר הופעתם משמאל לימין.

החיפוש אחרי מחלקה ששייכת לpackage מסוים נעשה בכל אחד מה-pathים שמופיעים ב-classpath. בכל אחד מהpathים שנבדקים מתבצע חיפוש אחרי ספריה ששמש זהה לשם של ה-package (או אחרי ספריה ששמה זהה לשם של ה-package ואחר כך גם אחרי תת ספריה מתאימה ששמה זהה לשם של תת ה-package) . אחרי מציאת הספריה המתאימה מתבצע חיפוש אחרי הקובץ המתאים בתוך אותה ספריה.

מסיבה זו, חשוב להוסיף ל-classpath את ה-path שבו נמצאת הספריה (או הספריות) של ה-package שאליו המחלקה המבוקשת שייכת.

המשך הדוגמא האחרונה:

כדי שניתן יהיה להשתמש, כעת, במחלקה Gulu יש צורך להוסיף אל ה-pathים שנמצאים ב-classpath :   c:\. 

כמו כן, מעתה ואילך, כדי להשתמש במחלקה Gulu יש צורך לכתוב את השם המלא של המחלקה:            abba.gold.Gulu

לדוגמא, כדי להריץ עכשיו את המחלקה Gulu (בהנחה שהיא application כמובן) יש צורך לרשום זאת כך:             java abba.gold.Gulu

את השם המלא יש לרשום בכל מקום שבו עושים שימוש במחלקה. גם כאשר מריצים את המחלקה (java abba.gold.Gulu), וגם כאשר משתמשים בה בתוך מחלקה אחרת. לגבי המקרה האחרון, ניתן להימנע מכתיבת השם המלא של המחלקה אם עושים שימוש בפקודה import.

 

הערות:

·           המטרה העיקרית של חלוקת המחלקות ל-packages היא לייצור מחלקות עם שמות ייחודיים, ולכן מקובל לעשות שימוש בשם ה-domain שבו עושים שימוש כשם של package.             לדוגמא:                                   package il.co.zindell

·           כאשר בקובץ קוד מקור מסוים יש הגדרה של יותר ממחלקה אחת, ומוסיפים לתחילתו של הקובץ את משפט ה-package אז כל המחלקות שמוגדרות באותו קובץ ישויכו ל-package שצוין.

 

 

 

 

משפט הimport-

 

כדי להימנע מכתיבת השם המלא של מחלקה (כלומר, שם ה-packaage שאליו היא שייכת או שמות ה-packages מופרדים בנקודות מפרידות ורק אחר כך השם של המחלקה) יש לכתוב את משפט ה-import בתחילת הקובץ. קיימות שתי דרכים לשימוש במשפט ה-import:

שימוש ספציפי

בתחילת הקובץ, כותבים את משפט ה-import עפ"י התבנית הבאה:

import package name . package name . class name;

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

דוגמא לשימוש ספציפי בפקודה import:

אם בתחילת קובץ אוסיף את השורה:

import abba.gold.Gulu;

אז כשארצה לעשות שימוש במחלקה Gulu אוכל לרשום את השם Gulu בלבד. אם ארצה, אוכל עדיין לרשום את השם המלא: abba.gold.Gulu אך זאת יהיה מיותר.

 

שימוש כללי

בתחילת הקובץ כותבים את משפט ה-import על פי התבנית הבאה:

import package name . package name. *;

במקרה כזה, כל המחלקות ששייכות ל-package שצוין (והכוונה רק לתת ה- package) – ניתן יהיה לעשות בהן שימוש בקובץ מבלי לציין את שמן המלא.

דוגמא לשימוש כללי בפקודה import:

אם בתחילת קובץ אוסיף את השורה:

import  abba.gold.*;

אז כשארצה לעשות שימוש במחלקה כלשהי ששייכת ל-package: abba.gold  אוכל לרשום את השם של המחלקה לבדו בלבד. אם ארצה אוכל עדיין לרשום את השם המלא, אך לא יהיה בכך עוד צורך.

הערות:

·           אם מחלקה רוצה להשתמש במחלקה אחרת ושתיהן שייכות לאותו package אז אין צורך בכתיבת שמה המלא של המחלקה האחרת, ולכן גם אין צורך במשפט ה-import.

·           ה- package ששמו java.lang מיובא (import) באופן אוטומאטי לכל קובץ שאנו כותבים ב-JAVA, ולכן אין צורך להוסיף לתחילת הקובץ:                  import  java.lang.*;

·           אם הקובץ מכיל גם את משפט ה-package וגם את משפט ה-import, אז משפט ה-package יופיע לפני משפט ה-import.

 

אם אתה מכיר את שפת התכנות C\C++, את/ה וודאי מכיר/ה את פקודת ה-include אשר מורה לקדם מהדר לכלול את תכנם של קבצים נוספים לצורך הידור. פקודת ה-import שונה מפקודת ה-include. שימוש בפקודת ה-import  לא גורם להגדלת הקובץ, ולכן איננו פוגע בביצועים. ההשוואות בין JAVA ל- C\C++  עוד יימשכו. אין לי כל כוונה לפגוע בכבודה של C\C++ , וגם אין בכך כל צורך.

 

 

דוגמא לשימוש ב-package  וב-import

הדוגמא לעיל כוללת שני קבצים. המחלקה Cord שבקובץ הראשון שייכת ל-package ששמו: solico. המחלקה PackageDemo שבקובץ השני עושה שימוש במחלקה Cord, ועל כן מופיעה בתחילת הקובץ שורת ה-import המתאימה. אל תנסה/י להבין את מה שהמחלקות עושות בשלב זה. כדי להבין את פעולתן תוכל לחזור אל הדוגמה לאחר ההתקדמות המתאימה בחומר.

את הקובץ הראשון, אשר כולל בתוכו את הגדרת המחלקה Cord עליך להדר באמצעות הוספת התגית –d ומייד אחריה את ה-path שהחל ממנו תיבנה היררכית הספריות המתאימה. תוכל לקבוע כל path שתרצה. זכור כי אם ברצונך לאפשר את השימוש במחלקה גם כאשר הספריה הנוכחית איננה הספריה שבה נוצרו ספריות ה-packages, עליך גם להוסיף את ה-path ל-classpath. הוספת path ל-classpath נעשית )בשורת הפקודה) באופן הבא:

set classpath=%classpath%; path to be added ;

%classpath% מייצג את ה-classpath  הנוכחי.

//filename: Cord.java

 

 

//Copyright © 2000 Haim Michael & Zindell Publishing House, Ltd.

//All rights reserved. No part of the contents of this program may be

//reproduced or transmitted in any form or by any means without the

//written permission of the publisher.

 

 

package soliko;

 

 

public class Cord

{

 

        private int x,y;

        private byte color;

 

        public void set(int a,int b, byte color)

        {

                this.x=a;              

                // the parameter name is different from

                // the instance variable name so the use

                // of the word this isn't neccesary !

 

                this.y=b;              

                // the parameter name is different from

                // the instance variable name so the use

                // of the word this isn't neccesary !

 

                this.color=color; 

                // the parameter has the same name as

                // the instance variable color so the

                // use of the word this is necessery

        }

 

        public void set(int a,int b)

        {

                x=a;

                y=b;

        }

 

        public void set(byte clr)

        {

                color=clr;

        }

 

        public void set()

        {

                x=y=0;

                set((byte)0);  

                //calling the function set(byte) to set the color

                //to be zero. you can use the word 'this' but you

    //don't have to !

        }

 

        public void set(int a)

        {

                x=a;

                y=a;

        }

 

        public boolean equals(Cord otherCord)

        {

                if (otherCord.x==x && otherCord.y==y)

                        return true;

                else

                        return false;

        }

}

 

 

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

 

//filename:PackageDemo.java

 

//Copyright © 2000 Haim Michael & Zindell Publishing House, Ltd.

//All rights reserved. No part of the contents of this program may be

//reproduced or transmitted in any form or by any means without the

//written permission of the publisher.

 

 

import soliko.Cord;

 

public class PackageDemo

{

        public static void main(String args[])

        {

                Cord CordA1;

                Cord CordA2;

                CordA1=new Cord();

                CordA2=new Cord();

                CordA1.set(10);        

    // Now CordA1 is (10,10) in color 2

                CordA2.set(10,10,(byte)2);

    // Now CordA2 is (10,10) in color 2 too !

                if (CordA1.equals(CordA2))

                     System.out.println("\nThe two new Cords equal");

        }

       

 

}

 

שים לב לכך, שכעת, שמה המלא של המחלקה Cord הוא:   soliko.Cord, ולכן, אילו היא הייתה גם application אז כדי להריץ אותה היה צריך לרשום:

java solico.Cord

 

כמו כן, שורה זו ניתן יהיה לרשום מכל path, ובלבד שה-classpath יכלול את ה-path, שבו ממוקמת הספריה solico. אם ה-classpath  לא כולל את ה-path, שבו ממוקמת הספריה solico אז ניתן יהיה להריץ את solico.Cord רק אם מנסים לעשות זאת כאשר נמצאים בספריה שבה נמצאת תת הספריה solico.

 

במקום לשנות את ערכו של ה-classpath ניתן, לחילופין, לשמור את תת הספרייה (solico במקרה זה) בתיקיה c:\jdk1.3\jre\classes (בהנחה שה-jdk הותקן בספריית השורש c:). אם תת הספרייה כלולה בתוך קובץ jar אז ניתן לשמור אותה בתיקיה c:\jdk1.2\jre\lib\ext (בהנחה שה-jdk הותקן בספריית השורש c:) במקום לעדכן את ה-classpath.

 

היכרות עם ה- javadoc 

 

ה- javadoc  היא תכנית שמאפשרת לייצור קבצי HTML שמהווים דוקומנטציה לתכנית הנכתבת. ההערות שמשולבות בתוך התכנית ושמועתקות אל קובץ ה-HTML שנוצר בתור תיעוד מאופיינות בכך שהן מתחילות ב-    **/   

ומסתיימות ב-  /*

 

בתוך ההערות שה-javadoc לוקח וממקם בקבצי התיעוד שהוא יוצר, ניתן למקם תגיות HTML, וכמו כן, גם תגיות שמיוחדות ל- javadoc, כגון: @see, @author ו- @since.

 

כדי להשתמש ב-javadoc יש לרשום בשורת הפקודה javadoc ואחריה את שם קובץ ה-JAVA או שם ה-package שרוצים לעשות להם דוקומנטציה. בין המילה javadoc לשם הקובץ יש להוסיף תגיות ותוספות שונות בהתאם לדוקומנטציה שרוצים שתיווצר. להכרות רחבה יותר עם הכלי תוכל/י לעבור ולקרוא עליו בנספח המתאים או לחילופין, לקרוא עליו ב- API Documentation, אשר גם הוא נוצר באמצעות ה-javadoc.

 

בדוגמא הבאה מובא קובץ שניתן להפעיל עליו את ה- javadoc. תוכל להתרשם מפעולת ה-javadoc על הקובץ בכך שבשורת הפקודה (עליך להימצא בספריה שבה נמצא הקובץ הזה) תרשום/תרשמי:

javadoc   –d   .    –author   JavadocExample.java

לאחר מתן הפקודה, תוכל לראות כיצד נוצרים קבצי ה-HTML המתאימים. לאחר תום תהליך יצירתם של הקבצים ניתן לצפות בהם באמצעות הדפדפן.  אחרי התגית –d, הפקודה javadoc מצפה לקבל את ה-path למיקום שבו יווצרו קבצי ה-HTML.  שליחת . (נקודה בודדת) כמוה כשליחת ה-path לספריה הנוכחית, שכעת עובדים עליה.

 

 

 

 

//filename: JavadocExample.java

 

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

 

 

/**

* filename is JavadocExample.  

* was written in 26/6/99

* in the Holly Land

* @since version b1

* @author Haim Michael */

public class JavadocExample extends Frame

{ 

 /**@serial beautiful */

    private Panel pane;

     

 /**This is the amazing constructor we love

   *and without him we could feel lonely    */

    public JavadocExample()

    { 

        pane = new Panel();

        Button blueButton = new Button("Blue");

       pane.add(blueButton);

        Button redButton = new Button("Red");

        pane.add(redButton);

        add(pane,"Center");

    }

  

 /**This is the main method of the application

   *We like to write comments … */

   public static void main(String[] args)

   { 

        Frame f = new JavadocExample();

        f.addWindowListener(new WindowAdapter()

                  { 

                public void windowClosing(WindowEvent e)

                        {

                           System.exit(0);

                        }

                  }                                           );

        f.setSize(400, 400);     

  f.show();

   }

}

 

 

ה - Java Virtual Machine

 

 

בתיעוד של JAVA  ניתן למצוא את ההגדרה הבא:

“The Java Virtual Machine is an Imaginary Machine that is implemented by emulating it in software on a real machine. Code for the Java Virtual Machine is stored in .class files, each of which contains code for at most one public class.”

 

ה- JVM (Java Virtual Machine) אחראית לתרגום ה-Java Byte Code לשפת המכונה שעליה התכנית מורצת. ה-JVM  יכולה להיות תוכנית שמורצת במחשב או אפילו חלק מהחומרה שלו. קובץ ה-byte code (הקובץ עם הסיומת ,class) מכיל למעשה סדרת הוראות ל-JVM. בכל כלי שמסוגל להריץ תכניות ב-JAVA (דפדפנים, סביבות פיתוח של תכניות ב-JAVA... ) קיים ה-JVM.

 

ה-JVM Specification מכיל הגדרות מדויקות בנוגע לאופן שבו אמורים להיות קבצי ה-Java Byte Code כדי שיוכלו לרוץ באמצעות ה-JVM.  כאשר מגיעה מחלקה מרשת האינטרנט לפני שהיא מורצת מופעל ה- Bytecode Verifier אשר מוודא בין היתר את עמידת קובץ ה- Java Byte Code בכללים. מידע נוסף אודות ה-JVM תוכל/י לקבל בספר:

JAVA Virtual Machine \ Jon Meyer & Troy Downing      from O’REILLY

 

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

 

במהלך השנים ה-JVM התפתח וביצועיו שופרו. לאחרונה פותח JVM חדיש ששמו: HOT SPOT VIRTUAL MACHINE, אשר מסוגל לתרגם את אותם חלקים של התכנית אשר מתבצעים יותר מפעם אחת (האזורים החמים שלה) לשפת מכונה, ורק אחר כך להריצה. הודות להתקדמות זו, מהירות הריצה של תכניות ב-JAVA מתקרבת למהירות הריצה של תכניות ב- C++. כמו כן, הודות לפיתוח האחרון, ניתן לייצור Multi Threading  (מספר רצפי פעולה שפועלים במקביל) תוך התבססות ישירה על ה-CPU, וללא יצירת סימולציה לכך. בכך מושג שיפור נוסף בביצועים. בשלב זה אינך אמור/ה להכיר את המושג thread (פרק 9 מוקדש במלואו לנושא זה).

 

 

ה - Garbage Collector

 

בשפות רבות קיימת האפשרות להקצות זיכרון דינמי במהלך ריצת התכנית. כאשר לא משתמשים עוד בשטח שהוקצה באופן דינמי, יש לשחרר אותו כדי שיוכל לשמש למטרות אחרות. בעוד שב- C\C++  וגם בשפות אחרות, האחריות לשחרור הזיכרון שהוקצה נופלת על המתכנת, ב- JAVA האחריות לכך מוטלת על השפה עצמה, וליתר דיוק, על ה- Garbage Collector. הודות לכך, הסיכוי שתכנית ב-JAVA תקרוס בגלל בעיות זיכרון קטן יותר מאשר אילו התכנית הייתה כתובה ב-C/C++  למשל.

 

ה- Garbage Collector פועל ברצף וללא הפסקה כל הזמן במקביל לתכנית, ומנהל מעקב אחרי כל שטחי הזיכרון שמוקצים בתכנית. כאשר הוא מגלה ששטח זיכרון שהוקצה – אך משתנה לא מצביע עליו יותר הוא משחרר אותו. כאן המקום להעיר, כי ב-JAVA המשתנים נחלקים לשני סוגים. המשתנים מהטיפוס הבסיסי מכילים ערכים מהטיפוסים הבסיסיים שקיימים. המשתנים מהטיפוס המחלקתי מכילים כתובות של שטחי זיכרון שמייצגים (כל אחד מהם בנפרד) אובייקט. נקודה זו תובהר בפרקים הבאים.

 

 

 

לנוחיותך, להלן תוכן העניינים של הספר:

 

פרק 1: ההתחלה Let's start  -

פרק 2: הבסיס Basic -

פרק 3: מחלקות Classes -
פרק 4: מערכים ומחרוזות תוויםArrays & Strings -
פרק 5: הורשהInheritance -
פרק 6: ניתוח מרכיביה של מחלקהReflection -
פרק 7: מחלקות פנימיותInner Classes -
פרק 8: יישומוניםApplets -
פרק 9: תכנות מקביליThreads -

פרק 10: ממשק משתמש גרפי בסיסי Graphic User Interface using AWT -

פרק 11: הטיפול באירועים Events Handling -

פרק 12: הטיפול בשגיאות Exceptions Handling -

פרק 13: פעולות קלט/פלט I\O Streams -
פרק 14: תקשורתNetworking -

פרק 15: ממשק משתמש גרפי מתקדם Graphic User Interface using SWING -
פרק 16: מבני נתונים Data Structures  -

פרק 17: מחלקות מוכנות לתיאור מבני נתונים Collections API  -

פרק 18:  קישור לבסיס נתונים - JDBC

פרק 19:  הפעלת מתודות מרחוק RMI -

פרק 20:  הסבת התכנית למדינות אחרותInternationalization -

פרק 21:  שילוב קוד בC- Native Methods (JNI) -

פרק 22:  שימוש בXML-

פרק 23:  אבטחת מידע Security -

פרק 24:  גרפיקה דו ממדית 2D Graphics -

פרק 25:  ניהול הזיכרון Memory Management -

 

 


נספחים:

נספח א': אופן הפעלת ה-javadoc

נספח ב': הכרות ראשונית עם UML

נספח ג': הכרות ראשונית עם Design Patterns

נספח ד': שיפור הביצועים של התכנית

נספח ה':  כללי תחביר בכתיבת קוד מקור

נספח ו':  פקודות שכיחות ב-SQL

 

 

 

 

 



 

 

 

 

 

 

 

 

 

 

 

 

 

 

2000 © All the rights reserved to

Haim Michael & Zindell Publishing House Ltd.

 

No parts of the contents of this paper may be reproduced or transmitted

in any form by any means without the written permission of the publisher ! 

This book can be used for personal use only!!!

 

 

Brought to you by ZINDELL

http://www.zindell.com