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

פונקציות

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

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

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

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

3. טיפוס הפונקציה (פלט): הפונקציה עצמה מחזירה ערך המהווה את התוצאה של הפונקציה. הערך יכול להשתנות אך הטיפוס שלו (integer, double, String וכו…) חייב להיות קבוע מראש.

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

בואו נראה דוגמא לפונקציה:

int GetBiggerNumber(int x, int y)
{
  if (x > y)
    return x;
  else
    return y;
}

בקטע קוד זה, הגדרנו פונקציה חדשה בשם GetBiggerNumber אשר מקבלת 2 פרמטרים מסוג int (משתנה x ומשתנה y) ומחזירה ערך מסוג int למי שקרא לה.
כל זה מתואר בשורה מספר 1, כאשר שורות 2 עד 7 הן בעצם קוד הפונקציה עצמה.
שימו לב לתיאור מדוייק יותר של שורה מספר 1:

הסבר על מבנה הפונקציה

פקודה נוספת אליה ארצה להפנות את תשומת ליבכם, היא הפקודה return שנמצאת בשורות 4 ו- 6. כאשר המחשב נתקל בתוך הפונקציה בפקודה return, הוא בעצם מפסיק להריץ את קוד הפונקציה ומחזיר את הערך שמופיע אחרי ה return בתור תוצאת הפונקציה (פלט הפונקציה).
שימו לב כי בשורות 4 ו- 6 אנחנו מחזירים את x או את y, אשר הם מטיפוס int, כפי שהגדרנו בפלט הפונקציה בשורה 1. באם היינו מנסים להחזיר משתנה או טיפוס אחר (לדוגמא, אם היינו כותבים return false), המחשב היה נותן הודעת שגיאה וזאת כי false הינו מסוג boolean ולא int.

לפי קטע הקוד המופיע בשורות 2 עד 7, אפשר לראות שהפונקציה בודקת האם x גדול מ y (שורה 3) ואם הוא אכן גדול יותר, היא מחזירה אותו (שורה 4). אם הוא לא גדול יותר (שורה 5), היא מחזירה את y (שורה 6).
כלומר מטרת הפונקציה היא לקבל 2 ערכים מסוג int ולהחזיר את הגדול בינהם. מי מכם שקרא את שם הפונקציה (GetBiggerNumber) יכל לדעת זאת גם מבלי לקרוא את קוד הפונקציה ולחסוך זמן יקר, ומכאן ניתן להבין מדוע חשוב תמיד לתת לפונקציות שמות משמעותיים.

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

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

int GetBiggerNumber(int x, int y)
{
  if (x > y)
    return x;
  else
    return y;
}

int x = GetBiggerNumber(10, 20);
int y = GetBiggerNumber(281, 198);

System.out.println(x);
System.out.println(y);

שורות 1 עד 7 הן הגדרת הפונקציה (זהות לקטע קוד העליון).
אך שימו לב לשורה 9. שורה זאת נמצאת מחוץ לבלוק הפונקציה ובה אנו מגדירים משתנה חדש בשם x מסוג int, אשר מקבל את הערך (פלט) שחוזר מהפונקציה GetBiggerNumber, שמקבלת בעצמה 2 ערכים מסוג int (המספר 10 והמספר 20).
בדומה לשורה זאת, שורה 10 מגדירה משתנה בשם y ואליו נכנס ערך שחוזר מאותה פונקציה, רק שהפעם הערכים שהפונקציה מקבלת הינם 281 ו- 198.

עכשיו, שימו לב:

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

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

בשורות 12 ו 13 אנחנו מדפיסים את הערך של x ושל y (החיצוניים לפונקציה).
מה לדעתכם יודפס בפועל?
אם כתבתם שיודפס 20 ומתחתיו 281, אתם צודקים.

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

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

תיכנות מונחה עצמים

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

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

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

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

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

המחלקה

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

public class Car {

}

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

public class Car {

}

Car AndyCar = new Car();
Car ProfessorCar = new Car();

בדוגמא הזאת הגדרנו מחלקה חדשה בשם Car (המחלקה ריקה ועדיין לא הגדרנו לה תכונות ופעולות) ולאחר מכן יצרנו שתי עצמים מהסוג של המחלקה שלנו בשם AndyCar ו ProfessorCar (שורות 5 ו 6).
ונחזור לתיכנות מונחה עצמים.
ישנם שלושה עקרונות בסיסיים לגבי מחלקות, בתיכנות מונחה עצמים:

עיקרון 1 – כימוס (Encapsulation)

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

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

public class Car {

	private String color;
	private int speed;
	private int gasInTank;

	public void increaseSpeed()
	{
		this.speed++;
	}

	public void decreaseSpeed()
	{
		this.speed--;
	}

	public void addGas(int gasQuantity)
	{
		this.gasInTank = this.gasInTank + gasQuantity;
	}

	public int getGas()
	{
		return this.gasInTank;
	}

	public String getColor()
	{
		return this.color;
	}

	public Car (String carColor)
	{
		this.color = carColor;
		this.gasInTank = 0;
		this.speed = 0;
	}
}

אל תיבהלו, זה רק נראה גדול ומסובך אבל למען האמת, זה די פשוט. בואו נעבור על הקוד:
שורה 1: הגדרה של מבנה של מחלקה ציבורית חדשה בשם Car.
שורה 3: הגדרה של תכונה פרטית מטיפוס String בשם color, אשר תכיל את צבע המכונית.
שורה 4: הגדרה של תכונה פרטית מטיפוס int בשם speed, אשר תכיל את המהירות הנוכחית של המכונית.
שורה 5: הגדרה של תכונה פרטית מטיפוס int בשם gasInTank, שמכילה את כמות הדלק הנוכחית במכונית.

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

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

רגע! עצור! מה זה void!??
כאשר פונקציה מסויימת מחזירה void המשמעות היא שהפונקציה בעצם אינה מחזירה דבר ואין להכניס פקודת return בתוכה. בדוגמא של הפונקציה increaseSpeed הגברת מהירות המכונית היא
פעולה לוגית שאינה מצריכה החזרת ערך למי שקורא לה ולפיכך היא מוגדרת כ- void.

שורה 9: מכילה את בלוק הקוד של פעולת increaseSpeed בו אנחנו בעצם מגבירים את המהירות, כלומר מגדילים את התכונה speed.
שורה 12: הגדרה של פעולה ציבורית המחזירה void בשם decreaseSpeed, שאינה מקבלת פרמטרים ותפקידה הוא להוריד את מהירות המכונית.
שורה 14: מכילה את בלוק הקוד של פעולת decreaseSpeed בו אנחנו מנמיכים את המהירות, כלומר מקטינים את התכונה speed.
שורה 17: הגדרה של פעולה ציבורית המחזירה void בשם addGas, המקבלת פרמטר אחד מסוג int בשם gasQuantity המתאר כמה דלק עלינו להוסיף למכונית. הפעולה אחראית על הוספת דלק למיכל המכונית.
שורה 19: מכילה את בלוק הקוד של פעולת addGas בו אנחנו מוסיפים לתכונה gasInTank את כמות הדלק שקיבלנו בפרמטר gasQuantity.
שורה 22: הגדרה של פעולה ציבורית המחזירה int בשם getGas, שאינה מקבלת פרמטרים ותפקידה הוא להחזיר את כמות הדלק שיש כרגע במיכל.
שורה 24: מכילה את בלוק הקוד של פעולת getGas, והיא בעצם החזרת הערך שנמצא בתוך התכונה הפרטית gasInTank.
שורה 27: הגדרה של פעולה ציבורית המחזירה String בשם getColor, שאינה מקבלת פרמטרים ותפקידה הוא להחזיר לנו את צבע המכונית.
שורה 29: מכילה את בלוק הקוד של פעולת getColor והיא בעצם החזרת הערך שנמצא בתוך התכונה הפרטית color.

שימו לב שכדי להתייחס לתכונה ששייכת למחלקה, השתמשנו ב this (שורות 14,19,24,29).

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

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

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

public void  decreaseSpeed()
{
  if (this.speed >= 0)
    this.speed--;
}

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

עקרונות נוספים בתיכנות מונחה עצמים

ישנם עוד שני עקרונות נוספים בתיכנות מונחה עצמים. הורשה (Inheritance) ורב-צורתיות (Polymorphism).
על עקרונות מעניינים אלו נדבר בהרחבה בשיעור הבא שלנו ובשיעור הנוכחי נתמקד במימוש מחלקות ושימוש בכימוס.

מימוש הקוד ב Eclipse

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

סדר בקוד – חבילות

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

Eclipse Package Explorer

הסבר על מבנה העץ:
תחת סיפריית src (מלשון Source) מוגדרת חבילה בשם iAndroid.academy ובתוכנה יש קובץ בשם Test.java.
תחת החבילה iAndroid.academy ניתן להוסיף קבצים רבים אשר קשורים לאותה חבילה. לפיכך, חשוב מאד שגם לשם החבילה, כמו לכל דבר אחר, יהיה שם בעל משמעות ושכל הקבצים תחת אותה חבילה יהיו קשורים אליה.
שימו לב: הסטנדרט מגדיר כי שמות של חבילות יתחילו תמיד באות קטנה.

סדר בקוד – קבצים ומחלקות

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

הוספת חבילה חדשה

בואו ונוסיף חבילה חדשה לתוך הפרויקט שלנו.
ליחצו מקש ימני על src ובתפריט שנפתח ביחרו ב New ואז ב Package.
צרו מחלקה חדשה בשם iAndroid.cars (שימו לב, גם iAndroid וגם cars מתחילות באות קטנה, ע"פ הסטנדרט).

התוצאה צריכה להיראות כך:

Eclipse, New and Empty Package

הוספת מחלקה חדשה

ליחצו מקש ימני על iAndroid.cars וביחרו ב New ואז ב Class.
במסך שנפתח לכם, הזינו את שם המחלקה Car בתוך השדה Name וליחצו על Finish.

התוצאה צריכה להיראות כך:

Eclipse - New Class

מזל טוב! כרגע יצרתם מחלקה חדשה בשם Car (שימו לב לצד ימין) שנמצאת בתוך החבילה iAndroid.cars.
בשיעור הבא נכניס עוד מכוניות רבות לתוך החבילה iAndroid.cars.

קריאה לחבילה.

העתיקו והדביקו את קטע הקוד של המכונית שכתבנו למעלה לתוך הקובץ Car.java (שימו לב לא למחוק בטעות את השורה הראשונה package iAndroid.cars שמגדירה את החבילה אליה משתייכת המחלקה).
היכנסו לקובץ Test.java שנמצא תחת החבילה iAndroid.academy וכיתבו בשורה השניה את קטע הקוד הבא

import iAndroid.cars.*;

הקובץ כולו אמור להיראות כך:

package iAndroid.academy;

import iAndroid.cars.*;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

	}
}
}

אז מה בעצם עשינו פה?
אמרנו למחשב בעצם ליבא (import) את כל המחלקות שנמצאות בחבילה iAndroid.cars.
כעת אנחנו יכולים ליצור אובייקט חדש מסוג Car ולהשתמש בו תחת Test.

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

יצירת אובייקט חדש מסוג Car

בתוך הפונקציה המרכזית של התוכנית (main), רישמו את קטע הקוד הבא:

package iAndroid.academy;

import iAndroid.cars.*;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Car myCar;
		myCar = new Car("Black");

		myCar.addGas(30);

		System.out.println(myCar.getGas());
	}
}

הסבר על הקוד:
שורה 11: יצירת עצם חדש בשם myCar מסוג Car. שימו לב שהאובייקט לא אותחל ושעדיין לא ניתן להשתמש בו.
שורה 12: איתחול האובייקט וקריאה לבנאי שלו, תוך העברת הערך "Black" כפרמטר. לאחר שורה זאת בעצם ניתן להשתמש באובייקט.
שורה 14: קריאה לפעולה addGas לשם הוספת דלק לרכב.
שורה 16: הדפסת הערך החוזר מקריאה לפעולה getGas.

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

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


תרגיל

אנדיאחלה תרגיל פרופסור!
בין העונים נכונה יוגרל סוף שבוע רומנטי עם המורה ללשון (או עם הפרופסור).

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

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

להית'!