שיעורי JAVA

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

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

לאחר שהתקנתם את התוכנה, נתחיל להבין את הפיתוח הראשוני בג'אווה ואיך מציגים הודעה למשתמש בצורה הפשוטה ביותר והראשונית ביותר:
כל מסמך קוד בג'אווה נקרא class. כמו שיש לנו לכל מסמך WORD את הDOC שלו, כל מסמך טקסט את הTXT, כל דף באתר את הHTML שלו - במקרה של java חובה לפתוח class חדש. בלחיצה ימנית נוכל לבצע זאת, יש שם classים שונים ומגוונים - אנו נבחר תחילה בclass הבסיסי והראשוני, שימו לב להדרכה בסרטון.

תמיד כל class ייפתח בשורה הבאה (בהנחה ששם הclass שבחרנו הוא first. ניתן לבחור כל שם שעולה על דעתכם.) -

    public class first{
    }

בתוך הclass אנו נזין קטעי קוד שונים, או מה שנקרא 'פונקציות' (ראה ערך 'פונקציות' במדריך הלוגיקה). הפונקציה הראשית שחייבת להיות בclass הראשי שלי נקראת main. גם כאן, בלי להסביר מה המשמעות בהתחלה, אבקש מכם לכתוב אותה.
    public static void main(){
    }
כך שבסופו של דבר הclass ייראה כך:
    public class first{
    public static void main(){
    }
    }
לסיום, נלמד את הפקודה הראשונית בג'אווה. פקודת הדפסה למשתמש.
כאשר נכתוב בתוך פונקצית הmain הראשית (כשמה כן היא) נוכל להציג למשתמש מסרים והוראות. רק דרכה.
במידה ונכתוב בתוכה את הקוד הבא: System.out.print("Hello!"); יוצג בפני המשתמש המילה Hello. שתי הערות: 1. ניתן כמובן לשנות בתוך הסוגריים למספרים, פעולות מתמטיות וחישוביות. לא חובה רק טקסטים. 2. נא להקפיד על אותיות גדולות וכתיבה נכונה.



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

בשיעור הבא, נלמד איך לשמור משתנים בג'אווה (ראו ערך שיעור 'משתנים' במדריך הלוגיקה) וכן גם לאט לאט נבין מה אומרים כל המילים שטרם הסברתי (public,static,void ועוד)...

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

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

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

    public class first{
    int num = 5;
    public static void main(){
    System.out.print(num+num)
    }
    }
בדוגמא זו, יוצג עבור המשתמש המספר 10.

אילו עוד סוגי משתנים יש לנו בג'אווה?
  • מחרוזת וטקסטים - String
  • מספרים שלמים - int
  • שני סוגים שימושיים פחות, הדומים ל-int אך בעלי טווח קטן יותר. מועילים בדרך כלל במצבים בהם יש צורך לחסוך בזיכרון. - byte / short
  • אותיות ותווים - char
  • מספרים עם נקודה עשרונית. לדוגמה: 1.5 , 3.278 - float
  • אופרטור בוליאני, כלומר - משתנה המסוגל להכיל "אמת" או "שקר" בלבד - boolean



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

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

על מנת לשדרג את הקוד שלנו ולהתממשק דרכו עם המשתמש, נוכל למשוך קטעי קוד שכתבו עבורינו מתכנתי ג'אווה. קטעי הקוד הללו שנמשוך לתוך הקוד שלנו, הם קטעי קוד שלא חלק מהג'אווה הבסיסית אלא צריך לבצע import (יבוא) שלהם לclass שלנו. הדבר יצור לכתיבה דרך המקלדת ממש בתוך הconsole שלנו. שימו לב גם לסרטוני ההסבר (גם בשיעור 2).

ראשית, מעל הclass במעלה הדף נוסיף ייבוא. ניתן לייבא clssים שונים וחיצוניים.
כעת, נלמד על הScanner.
import java.util.Scanner;

בשלב זה עדיין לא נעסוק באובייקטים ובבנאים (Constructors), ובשורות הבאות נשתמש בהם מבלי להבין לגמריאת משמעותם. בתוך מתודת ה-main נכתוב את השורות הבאות:
Scanner s = new Scanner(System.in);
שורה זו מאתחלת אובייקט מטיפוס Scanner בשם s, המקבל כפרמטר את זרם הקלט.
כאמור - בשלב זה עדיין לא נמצאים בידינו הכלים להבין שורה זו.
int num = s.nextInt();
למעשה, אחרי שייבאנו ואחרי שהגדרנו שהמשתנה s הוא מסוג טיפוס Scanner, ניתן ליצור את ההקלדה בתוך גוף הconsole. כל שנצטרך לעשות הוא להוסיף את השורה הנ"ל, להגדיר משתנה int שהוא מספר ולהגדיר לו שהוא nextInt , כלומר מחפש מספר.
מה שיקרה עכשיו, ברגע שהרובוט יגיע לשורה הזו, הוא יפתח בפני המשתמש אפשרות להזין מספר. צריך להקליד ואז המספר שהוזן נשמר לתוך המשתנה num.

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

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





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

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

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

    public class Value{
    public int num = 0;
    }

    import java.util.Scanner;

    public class first{
    public static void main(){
    Scanner scan = new Scanner(System.in);
    num = scan.nextInt();
    System.out.print("המספר שלך הוא : " + num);
    }
    }

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




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

בואו נדגים על חתול.
צרו class בשם cat.
לכל חתול יש תכונות בסיסיות כמו צבע, גיל ושם.
לכן, הclass שלנו ייראה תחילה כך:

    public class cat{
    private String color = "white";
    private int age = 3;
    private String name = "whiskey";
    }
    }
השלב הבא שנרצה לעשות הוא לקלוט בmain הראשי שלנו, מהclass שמדבר עם המשתמש, תכונות של חתול על פי יצירת המשתמש וליצור את החתול בצורה מסודרת באמצעות האובייקט.

עלינו ליצור Constructors (בנאי), כלומר פונקציה שלמה שעוסקת רק בקליטה של התכונות על ידי המשתמש.
למעשה, הבנאי תמיד ייראה בהישענות על המשתנים הקיימים בclass מראש. ראו בסרטון.
    public Cat(String color , int age , String name){
    this.color = color;
    this.age = age;
    this.name = name;
    }
    }
2 הערות: 1. כעת, יש לנו פונקציה בשם Cat שהיא public, כלומר, ניתן מclass אחר (מהclass הראשי במקרה שלנו) לדבר איתה. לכתוב בו : Cat("blue",1,"bub"); ויווצר חתול באופן וירטואלי שיש לו צבע כחול, הוא בן שנה וקוראים לו בוב. 2. המונח this מסמן את הבנת ההשמה בשלב הבנאי. אנו רוצים שתתבצע השמה, בתוך הסוגריים של הפונקציה אנו מקבלים ערך מהמשתמש כביכול ומזינים אותו לתוך המשתנה של האובייקט. הטכניקה הזו עובדת. כמו בהשמה. הthis מסמן את הcolor של האובייקט ולא את הcolor מהפונקציה. הרי לשתי המשתנים קוראים color. (למען ויתור על הthis ולהסיר את הבלבול, ניתן לשנות את שמות המשתנים).

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

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





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

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

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

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

    public class Animal{
    private Boolean mammal = true;
    }
    public Animal(Boolean mammal){
    this.mammal = mammal;
    }
    }

    public class Cat extends Animal{
    private String color = "white";
    }
    public Cat(String color, Boolean mammal){
    super(mammal);
    this.color = color;
    }
    }



מכאן, נוכל להסיק כי:
1. השימוש במילה super קורה בתוך הבנאי של הבן. הוא זה שמייבא את כל התכונות מהאב.
2. אנו יכולים פשוט להזין את שם התכונה שם האבא בסוגריים של הבנאי בבן ביחד עם תכונות הבן.
3. ניתן לבצע גם פולימורפיזם. הכוונה היא שניתן ליצור אובייקט של האב ולהציג את הבן: Animal a1 = new Cat("white",true); ובכך אנו מייצרים חיה מסוג חתול...

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

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

באמירה "לא ניתן לייצר אותה" אני מתכוון לכך שלא יהיה ניתן לבצע דרכה פולימורפיזם או ליצור אובייקט שלה. לצורך העניין, נכון לרגע זה אני יכול בקלות לכתוב את הקוד הבא בקוד הmain שלי: Animal a1 = new Animal(true); (שוב, בהתבסס על שיעור 6 ועל המחלקה של החיה עם הבנאי שמכיל רק משתנה בוליאני).

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

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


    public abstract class Shape {
    private int ribs = 0;
    private String color = "white";
    }
אם נכתוב מחלקה מופשטת - לא נוכל ליצור אובייקט שלה, אך ניתן להרחיב אותה בעזרת מחלקה רגילה וליצור אובייקט של המחלקה הרגילה הזאת. מחלקה מופשטת יכולה להכיל גם שיטות מופשטות, כלומר - שיטות לא ממומשות (לא כתובות; שיטות שרק הכרזנו עליהן באמצעות הכותרת אך לא כתבנו בהן קוד כלשהו), המיועדות להתממש על ידי מחלקה יורשת כלשהי.
    public abstract class Shape {
    private int ribs = 0;
    private String color = "white";
    public abstract void myMethod(); }





בהמשך לשיעור 8 אלמד אתכם פה על ממשקים (Interfaces).
אם נשים לב כאשר נפתח מחלקה חדשה בbluej נוכל ליצור גם interface ולא class.

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

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

    interface Actions{
    public void drinkmilk();
    }

    public class Cat extends Animal implements Actions{
    private String color = "white";
    }
    public Cat(String color, Boolean mammal){
    super(mammal);
    this.color = color;
    }
    public void drinkmilk(){
    System.out.println("DrinkMilk Now!!!");
    }
    }





🔝