שיעור 01: איך מתחילים

מתוך גרינפוט ישראל - מדריך ציבורי ללימוד גרינפוט
קפיצה אל: ניווט, חיפוש

השיעור הבא: תחביר ג'אווה->

מטרת השיעור

בשיעור זה נכיר לראשונה את סביבת גרינפוט:

  • נתקין את תוכנת גרינפוט
  • נריץ את התוכנה בפעם הראשונה ונכיר את סביבת גרינפוט
  • נלמד כיצד בנויה תוכנית בגרינפוט, עדיין בלי להבין יותר מידי Java
  • נכתוב תוכנית פשוטה ראשונה בגרינפוט (את ה-"Hello Greenfoot" שלנו)
  • נכתוב עוד תוכנית פשוטה אחת, אבל שעושה קצת יותר
  • נלמד מה זה קומפילציה ואיך להתמודד עם שגיאות קומפילציה

רקע נדרש

בשיעור זה נסביר מהי התוכנה Greenfoot, איך מתקינים אותה ואיך עובדים בה.

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

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

אז בואו נתחיל

התקנת התוכנה

להורדת Greenfoot היכנסו לאתר הבא - http://www.greenfoot.org/download [1]

הסברים מפורטים התקנת התוכנה ניתן למצוא בקישור - התקנת Greenfoot

הכרת סביבת גרינפוט

זו סביבת העבודה שלנו:

Gf0.jpg

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

Gf1.jpg

נבחר את הנתיב הזה לבחירת פרוייקט קיים C:\Program Files (x86)\Greenfoot\scenarios\java

Gf2.jpg

לחצו על "OK"

Gf3.jpg

ניתן שם ונתיב לשמירת הפרויקט ונלחץ על "save"

Gf5.jpg

בשלב זה נסגר החלון הקודם ונפתח אחד חדש – לא להיבהל :) נפתח לנו הפרויקט הבא:

Gf6.jpg


מה שבעצם יש לנו במסך הראשי של כל תוכנית:

העולם שלנו (תחת World Classes) מכיל במקרה שלנו את ground (השטח הירוק והמסלול החום).

האקטורים (תחת Actor classes) במקרה שלנו היא המכונית הכחולה.

כפתור הACT מבצע צעד אחד עבור כל אחד מהאובייקטים בעולם.

כפתור הRUN מריץ את התכנית/ לולאת המשחק.

כפתור ה-Reset מחזיר את התוכנית למצב ההתחלתי.

כיצד בנויה תוכנית בגרינפוט

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

תחילה, ניזכר שיש לנו 2 מחלקות בתוכנית:

מחלקת World - אחראית על יצירת ותכנון העולם שאותו נרצה ליצור.

מחלקת Car - מחלקה זו מכילה את כל התכונות והפעולות שיש למחלקה Actor שהזכרנו בסעיף הקודם. בנוסף לזה יש במחלקה הזו תכונות ופעולות חדשות שאנחנו יכולים להוסיף כרצוננו. (בשפת מתכנתים מגדירים זאת כ-ירושה. כלומר המחלקה Car "יורשת" מהמחלקה Actor).


איך התוכנית רצה?

ב-Greenfoot ישנה לולאה אוטומטית (שלא אנחנו כותבים) שאומרת לכל אקטור שיש לנו בתוכנית להפעיל את הפונקציה ()act.

כלומר עבור כל אובייקט שנרצה לכתוב בתוכנית שלנו, שיורש מהמחלקה Actor, ישנה פונקציה שנקראת ()act שהקוד שנכתוב בה יורץ אוטומטית ע"י התוכנה.

לכן, בדוגמה זאת, כאשר נרצה שהמכונית שלנו תזוז - נכתוב את הפקודות שיגרמו לכך בתוך הפונקציה ()act.


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


ועכשיו - נצלול לתוך הקוד שקיבלנו:

מה שנדגים כעת עבור המחלקה World תקף גם לגבי המחלקה Actor.

נלחץ דאבל קליק על המחלקה World -

Build1.jpg


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


Build2.jpg


ניתן לראות בקישור שנפתח את כל הפונקציות שקיימות במחלקה זו. עבור כל פונקציה קיים תיאור של מה שהיא מבצעת או מחשבת (JAVADOC).

כעת, נראה את המחלקות שיצר המשתמש:

נלחץ דאבל קליק על המחלקה Ground (שנמצאת מתחת ל-World):


Build3.jpg


במסך זה נראה את הקוד שמרכיב את המחלקה Ground. בבנאי של המחלקה עלינו לכתוב קוד שמעביר למחלקת האב של Ground (כלומר, המחלקה World) את הפרמטרים שהיא צריכה על מנת לעבוד. ( פנייה למחלקת האב נעשית ע"י שימוש במילה super). בנוסף, בבנאי של המחלקה הזו, שמהווה את העולם של התוכנית שלנו, נרצה ליצור את האקטורים שיש לנו בתחילת התוכנית ולהוסיף אותם למסך. ניתן להוסיף פונקציות חדשות למחלקה הנוכחית, ובכך בעצם לעצב את העולם של התוכנית שלנו.

באופן דומה, אם נלחץ דאבל קליק על Car נקבל:


Build4.jpg

Hello Greenfoot

נפתח תכנית חדשה בגרינפוט: Scenario -> New Java Scenario

Hello1.jpg

נבחר את התיקייה שבה נרצה שיהיה הפרויקט, ניתן שם ונלחץ על create

Hello2.jpg

(נסגר ונפתח מחדש, לא להיבהל :-) ) נפתח המסך הבא:

Hello3.jpg

ניצור actor משלנו: נלחץ מקש ימני על Actor -> new subclass ויפתח החלון הבא:

Hello4.jpg

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

כעת, תחת Actor קיים אובייקט חדש Ball.

דאבל קליק על Ball ייקח אותנו אל קוד המחלקה, בו נוכל להוסיף פונקציונליות לכדור כרצוננו. בד"כ תוך כדי כתיבת הקוד שלנו, נשתמש בפונקציות קיימות שקיבלנו ממחלקת האב Actor.

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


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


הקוד של העולם

נשים לב שכל מה שכתבנו בקוד של העולם נמצא בבנאי של המחלקה -

1. סיפקנו למחלקת האב את הפרמטרים הדרושים לה (ע"י כתיבת המילה super).

2. הוספנו אובייקט חדש לעולם שלנו מסוג המחלקה החדשה שיצרנו - Ball.

יצירת כדור חדש נעשית ע"י הפקודה ()new Ball. הוספת האובייקט לעולם שלנו נעשית ע"י -

(ציון המיקום של האובייקט החדש על המסך, ציון האובייקט אותו מוסיפים) this.addObject


Hello6.jpg


הקוד של הכדור

נשים לב שהשתמשנו בשלוש פונקציות שקיבלנו מהמחלקה Actor:

1. ()isAtEdge שבודקת האם האובייקט שלנו הגיע לסוף המסך.

2. ()turn שגורמת לאובייקט שלנו להסתובב (במקרה זה ב-90 מעלות).

3. ()move שגורמת לאובייקט שלנו לזוז.


Hello7.jpg

תמונה של התכנית:

Hello5.jpg

ועכשיו תוכנית שעושה קצת יותר

כעת, נראה תכנית מעט יותר מורכבת.

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

נחלק את המשימה שלנו לשלושה חלקים-

חלק 1: ניצור על המסך ארבעה כדורים.

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

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


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




הסברים על התוכנית שמבצעת את המשימה


הקוד של האקטור שלנו - הכדור:

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

עשינו import לחבילה שנקראת java.util.Random.

לאחר מכן הגדרנו data member מטיפוס Random וקראנו לו random. בטיפוס זה אנחנו משתמשים בפונקציה Act כאשר אנחנו רוצים להגריל מספר אקראי בעת שינוי כיוונו של הכדור.


דרך נוספת לקבל מספר אקראי:

כמו שהזכרנו קודם, ישנן פונקציות שאנו מקבלים מGreenfoot במתנה, אחת מפונקציות אלה נקראת (_)Greenfoot.getRandomNumber שנותנת לנו מספר אקראי בין 0 למספר שנכתוב בסוגריים במקום _ .


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


BallsProg1.jpg


הקוד של העולם:

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


BallsProg2.jpg


תמונה של התכנית לפני לחיצה על RUN:

BallsProg3.jpg

התמודדות עם שגיאות קומפילציה בגרינפוט

מה זה קומפילציה?

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

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

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


נראה דוגמה: נכתוב את הקוד הבא ונלחץ על הכפתור Compile

אפשר לראות שמופיע קו אדום מקוקו ליד אחת הפקודות שלנו

Compile1.jpg

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

Compile2.jpg

כעת נתקן את הבעיה (נוסיף ;) ונלחץ שוב על "compile"

Compile3.jpg

סיכום

בשיעור זה הכרנו את התוכנה Greenfoot שמאפשרת לנו לכתוב קוד בג'אווה ולהריץ אותו.

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

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

התנסינו וכתבנו שתי תוכניות בGreenfoot תוך שימוש בכלים שיש בתוכנה.

ראינו איך מריצים תוכנית (Run, Reset, Act), ואיך התוכנה עוזרת לנו להתמודד עם מקרה בו לא ניתן להריץ את התוכנית כי תהליך הקומפילציה נכשל.


כלומר, בשיעור זה הכרנו את כל הכלים ב-Greenfoot שהם הבסיס שלנו להמשך העבודה בתוכנה ולכתיבת תוכניות מורכבות יותר.

שיעורי בית

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

רמז: ישנן פונקציות שגרינפוט נותן לנו שתעזורנה לנו להזיז אקטור לפי מקשי המקלדת.

השיעור הבא: תחביר ג'אווה->