תיכנות בסיסי


פורסם ב 09/05/2010 ע"י האקדמיה לפיתוח לאנדרואיד

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

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

אז בואו נתחיל.

איך אומרים למחשב מה לעשות

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

[sourcecode language="java"]
int x;

x = (9 + 3) – 1;

[/sourcecode]

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

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

משתנים

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

בואו נחזור לדוגמא שלנו מלמעלה. זוכרים את השורה ;int x שהתעלמנו ממנה? בשורה זאת בעצם הגדרנו משתנה בשם x ומסוג int (קיצור של integer) שלתוכו שמרנו את התוצאה (שורה מספר 3) של תשע ועוד שלוש פחות אחת. התוצאה שמורה בתוך x ונוכל לעשות בה שימוש בשלב מאוחר יותר.
int או integer בשמו המלא, הוא דוגמא לטיפוס שיכול להחזיק רק מספרים שלמים. להלן דוגמא נוספת לביצוע מניפולציות על משתנה בשם x, משתנה בשם y ומשתנה בשם z מסוג integer:

[sourcecode language="java"]
int x;
int y;
int z;

x = 9 + 3;
y = 1;
z = x – y;

[/sourcecode]

שימוש לב שבשורות 1 עד 3 הגדרנו שלושה משתנים שונים. הם כולם ריקים בזמן ההגדרה.
בשורה 5 הכנסנו למשתנה x את התוצאה של 9 ועוד 3 (12 כמובן).
בשורה 6 הכנסנו למשתנה y את הסיפרה 1
בשורה 7 הכנסנו למשתנה z את התוצאה של x פחות y, כלומר 12 פחות 1 (ומכאן שבמשתנה z יהיה מוכל 11).

כלומר בשורה 7 ניתן לראות שאנחנו משתמשים במשתנים עצמם כדי להתייחס לערכים השמורים בתוכם.

זוכרים שכתבתי למעלה ש- integer הוא טיפוס המחזיק מספרים שלמים? אם כך מה תהיה התוצאה במקרה הבא:

[sourcecode language="java"]
int x;
int y;

x = (9 + 3) – 1;
y = x / 2;

[/sourcecode]

לשם הבהרה, הסימן / הוא חילוק, כך שבשורה 5 אנחנו מכניסים למשתנה y את הערך של x לחלק ל 2.
שימו לב שב- y אמור להיות המספר 5.5, אך מכיוון ש- integer מכיל רק ערכים שלמים, המספר שיהיה בפועל ב- y הוא 5.
כדי לשמור מספרים עשרוניים בתוך משתנים, יש להשתמש בטיפוס אחר שהוא לא integer, לדוגמא double. להלן אותה תוכנית בצורה מתוקנת:

[sourcecode language="java"]
int x;
double y;

x = (9 + 3) – 1;
y = x / 2;

[/sourcecode]

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

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

[sourcecode language="java"]
char letter = 'U';
[/sourcecode]

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

עוד נקודה שחשוב לשים אליה לב היא ש char יכול להכיל רק תו אחד ויחיד! כך שהתוכנית הבאה היתה נכשלת:

[sourcecode language="java"]
char letter = 'UU';
[/sourcecode]

מחרוזות
מחרוזת, או String, יכולה להחזיק שרשרת של char-ים בתוכנה. להלן דוגמא לכך:

[sourcecode language="java"]
String greeting = "Hello iAndroid!";
[/sourcecode]

כלומר המחרוזת greeting מכילה את המשפט "Hello iAndroid!". שימו לב שכדי להזין מחרוזת למשתנה, בניגוד לתו בודד, השתמשנים במרכאות (") ולא בגרש.


משתנים בוליאנים

משתנים בוליאנים יכולים להחזיק אחד משני הערכים הבאים: true או false (או "נכון" ו "לא נכון") להלן דוגמא:

[sourcecode language="java"]
boolean beautifullAndy

beautifullAndy = true;
[/sourcecode]

בדוגמא הזו הגדרנו משתנה בשם beautifullAndy והזנו לתוכו את הערך true. למרות שבמבט ראשון נראה כי השימוש בטיפוס boolean מיותר, מדובר למעשה באחד מטיפוסי המשתנים החשובים ביותר! שימו לב לדוגמא הבאה:

[sourcecode language="java"]
int x = 12;
int y = 6;
boolean isYBigger;

isYBigger = (y > x);
[/sourcecode]

קטע הקוד (y > x) שבשורה 5 בודק האם y גדול מ x.
חידה! מה יהיה לדעתכם הערך בתוך המשתנה הבוליאני isYBigger?
אם אמרתם ש- isYBigger שווה false, צדקתם. וזאת כי הערך 6 המוכל במשתנה y קטן מהערך 12 המוכל במשתנה x.

שימו לב גם לשימוש שעשינו לראשונה בסימן < כדי לבדוק האם y גדול מ x. הסימן < (גדול מ) ניקרא אופרטור והוא מביא אותנו לנושא הבא בשיעור שלנו.

אנדי

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

המורה ללשון: "ואלי לא התגעגעת?"

אנדי

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

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

אנדיאוי ואבוי!
שמישהו יעצור אותה!

אופרטורים

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

אופרטור דוגמא לשימוש תוצאה
+ x+y חיבור בין המשתנה x למשתנה y
x-y חיסור בין המשתנה x למשתנה y
* x*y הכפלת המשתנה x במשתנה y
/ x/y חילוק המשתנה x במשתנה y
= x=y הכנסת הערך y לתוך המשתנה x

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

"השמה" או "פקודת השמה" היא כל פקודה המזינה ערך חדש לתוך משתנה.

אנדיוהנה חידה:
מה יקרה בתוכנית הבאה:

[sourcecode language="java"]
int x = 12;
int y = 6;
boolean isEqual;

isEqual = y = x;
[/sourcecode]

נו? מה דעתכם?
יודעים כבר?
טוב, אז חלקכם בטח חושבים שהמשתנה isEqual יהיה שווה לערך false וזאת כי y לא שווה ל x.
אבל מה שיקרה בסופו של דבר הוא שהתוכנית פשוט תיכשל…
למה? פשוט בגלל שהאופרטור "=" הינו אופרטור השמה ולא אופרטור השוואה ולכן y = x בעצם גורם לך ש y יהיה שווה ל 12 (הערך של X), שזה לא בדיוק מה שרצינו לעשות, אבל תקין מבחינת המחשב. הבעיה היא שלאחר מכן הוא מבצע isEqual = y, כלומר להכניס את המספר 12 לתוך משתנה isEqual הבוליאני שיכול להכיל רק true ו- false. זאת פעולה בהחלט לא תקינה ותגרום כאמור לתוכנית להיכשל.

אז איך בעצם מבצעים השוואה בין משתנים?
להלן תיקון של התוכנית הקודמת:

[sourcecode language="java"]
int x = 12;
int y = 6;
boolean isEqual;

isEqual = (y == x);
[/sourcecode]

שימו לב, החלפנו בשורה חמש את y = x ל- y == x וזאת כי == מבצע פעולה השוואה בין המשתנים שנמצאים סביבו.

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

אופרטור דוגמא לשימוש תוצאה
== x==y בודק האם x שווה ל y
!= x != y בודק חוסר שיוויון! כלומר האם x אינו שווה ל y
> x > y בודק האם x גדול מ y
< x < y בודק האם x קטן מ y
>= x>=y בודק האם x גדול או שווה ל y
<= x<=y בודק האם x קטן או שווה ל y


ביטויים לבקרת זרימה

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

[sourcecode language="java"]
int x = 12;
int y = 6;

if (x > y)
{
y = x + 1;
}

[/sourcecode]

בקטע הקוד הרשום אנו מגדירים את המשתנה x ומכניסים לתוכו את הערך 12, מגדירים את המשתנה y ומכניסים לתוכו את הערך 6 ולבסוף שואלים "אם x גדול מ y" אז "הכנס ל y את הערך של x ותוסיף לו 1".
שימו לב לדגשים הבאים:
1. את התנאי עצמו (האם x גדול מ y) כותבים אחרי משפט ה if בתוך סוגריים.
2. שורת התנאי לא הסתיימה בסימן ; כמו שאר השורות שכתבנו עד עכשיו.
3. את קטע הקוד שיש לבצע באם התנאי כן מתקיים, שמנו בתוך סוגריים מסולסלים { } וזאת כדי לתחום אותו.
4. במידה ש x לא היה גדול מ y, כל קטע הקוד בתוך הסוגריים המסולסלים פשוט לא היה מתבצע והמחשב היה "מדלג" מעליו.
5. בתוך קטע התנאי (שורה 4) ניתן להשתמש בכל אופרטור השוואה שנראה לנו לנכון (ראו טבלה למעלה).

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

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

הידעת אנדי כי המילה העברית ל"עימוד קוד" היא "הזחה"?

אנדי

המ.. כן תודה לך. זה מאד מעשיר.

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

[sourcecode language="java"]
int x = 12;
int y = 6;

if (x > y)
{
y = x + 1;
}
else if (x < y)
{
x = y + 1;
}
else
{
x = x + 1;
y = y + 1;
}

[/sourcecode]

אני בטוח שמבלי לדעת מה אומרת שורה 8 ושורה 12, אתם כבר יכולים להבין את משמעות הקוד.
שורות 5 עד 7 מתרחשוב באם התנאי בשורה 4 מתקיים.
אחרת (כלומר, אם התנאי בשורה 4 לא מתקיים), המחשב בודק את התנאי שרשום בשורה 8 ורק אם הוא מתקיים, שורות 9 עד 11 יבוצעו.
אחרת (כלומר, במידה שאף אחד מהתנאים הללו לא מתקיים), שורות 13 עד 16 יתבצעו בכל מקרה.

אם x היה שווה ל- y אז התנאי בשורה 4 לא היה מתקיים וגם התנאי בשורה 8 לא היה מתקיים ומכאן שהתוכנית היתה מבצעת את שורות 13 עד 16.

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

[sourcecode language="java"]
int x = 12;
int y = 6;

if (x >= y)
{
if (x == y)
{
x = x + 1;
}
else
{
x = y + 1;
}
}
[/sourcecode]

ועוד דברים רבים אחרים שניתן לעשות.
כדאי לקרוא באופן מקיף על משפט ההתנאה if באינטרנט או בספר לימוד ה java שלכם.

לולאות

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

[sourcecode language="java"]
int x = 1;
int y = 100;

while (x < y)
{
x = x + 1;
}

y = 0;
[/sourcecode]

קטע הקוד שרשום בשורה 4 יבדוק האם המשתנה x קטן מהמשתנה y. במידה ותנאי הלולאה מתקיים, שורה 6 תתבצע ולמשתנה x יתווסף 1.
לאחר מכן תחזור התוכנית לבצע שוב את שורה 4 ותשאל "האם x קטן מ y ובמידה ותנאי הלולאה עדיין מתקיים, שוב שורה 6 תתקיים ולמשתנה x יתווסף 1.
לאחר מכן תחזור התוכנית לבצע שוב את שורה 4 ותשאל "האם x קטן מ y ובמידה ותנאי הלולאה עדיין מתקיים, שוב שורה 6 תתקיים ולמשתנה x יתווסף 1.
לאחר מכן תחזור התוכנית לבצע שוב את שורה 4 ותשאל "האם x קטן מ y ובמידה ותנאי הלולאה עדיין מתקיים, שוב שורה 6 תתקיים ולמשתנה x יתווסף 1.
ושוב ושוב ושוב ושוב ושוב…..
עד אשר התנאי שמוגדר בשורה 4, כבר לא יתקיים והתוכנית תוכל לצאת מהלולאה ולהמשיך הלאה (שורה 9 והלאה…).
במקרה הזה, הלולאה תתבצע 99 פעמים, עד אשר x יהיה שווה ל- 101 ותנאי הלולאה כבר לא יהיה נכון.

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

חידה! מתי לדעתכם תסתיים הלולאה הבאה:

[sourcecode language="java"]
int x = 0;

while (1 < 2)
{
x = x + 1;
}

y = 0;
[/sourcecode]

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

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

[sourcecode language="java"]
int y = 2;

for (int x = 1; x < 10; x++)
{
y = y * 2;
}
[/sourcecode]

הערת ביניים: הסימן ++ הינו אופרטור שמקדם את המשתנה שלו ב 1. כלומר x++ הוא בדיוק כמו לכתוב x = x + 1.

נחזור לקטע הקוד. שימו לב שבשורה 3 הגדרנו משתנה בשם x, הכנסנו לו את הערך 1, הגדרנו תנאי ללולאה (כל עוד x קטן מ- 10) וקבענו כי בכל מחזור של הלולאה, x יקודם באחד.
גם כאן ניתן להחליף את המספר 10 במשתנה אחר, את האופרטור > באופרטור אחר, את הערך ההתחלתי של x (אחד) בערך אחר וכדומה…
חידה! כמה יהיה שווה לדעתכם y בסוף הלולאה?

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

להריץ Java על Eclipse

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

היכנסו ל Eclipse, כפי שהוסבר בשיעור ב' (אין לכם Eclipse? לא עשיתם את שיעור ב'? זה הזמן לעבור לשם מהר ולבצע אותו!)
ביחרו ב- File ואז ב New ואז ב Java Project.
במסך שיפתח לכם, תחת Project Name רישמו את שם הפרויקט שלכם (לדוגמא, My First Java Project) ואז על Finish בתחתית.

תוכנית Java חדשה

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

מחלקה חדשה ב- Java

הסבר על השדות:

  1. Package: שם חבילת הקוד החדשה שאנו רוצים ליצור, או בחירה של חבילה קיימת.
  2. Name: שם המחלקה (Class) בתוך החבילה, שאנחנו רוצים ליצור.
  3. public static void main….: סימון התיבה אומר כי קטע קוד זה יכיל את "נקודת הכניסה" לתוכנית שנכתוב.

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

ליחצו על Finish ואמור להופיע לפניכם מסך חדש עם קטע הקוד הבא:

[sourcecode language="java"]
package iAndroid.academy;

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}

}
[/sourcecode]

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

[sourcecode language="java"]
package iAndroid.academy;

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
int y = 2;

for (int x = 1; x < 10; x++)
{
y = y * 2;
}

System.out.print("The value of Y is: ");
System.out.println(y);
}
}
[/sourcecode]

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

[sourcecode language="java" firstline="15"]
System.out.print("The value of Y is: ");
System.out.print(y);
[/sourcecode]

הפקודה System.out.print היא פונקציית פלט שמדפיסה מחרוזת מסויימת.
במקרה הזה ביקשנו מהמחשב להדפיס את המשפט The value of Y is ואז להדפיס את הערך שבמשתנה y.

בתוך Eclipse, התוכנית שלכם צריכה להיראות כך:

תוכנית Java

וכעת, ניתן סוף סוף להריץ את התוכנית!
בתפריט למעלה, ביחרו Run ואז Run.
התוצאה של התוכנית תודפס לכם בתחתית המסך, בתוך ה- Console.

תוצאת התוכנית

לסיכום

מה יקרה אם נכניס לתוך System.out.print משתנה בוליאני? מה קורה אם מדפיסים משתנה שרק הוגדר, אבל לא ניתן לו ערך? מה קורה אם נשים את System.out.print בתוך הלולאה עצמה?
אני מעודד אתכם לנסות וללמוד ואף לשתף אותנו בממצאים ובשאלות שלכם בפורום הפיתוח לאנדרואיד.
כמו כן, אל תהססו להשתמש באינטרנט או בספרים כדי ללמוד עוד על שפת Java ועל תיכנות מונחה עצמים.

עד כאן השיעור של היום, אני מקווה שנהנתם.
להית'!

Share

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

בואו ללמוד לפתח לאנדרואיד! אתם בטח זוכרים אותי בתור Andy מהבלוג הישן!

23 Comments

  1. אנדי
    09/05/2010 בשעה 12:05

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

    הצביעו והשפיעו!

  2. שחף
    09/05/2010 בשעה 12:30

    אני מעדיף ללמוד תכנות לאנדרויד כיוון שיש המון אתרים שמלמדים JAVA
    ואפשר מידי פעם לתת ריענון קצר על דברים מסובכים

    תודה ותמשיכו לעדכן

  3. גרובר
    09/05/2010 בשעה 12:43

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

  4. guest
    09/05/2010 בשעה 12:52

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

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

  5. ימחק
    09/05/2010 בשעה 13:04

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

  6. יאן
    09/05/2010 בשעה 13:57

    יש לי ידע בסיסי בתכנות בC ועכשיו לומד גם C++ וזה מאוד מזכיר את זה, בעצם זה כמעט זהה עד כה, ואני נהנה מאוד לקרוא וללמוד ומקווה שאוכל להגיע למצב שאוכל לתכנת ישום פשוט בזמן קצר. מקווה שזה יהיה אפשרי ומקווה שתתקדם יותר מהר עם הבלוג.
    יש לי שאלה, אצלי בECLIPSE לא מופיע מס' שורה של הקוד, איך אני מוסיף את האופציה?

  7. יאן
    09/05/2010 בשעה 13:58

    אני כמובן מעדיף עוד שיעורים בסייסים בJAVA.

  8. אלעד
    09/05/2010 בשעה 14:04

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

  9. המורה רוחמה
    09/05/2010 בשעה 14:05

    אחותך תקועה!

  10. nisim2337
    09/05/2010 בשעה 14:45

    את מה שנאמר פה למדתי לפני כמה ימים (בדיוק התחלתי JAVA) ואני חושב שעדיף שתלמדו ג'אוה זה יגרום להרבה יותר להיכנס לתחום

  11. ZooZ
    09/05/2010 בשעה 16:10

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

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

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

  12. גיבור
    09/05/2010 בשעה 17:34

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

  13. אנדי
    09/05/2010 בשעה 17:57

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

    תודה לכולם!

  14. הבן של המורה ללשון
    10/05/2010 בשעה 07:33

    אמרו "התניה" ולא "התנאה". אם כבר יש לזה מילה בעברית, למה להזמין חדשה?

    1. המורה רוחמה
      10/05/2010 בשעה 07:35

      הבן שלי?
      שֶׁסֶק? זה אתה?

      בכל מקרה, "הַתְנָאָה" היא בהחלט מילה תקינה בשפה העברית:
      http://morfix.mako.co.il/default.aspx?q=%u05D4%u05EA%u05E0%u05D0%u05D4

      ומתוך מילון אבן שושן:
      הַתְנָאָה – הַתְנָיָה, קְבִיעַת תְּנַאי לְדָבָר, בִּצּוּעַ מַשֶּׁהוּ בִּתְנָאִים מְסֻיָּמִים: הַתְנָאַת הַסִּיּוּעַ בְּהִתְחַיְּבֻיּוֹת כַּלְכָּלִיּוֹת.

  15. אין
    10/05/2010 בשעה 17:44

    תודה רבה!
    שיעור על אובייקטים יהיה חשוב…

    ושוב תודה רבה על ההשקעה.

  16. שמךsharon
    11/05/2010 בשעה 19:16

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

    למי שמעוניין להרחיב את היריעה ככלי עזר לקורס זה, מצאתי אתר שבו ניתן לצפות בהדרכות וידאו של Eclipsa and Java, ובנוסף להוריד קובץ PDF שמלווה את ההדרכה.
    כנסו ללינק:
    http://eclipsetutorial.sourceforge.net/totalbeginner.html
    http://eclipsetutorial.sourceforge.net/Total_Beginner_Companion_Document.pdf

  17. אוהלי
    15/05/2010 בשעה 12:45

    תודה על השיעור, אני בעד המשך ג'אווה,

  18. נדב
    02/07/2010 בשעה 06:05

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

  19. lior vaknin
    13/12/2010 בשעה 21:30

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

    תודה,

  20. רמי
    08/04/2011 בשעה 20:11

    תודה. אתם מקיימים גם קורס לא וירטואלי?

  21. ניב
    21/04/2011 בשעה 17:48

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

  22. עדו
    03/05/2011 בשעה 18:08

    אם למדתי פסקל ברמת 3 יחידות זה יעזור לי?

    כי זה ממש מזכיר את זה

השאר תגובה