שיעור פרטי בתכנות מונחה עצמים עם AI
ללמוד תכנות מונחה עצמים ב-Java: ממחלקה ראשונה ועד עיצוב לפי עקרונות SOLID
המורה: נועם
- התוכנית עודכנה 11.2026
- עברית, ועוד 5 שפות
- 3 רמות: מתחילים · ממשיכים · מתקדמים
- 35 שיעורים · כ־19 שעות של שיעורים
תכנות מונחה עצמים
ללמוד תכנות מונחה עצמים ב-Java: ממחלקה ראשונה ועד עיצוב לפי עקרונות SOLID
11 שיעורים · 3 פרקים · שיעור חי פרטי עם המורה על הלוח
מה תדעו לעשות בסוף
- להסביר מהו אובייקט (מצב, התנהגות וזהות) ולמה הוא עדיף על משתנים מפוזרים
- לכתוב מחלקה ב-Java עם שדות וליצור ממנה כמה אובייקטים בעזרת new
- לצייר את הזיכרון ולחזות את תוצאת השמת הפניות, כולל null
- לכתוב מתודות מופע ובנאים מועמסים, כך שכל אובייקט נוצר במצב תקין
- לבחור נכון בין שדה או מתודה של מופע לבין static
- להגן על האובייקט עם private ולכתוב getters ו-setters שבודקים תקינות
- להבחין בין == ל-equals ולכתוב toString ו-equals פשוטים
- לגזור מתיאור מילולי מחלקה מכומסת עם UML ולהצדיק כל החלטת עיצוב
- לזהות יחס is-a ולכתוב מחלקה יורשת עם extends
- לכתוב בנאי שקורא ל-super ולעקוב אחרי סדר הבנייה בשרשרת ירושה
- לדרוס מתודה, להרחיב אותה עם super.method() ולהבדיל בין דריסה להעמסה
- לשרטט ב-UML היררכיית ירושה בכמה רמות, עם Object בראשה
- לקבוע לפי הטיפוס הסטטי והדינמי אילו קריאות יעברו קומפילציה
- לנבא מה יודפס בקוד פולימורפי, כולל קריאות בתוך מתודות ו-super
- לבצע downcasting בטוח עם instanceof ולכתוב לולאה פולימורפית על מערך מטיפוס הבסיס
- להגדיר מחלקה מופשטת וממשק, לממש Comparable ולנמק מתי לבחור בכל אחד
- להבחין בין ירושה, הרכבה, צבירה ואסוציאציה ולשרטט כל יחס ב-UML
- להמיר ירושה שבירה להרכבה עם האצלה, ולהחליף היררכיה בממשק Strategy
- לפצל מחלקת-אלוהים למחלקות לכידות עם צימוד נמוך (S)
- להחליף שרשרת switch בפולימורפיזם, כך שסוג חדש נוסף בלי לשנות קוד קיים (O)
- לבדוק אם תת-מחלקה ניתנת להחלפה לפי תנאי קדם, תנאי בתר ושמורות (L)
- לפצל ממשק שמן לפי לקוח, להזריק תלויות דרך הבנאי ולבדוק מחלקה בבידוד עם fake
- לממש גרסה פשוטה של Factory או Observer ולהסביר איזה עיקרון היא משרתת
- להפוך דרישות מילוליות למחלקות ולדיאגרמת UML ולסקור את העיצוב מול SOLID
בסוף כל רמה המורה בודק שזה באמת ברור, לא רק שעברנו על החומר
נושאים קשורים
הקורס כולל
- שיעורים חיים 1:1 עם מורה פרטי AI על לוח
- 19 שעות של שיעורים חיים אחד על אחד
- 35 שיעורים על לוח משותף, כל אחד עם יעד ברור
- תרגול ובדיקת הבנה בכל שיעור
- סיכום אחרי כל שיעור, שנשמר בהיסטוריה
- תעודת סיום לכל רמה
- מחשב, טאבלט או טלפון
- עברית, ועוד 5 שפות
תוכנית הקורס
3 רמות · 10 פרקים · 35 שיעורים · 19 שע׳ בסך הכול
מתחיליםמתחילים: מחלקות, אובייקטים וכימוס3 פרקים • 11 שיעורים • 6 שע׳
הלומד/ת יגדיר/תגדיר מחלקה ב-Java עם שדות, בנאים ומתודות, ייצור/תיצור ממנה אובייקטים, יגן/תגן על המצב שלהם בעזרת כימוס, וימדל/תמדל ישות פשוטה כ-UML.
מהמשתנה לאובייקט3 שיעורים • 1 שע׳ 35 דק׳
- 1למה בכלל אובייקטים?להסביר מה זה אובייקט (מצב, התנהגות וזהות) ולמה הוא עדיף על הרבה משתנים מפוזרים.שיעור ניסיוןכ־30 דק׳
- 2מחלקה ואובייקט: תבנית ומופעלכתוב מחלקה פשוטה ב-Java וליצור ממנה כמה אובייקטים עם new.כ־30 דק׳
- 3שדות, הפניות ו-nullלצייר מה קורה בזיכרון כשמשתנה מפנה לאובייקט, ולחזות את התוצאה של השמת הפניות.כ־35 דק׳
מתודות ובנאים4 שיעורים • 2 שע׳ 10 דק׳
- 4מתודות: האובייקט עושה דבריםלכתוב מתודות מופע שקוראות ומשנות את מצב האובייקט, עם פרמטרים, ערך מוחזר ו-this.כ־35 דק׳
- 5בנאים: אובייקט שנולד תקיןלכתוב בנאים, כולל העמסה, כך שכל אובייקט נוצר כבר במצב תקין.כ־30 דק׳
- 6אובייקטים שעובדים יחדלהעביר אובייקטים כפרמטרים, להחזיק אובייקט כשדה ולנהל מערך של אובייקטים.כ־35 דק׳
- 7static: מה שייך למחלקה כולהלהבחין בין שדות ומתודות של מופע לבין static, ולבחור נכון ביניהם.כ־30 דק׳
כימוס: להגן על האובייקט4 שיעורים • 2 שע׳ 15 דק׳
- 8private ו-public: מי רשאי לגעתלהסביר למה מסתירים שדות, ולהחליט מה private ומה public במחלקה.כ־30 דק׳
- 9getters, setters ושמירת חוקיםלכתוב getters ו-setters עם בדיקות תקינות, ולשמור על חוקי האובייקט (invariants) בכל רגע.כ־35 דק׳
- 10toString ו-equals: זהות מול שוויוןלהבחין בין == ל-equals, ולכתוב toString ו-equals פשוטים למחלקה.כ־30 דק׳
- 11פרויקט: מידול מחלקה מאפסלקחת תיאור מילולי, לגזור ממנו מחלקה מכומסת עם UML ולהצדיק כל החלטת עיצוב.כ־40 דק׳
ממשיכיםממשיכים: ירושה, פולימורפיזם וממשקים3 פרקים • 12 שיעורים • 6 שע׳ 25 דק׳
הלומד/ת בונה היררכיית מחלקות עם ירושה, מנבא/ת איזו מתודה תרוץ בכל קריאה פולימורפית, ובוחר/ת בין מחלקה מופשטת לממשק ומנמק/ת את הבחירה.
ממופה למבחן: בגרות מדעי המחשב 5 יח"ל — עיצוב תוכנה (ירושה, פולימורפיזם, מחלקות מופשטות וממשקים)
ירושה: מחלקה שבונה על מחלקה4 שיעורים • 2 שע׳ 5 דק׳
- 1extends: יחס is-a ושימוש חוזר בקודלזהות יחס is-a, לכתוב מחלקה יורשת עם extends ולדעת מה עובר אליה מהמחלקה הבסיסית.כ־30 דק׳
- 2super ובנאים: איך נולד אובייקט יורשלכתוב בנאי של מחלקה יורשת שקורא ל-super, ולעקוב אחרי סדר הבנייה בשרשרת ירושה.כ־30 דק׳
- 3דריסה (Override) מול העמסה (Overload)לדרוס מתודה במחלקה יורשת, להרחיב אותה עם super.method(), ולהבדיל בינה לבין העמסה.כ־35 דק׳
- 4Object בראש העץ: היררכיה ו-UMLלשרטט היררכיית ירושה בכמה רמות ב-UML, ולהבין ש-toString ו-equals הם דריסות של Object.כ־30 דק׳
פולימורפיזם: הפניה אחת, התנהגויות רבות4 שיעורים • 2 שע׳ 5 דק׳
- 5הפניה מטיפוס הבסיס: טיפוס סטטי ודינמילהבחין בין הטיפוס הסטטי של משתנה לטיפוס הדינמי של האובייקט, ולקבוע אילו קריאות יעברו קומפילציה.כ־30 דק׳
- 6קישור דינמי: איזו מתודה תרוץ באמתלנבא בדיוק מה יודפס בקוד פולימורפי, כולל קריאות בתוך מתודות ו-super, כמו בשאלות מעקב בבגרות.כ־35 דק׳
- 7instanceof והמרה מטה (downcasting)לבצע המרה מטה בבטחה עם instanceof, ולזהות מתי הצורך בה מעיד על עיצוב חלש.כ־30 דק׳
- 8מערכים פולימורפיים: קוד אחד לכל הסוגיםלכתוב לולאה ומתודות שעובדות על מערך מטיפוס הבסיס, ולהוסיף סוג חדש בלי לשנות אותן.כ־30 דק׳
מחלקות מופשטות וממשקים4 שיעורים • 2 שע׳ 15 דק׳
- 9מחלקה מופשטת: תבנית שאי אפשר ליצורלהגדיר מחלקה ומתודות abstract, לממש אותן ביורשות ולהסביר למה אי אפשר ליצור מופע של הבסיס.כ־30 דק׳
- 10ממשקים: חוזה של יכולתלהגדיר ממשק, לממש כמה ממשקים במחלקה אחת ולהשתמש בממשק כטיפוס של משתנה ופרמטר.כ־35 דק׳
- 11Comparable ובחירה: מופשטת או ממשק?לממש Comparable כדי למיין אובייקטים, ולנמק מתי לבחור מחלקה מופשטת ומתי ממשק.כ־30 דק׳
- 12פרויקט: היררכיה שלמה לתחום קטןלתכנן ולממש היררכיה עם מחלקה מופשטת, ממשק וקוד פולימורפי לתחום אמיתי, ולנמק כל החלטת עיצוב.כ־40 דק׳
מתקדמיםמתקדמים (מקצועי): עיצוב מונחה עצמים4 פרקים • 12 שיעורים • 6 שע׳ 35 דק׳
הלומד/ת ממדל/ת תחום קטן כמחלקות, בוחר/ת בין הרכבה לירושה ומנמק/ת, ובודק/ת את העיצוב מול עקרונות SOLID כמו מפתח/ת בכיר/ה.
הרכבה מול ירושה3 שיעורים • 1 שע׳ 35 דק׳
- 1has-a מול is-a: הרכבה, צבירה ואסוציאציהתבחין/י בין ירושה, הרכבה, צבירה ואסוציאציה, ותשרטט/י כל יחס נכון ב-UML.כ־30 דק׳
- 2כשירושה נשברת: מחלקת בסיס שבירה והאצלהתזהה/י מתי ירושה חושפת פרטי מימוש ושוברת קוד, ותמיר/י אותה להרכבה עם האצלה (delegation).כ־35 דק׳
- 3Strategy: התנהגות כאובייקט שמחליפיםתחליף/י היררכיית ירושה מתפוצצת בממשק התנהגות שמוזרק בהרכבה ואפשר להחליף בזמן ריצה.כ־30 דק׳
עקרונות SOLID5 שיעורים • 2 שע׳ 40 דק׳
- 4S: אחריות אחת, לכידות וצימודתזהה/י מחלקת-אלוהים, תמצא/י בה כמה סיבות לשינוי, ותפצל/י אותה למחלקות לכידות עם צימוד נמוך.כ־30 דק׳
- 5O: פתוח להרחבה, סגור לשינויתחליף/י שרשרת switch על סוג בהיררכיה פולימורפית, כך שסוג חדש נוסף בלי לגעת בקוד קיים.כ־30 דק׳
- 6L: עקרון ההחלפה של ליסקוב וחוזיםתבדוק/י אם תת-מחלקה באמת ניתנת להחלפה בבסיס שלה לפי תנאי קדם, תנאי בתר ושמורות.כ־35 דק׳
- 7I ו-D: ממשקים רזים והיפוך תלותתפצל/י ממשק שמן לממשקים לפי לקוח, ותגרום/י למודול עליון להיות תלוי בהפשטה ולא במימוש מוחשי.כ־35 דק׳
- 8הזרקת תלויות וקוד שאפשר לבדוקתעביר/י תלויות דרך הבנאי במקום ליצור אותן בפנים, ותכתוב/י מימוש מזויף (fake) שמאפשר לבדוק מחלקה בבידוד.כ־30 דק׳
כלים של מעצב: אי-שינוי ותבניות2 שיעורים • 1 שע׳ 5 דק׳
- 9אובייקטי ערך ואי-שינוי (Immutability)תבנה/י מחלקת ערך בלתי משתנה עם equals ו-hashCode עקביים, ותסביר/י מתי אי-שינוי מונע באגים.כ־30 דק׳
- 10Factory ו-Observer: תבניות עיצוב שימושיותתזהה/י בעיה שמתאימה ל-Factory או ל-Observer, תממש/י גרסה פשוטה ותסביר/י איזה עיקרון SOLID היא משרתת.כ־35 דק׳
מידול בעיה מקצה לקצה2 שיעורים • 1 שע׳ 15 דק׳
- 11מדרישות למחלקות: שמות עצם, פעלים ו-CRCתהפוך/תהפכי תיאור דרישות מילולי לרשימת מחלקות, אחריויות ויחסים, ותשרטט/י דיאגרמת UML ראשונה.כ־35 דק׳
- 12פרויקט: מידול תחום ונימוק העיצובתמדל/י תחום קטן מאפס, תנמק/י כל בחירה בין ירושה להרכבה ותעביר/י את העיצוב סקירה מול SOLID.כ־40 דק׳
מה צריך
- היכרות בסיסית עם Java: משתנים, תנאים, לולאות ומערכים
- מחשב עם סביבת פיתוח ל-Java, או נכונות להתקין אחת
- מחשב, טאבלט או טלפון עם מיקרופון, ודפדפן
על הקורס
קורס בשלוש רמות: מחלקות, אובייקטים וכימוס; ירושה, פולימורפיזם וממשקים; ועיצוב מקצועי עם הרכבה ו-SOLID. כל שיעור הוא אחד על אחד על לוח משותף: כותבים קוד, מציירים UML ומנבאים מה יודפס, צעד אחר צעד.
למי הקורס
- מי שמכיר משתנים ולולאות ב-Java ורוצה להבין מחלקות ואובייקטים
- תלמידים שמתכוננים לבגרות במדעי המחשב ברמת 5 יח"ל
- מי שכותב קוד ורוצה לעצב אותו בצורה נקייה, גמישה וקלה לבדיקה
מבחנים והסמכות
- ממשיכים: בגרות מדעי המחשב 5 יח"ל — עיצוב תוכנה (ירושה, פולימורפיזם, מחלקות מופשטות וממשקים)
קורסים נוספים במסלול
המורה שלך
נועםמורה AI פרטי, בשיעור חי על לוח משותףמורה AI פרטי שמלמד בשיחה חיה: שואל, מקשיב, מצייר על הלוח ונותן לפתור לבד עם רמזים. זוכר מה למדתם ומתחיל כל שיעור מהמקום שעצרתם.
איך נראה שיעור?
הילד מדבר עם המורה בקול, כמו בשיחת וידאו, ושואל מה שלא ברור.
המורה מסביר, כותב ומצייר על לוח משותף, והילד פותר איתו על אותו לוח.
אפשר לצלם דף עבודה או שיעורי בית וללמוד ממנו, תרגיל אחרי תרגיל.
ההורה מקבל דוח: זמן לימוד, מה הצליח ומה כדאי לחזק.
כללי השיעור
- רק לימוד
שאלות נפוצות
- איך עובד שיעור פרטי בתכנות מונחה עצמים?
- בוחרים תכנות מונחה עצמים ורמה, ומדברים עם המורה בקול. המורה שואל מה כבר ידוע, מסביר, כותב ומצייר על הלוח, ונותן לפתור לבד עם רמזים עד שהעניין ברור.
- כמה זמן לוקח הקורס תכנות מונחה עצמים?
- 11 שיעורים של כ־33 דקות ברמה הראשונה, בקצב שלך. אפשר לעצור, לחזור ולדלג על מה שכבר ידוע.
- צריך ידע קודם?
- לא ברמת המתחילים. בתחילת השיעור הראשון המורה בודק מה כבר ידוע ומתאים את הרמה, ואפשר להתחיל ישר מרמה מתקדמת.
- איך מתחילים בחינם?
- נכנסים עם חשבון Google או עם קוד שנשלח למייל, כותבים שם וכיתה של הילד, והשיעור מתחיל מיד. כל משפחה מקבלת 45 דקות שיעור חינם, בכל מקצוע, לפי זמן השיעור בפועל, בלי כרטיס אשראי. אחר כך בוחרים מנוי בתשלום, ומבטלים בכל עת.
- על איזה מכשיר לומדים?
- בכל מחשב, טאבלט או טלפון עם דפדפן ומיקרופון. אפשר גם להתקין את האתר כאפליקציה במסך הבית.
רוצים לנסות?
נכנסים, כותבים שם וכיתה של הילד, והשיעור מתחיל. 45 דקות שיעור חינם, בלי כרטיס אשראי.
להתחיל בחינםשיעור פרטי עם AI: מה זה ואיך זה עובד







