דף כללים במדעי המחשב לבגרות
כל הכללים לשינון לפי נושא. ההסברים, דרכי הפתרון והדוגמאות - בסיכום של כל נושא.
הבגרות במדעי המחשב: השאלונים ודרכי התשובה
מבנה השאלונים כפי שהוא מודפס
899371: פרק א 2 מתוך 3 × 20, פרק ב 2 מתוך 3 × 30, שעתיים וחצי · 899271: פרק א 2 מתוך 3 × 25, פרק ב 2 מתוך 3 × 25 ממסלול אחד, שלוש שעות
מה במיקוד תשפ"ז ומה לא
תשפ"ז, 899371: בלי מערך של עצמים, עם מערך דו-ממדי · 899271: בלי מחסנית, בלי רשימה דו-כיוונית, בלי עץ חיפוש בינרי
מה כל שאלת מעקב מבקשת
מחזירה = טבלה + "הפעולה מחזירה..." · פלט = כל מה שמודפס בסדר · מה מבצעת = מטרה במשפט, לכל קלט · רקורסיה = שורה לכל קריאה
המילים בשאלה ומה הן אומרות בקוד
מחזירה = return · מדפיסה = void + הדפסה · חיצונית = public static · פנימית = בלי static, עם התכונות · "יש להשתמש בפעולה מסעיף..." = קוראים לה
Java מול C#: ההבדלים שחוזרים בבגרות
boolean/bool · String/string · length/Length · charAt(i)/s[i] · println/WriteLine · Queue<Integer>/Queue<int> · שמות פעולות באות קטנה/גדולה
סדרי הגודל הנפוצים
O(1) = פעולות הממשק · O(n) = מעבר אחד · O(n²) = לולאה בתוך לולאה או n קריאות ל-O(n) · O(log n) = חצייה בכל צעד
מושגי יסוד בתכנות: משתנים, ביטויים, קלט ופלט
הטיפוסים הבסיסיים
int = שלם · double = ממשי · char = תו בגרש בודד · boolean / bool = true או false · String / string = מחרוזת במירכאות
הגדרה, אתחול והשמה
הגדרה ואתחול: int count = 0; · השמה x = ביטוי; מעתיקה את ערך הביטוי ל-x · = השמה, == השוואה
מה הערך של הביטוי
7 / 2 = 3 · 7.0 / 2 = 3.5 · 7 % 2 = 1 · (double) sum / num = ממוצע ממשי · (int) 4.79 = 4, קטיעה
חלוקה ושארית על ספרות ועל התחלקות
n % 10 = ספרת האחדות · n / 10 = מוחקים את ספרת האחדות · n / 10 % 10 = ספרת העשרות · n % k == 0 = n מתחלק ב-k
סדר הפעולות וסוגריים
* / % לפני + - · אותה רמה: משמאל לימין · סוגריים קודם
קליטה והדפסה ב-Java וב-C#
קליטה: scan.nextInt() / int.Parse(Console.ReadLine()) · scan.nextDouble() / double.Parse(Console.ReadLine()) · println / WriteLine יורדות שורה, print / Write לא
שרשור מחרוזות: הסדר קובע
"sum: " + 1 + 2 = sum: 12 · "sum: " + (1 + 2) = sum: 3 · 1 + 2 + " is sum" = 3 is sum
הפעולות של Math
Math.abs · Math.max / Math.min · Math.pow(a, b) ו-Math.sqrt(x) מחזירות double · (int) Math.sqrt(n) = השורש השלם · ב-C# באות גדולה: Math.Sqrt, Math.Pow, Math.Max
תבנית: הגרלת מספר שלם בתחום
Java: rnd.nextInt(n) או (int) (Math.random() * n) = 0 עד n-1 · C#: rnd.Next(n) = 0 עד n-1, rnd.Next(a, b + 1) = a עד b
ביצוע מותנה וביצוע חוזר
פעולות השוואה ופעולות בוליאניות
== != > >= < <= · וגם && · או || · לא ! · && אמת רק אם שניהם אמת · || שקר רק אם שניהם שקר
המילים בשאלה והסימן בקוד
ומעלה / לפחות = >= · גדול מ / מעל = > · גבוה ב-10 לפחות מ-max = speed >= max + 10 · לפחות אחד מהמקרים = || · וגם = &&
ענפים נפרדים מול שרשרת else if
כמה if נפרדים = כל תנאי נבדק, כמה גופים יכולים להתבצע · if - else if - else = בדיוק גוף אחד, הראשון שמתקיים
כמה פעמים הלולאה רצה
i = 0; i < n → n סיבובים (0..n-1) · i = 1; i <= n → n סיבובים · i = low; i <= high → high - low + 1 · i < arr.length - 1 כשניגשים ל-arr[i+1]
for או while
ידוע כמה פעמים → for · נעצרת לפי תנאי או לפי ערך זקיף → while · while בודקת לפני כל סיבוב, ויכולה לא לרוץ אף פעם
תבנית: לולאת זקיף
זקיף: קליטה לפני הלולאה · while (הערך אינו הזקיף) · בגוף: טיפול, ואז קליטה של הבא כהוראה אחרונה · הזקיף לא נספר
ערך התחלתי ועדכון לכל תפקיד
צובר: 0, sum += x · מונה: 0, count++ בתנאי · דגל: false, = true בתנאי · מקסימום/מינימום: הערך הראשון · ממוצע: (double) sum / n אחרי הלולאה
רוב, חצי וממוצע
ממוצע = (double) sum / n · רוב = count > n / 2.0 · לפחות חצי = count * 2 >= n · "אחד או יותר" = דגל
הביטויים שחוזרים
ספרת אחדות = num % 10 · מוחקים אחדות = num / 10 · עשרות = (num / 10) % 10 · k ימניות = num % 10^k · k שמאליות = לחלק ב-10, len - k פעמים · חד-ספרתי = num < 10
תבנית: מעבר על כל הספרות
while (temp > 0) { digit = temp % 10; ... ; temp = temp / 10; } · מספר הסיבובים = מספר הספרות
כמה פעמים הגוף הפנימי מתבצע
n סיבובים × m סיבובים = n·m · פנימית עד i = 1 + 2 + ... + n · קריאה לפעולה עם לולאה בתוך לולאה - גם כפל
פעולות, מחרוזות ותווים
תבנית: פעולה שמחזירה ופעולה שקוראת לה
public static <טיפוס מוחזר> name(<טיפוס> p1, <טיפוס> p2) · void = לא מחזירה · return מסיים את הפעולה · בלי פרמטרים: ()
איך קוראים לפעולה, לפי מה שהיא מחזירה
int: x = f(a) · boolean: if (f(a)), !f(a) · מערך: int[] r = f(arr) · void: f(a); לבד · ארגומנטים באותו סדר וטיפוס כמו בכותרת
הפעולות של מחרוזת
אורך: s.length() / s.Length · תו: s.charAt(i) / s[i] · מקום: indexOf / IndexOf, לא נמצא = -1 · מכילה: contains / Contains · שרשור: +
תו מול מחרוזת
char: 'A' גרשיים, תו אחד, משווים ב-== · String: "A" מירכאות · s.charAt(i) / s[i] מחזירה char
מערכים
הגדרה, אתחול, גישה ואורך
int[] arr = new int[n]; - n תאים, בכולם 0 · int[] a = {2, 3, 5}; · התא הראשון a[0], האחרון a[a.length - 1] · אורך: length ב-Java, Length ב-C#
מערך כפרמטר וכערך מוחזר
מקבלת: int[] arr · מחזירה: טיפוס int[] · מערך חדש: new int[arr.length] ואחר כך return result;
משימות הסריקה
סכום sum += arr[i] · מנייה count++ · מקסימום מתחיל ב-arr[0] · קיום: return true בלולאה, false אחריה · כל: return false בלולאה, true אחריה · מקום: return i, אחרי הלולאה -1
תבנית: החלפה והזזה ימינה
החלפה: temp = a[i]; a[i] = a[j]; a[j] = temp; · הזזה ימינה: k מ-length - 1 יורד עד 1, a[k] = a[k - 1] · מערך עזר: temp[k] = ...; k++; ובסוף מעתיקים בחזרה
מה נכנס לתא, ואיזה תא
גודל = מספר הקטגוריות (קוד 0-99 → new int[100]) · מנייה: counters[x]++ · צבירה: sums[x] += value · new מאתחל ל-0
התחביר ב-Java וב-C#
Java: int[][] m = new int[r][c]; · m[i][j] · שורות m.length, עמודות m[0].length · C#: int[,] m = new int[r, c]; · m[i, j] · m.GetLength(0), m.GetLength(1)
תבנית: לולאה כפולה ואלכסונים
לפי שורות: חיצונית i, פנימית j · לפי עמודות: חיצונית j, פנימית i · אלכסון ראשי m[i][i] · אלכסון משני m[i][n - 1 - i]
מחלקות ועצמים
שלושה סוגי פעולות במחלקה
פעולה בונה = שם המחלקה, בלי טיפוס מוחזר · שאילתה = מחזירה ערך ולא משנה (get) · פקודה = void, משנה את מצב העצם (set)
this: התכונה מול הפרמטר
this.x = התכונה של העצם הנוכחי · x לבד = הפרמטר, כשיש פרמטר באותו שם
כמה פעולות בונות באותה מחלקה
כמה פעולות בונות = אותו שם, רשימות פרמטרים שונות · new בוחרת לפי הערכים שמעבירים
שאילתה או פקודה: איך כותבים כל אחת
שאילתה = טיפוס מוחזר + return, לא משנה תכונות · פקודה = void + הצבה בתכונה
toString: תיאור העצם כמחרוזת
Java: public String toString() · C#: public override string ToString() · מחזירה מחרוזת, לא מדפיסה
יצירה, זימון פעולות והפניות
new = עצם חדש · q = p = עוד הפניה לאותו עצם · == על עצמים = אותה הפניה, לא אותם ערכים
גישה לתכונות: מתוך המחלקה ומחוצה לה
בתוך המחלקה: this.x · עצם אחר: other.getX() · מחוץ למחלקה: רק get ו-set
שרשרת נקודות: מי מפעיל את מה
מחלקה מורכבת: this.birthdate.sameDate(other.getBirthdate()) · כל נקודה = פעולה של העצם שמשמאלה
רקורסיה ויעילות
תבנית: פעולה רקורסיבית שמחזירה ערך
if (תנאי עצירה) return תשובה ישירה; return צירוף(הערך הנוכחי, f(קלט קטן יותר)); · כל קריאה מתקרבת לתנאי העצירה
מה מקטינים ומה תנאי העצירה, לפי הקלט
מספר: n / 10 או n - 1, עצירה ב-n < 10 או n == 0 · שרשרת: getNext(), עצירה ב-null · עץ: getLeft() ו-getRight(), עצירה ב-null או בעלה
סוגי רקורסיה
זנב: return f(קטן) · הלוך-חזור: עבודה אחרי הקריאה · כפולה: שתי קריאות (עץ) · הדדית: A קוראת ל-B ו-B ל-A
לפני הקריאה ואחרי הקריאה
לפני הקריאה = בדרך למטה, בסדר הקריאות · אחרי הקריאה = בדרך חזרה, בסדר הפוך
מקרה גרוע ומקרה טוב בשאלות הבגרות
עונים על המקרה הגרוע ביותר, ומתארים את הקלט הגרוע · מקרה טוב = הקלט שבו הכי מעט צעדים
סכומים שחוזרים בנימוק
n+1 קריאות = O(n) · k·n = O(k·n), במקרה הגרוע O(n²) · (n−1)+(n−2)+...+1 = n(n−1)/2 = O(n²) · חלקים ברצף: הגדול ביניהם
יעילות של פעולה רקורסיבית
רקורסיה: מספר קריאות × עבודה בכל קריאה · קריאה על ההמשך + O(1) = O(n) · n קריאות × פעולה ב-O(n) = O(n²) · עץ, כל צומת פעם אחת = O(n)
תור
פעולות הממשק של Queue<T>
Queue: isEmpty()/IsEmpty() · insert(x)/Insert(x) - לסוף · remove()/Remove() - מחזיר ומוציא את הראש · head()/Head() - מחזיר את הראש בלי להוציא · כולן O(1) · אין size ואין גישה לפי מקום
הפעולות בפעולה
q.insert(q.remove()) = הראש עובר לסוף · n פעמים = סיבוב שלם, התור חוזר למצבו
תבנית: סריקה עם תור עזר והחזרת האיברים
while (!q.isEmpty()) { x = q.remove(); ...; temp.insert(x); } ואחר כך while (!temp.isEmpty()) q.insert(temp.remove());
שלוש דרכים לעבור על תור בלי לאבד אותו
תור עזר = תמיד · סימן עצירה = רק כשיש ערך שלא מופיע בתור · סיבוב = size פעמים q.insert(q.remove())
תבניות של בניית תור
פיצול = קבוצה א לתוצאה, קבוצה ב לעזר ואז לסוף התוצאה · איחוד = בכל סבב temp מחליף את התור, O(n²) · הכנסה לפי סדר = לפני הראשון שקטן ממנו, אחרת בסוף
שרשרת חוליות (רשימה חד-כיוונית)
הממשק של Node
Node<T>: new Node<T>(x) · new Node<T>(x, next) · getValue()/GetValue() · getNext()/GetNext() · hasNext()/HasNext() · setValue(x)/SetValue(x) · setNext(next)/SetNext(next) - כולן O(1)
מה אומר כל ביטוי
ריקה: lst == null · אחרונה: !p.hasNext() · הבאה: p.getNext() · הערך: p.getValue() · ערך הבאה: p.getNext().getValue() רק אם p.hasNext()
תבנית: סריקה עם הפניית עזר
Node<Integer> p = lst; while (p != null) { ... p.getValue() ...; p = p.getNext(); } · מקום: pos++ בכל סיבוב
איזה תנאי לולאה
p != null: כל החוליות · p.hasNext(): עוצרים על האחרונה · count < len && p != null: עד len או עד הסוף · שתי שרשרות: מקדמים את שתי ההפניות באותו סיבוב
תבנית: הוספה ומחיקה בקוד
בראש: lst = new Node<T>(x, lst) · אחרי p: p.setNext(new Node<T>(x, p.getNext())) · מחיקת הראש: lst = lst.getNext() · מחיקה אחרי p: p.setNext(p.getNext().getNext())
הסיבוכיות של הוספה ומחיקה
בראש או אחרי p נתון: O(1) · בסוף, לפי ערך או לפי מקום: O(n) - בגלל הסריקה
תבנית: מחזירה ערך, מחזירה שרשרת
בסיס: if (lst == null) · צעד: f(lst.getNext()) · מחזירה שרשרת: rest = f(lst.getNext()); מדלגים - return rest; או משאירים - lst.setNext(rest); return lst;
עצים בינריים
המינוח של עץ
שורש = בלי הורה · עלה = בלי בנים · רמה = קשתות מהשורש (השורש ברמה 0) · גובה = הרמה הגבוהה ביותר · עץ עם רמות 0 עד h = h + 1 רמות
פעולות הממשק BinNode
getValue/GetValue · getLeft, getRight/GetLeft, GetRight · hasLeft, hasRight/HasLeft, HasRight · setValue, setLeft, setRight · new BinNode<T>(x) · new BinNode<T>(left, x, right) · כולן O(1)
שלושת הסדרים על עץ אחד
תחילית = שורש, שמאל, ימין · תוכית = שמאל, שורש, ימין · סופית = שמאל, ימין, שורש · לרוחב = רמה אחרי רמה, בעזרת תור
מקרה הבסיס והצירוף לפי סוג השאלה
ספירה/סכום: null → 0, חיבור · גובה: null → -1, 1 + max · "האם כל": null → true, && · "האם קיים": null → false, ||
יעילות של פעולה על עץ
קריאה אחת לכל צומת = O(n) · פעולה של O(n) בכל צומת = עד O(n²)
נושא בחירה: אלגוריתמים (גרפים)
מושגים שחוזרים בשאלות
מלא: n(n−1)/2 קשתות · דו-צדדי: כל קשת בין שני הצדדים · עץ: קשיר ובלי מעגלים · קשיר היטב: מסלול מכוון בין כל שניים בשני הכיוונים
סכום הדרגות, עצים וגרף דו-צדדי
סכום הדרגות = 2·E · מכוון: סכום דרגות הכניסה = סכום דרגות היציאה = E · עץ: קשיר, בלי מעגלים, n−1 קשתות · דו-צדדי ⇔ אין מעגל באורך אי-זוגי
מטריצה מול רשימות: סיבוכיות הפעולות
מטריצה: זיכרון O(V²), בדיקת קשת O(1), שכני u ב-O(V) · רשימות: זיכרון O(V + E), שכני u ב-O(דרגת u), מעבר על כל הגרף O(V + E)
קריאת מטריצה וגרף הפוך
לא מכוון: מטריצה סימטרית · מכוון: שורה = יוצאות, עמודה = נכנסות · גרף הפוך: כל u→v הופכת ל-v→u, O(V²) במטריצה, O(V + E) ברשימות
BFS בצעדים וסיבוכיות
BFS: תור, מסמנים בכניסה לתור, d[v] = d[u] + 1 · O(V + E) ברשימות, O(V²) במטריצה · אורך מסלול = מספר קשתות
BFS כקופסה שחורה
קשירות: BFS אחד מגלה את כל V הקודקודים · רכיבים: BFS מכל קודקוד שלא סומן, סימון משותף · דו-צדדי: צביעה בשני צבעים בלי קשת באותו צבע
דייקסטרה בצעדים
דייקסטרה: בוחרים מ-T את d המינימלי, קובעים אותו, ומרפים: אם d[u] + w(u, v) < d[v] אז d[v] = d[u] + w(u, v), π[v] = u · רק משקלות אי-שליליים
סיבוכיות דייקסטרה
דייקסטרה: O(V²) במערך / מטריצה · O((V + E)·log V) עם תור עדיפויות
בלמן-פורד בצעדים וסיבוכיות
בלמן-פורד: V − 1 סבבים, בכל סבב מרפים את כל E הקשתות · O(V·E) · שינוי בסבב נוסף = מעגל שלילי
איזה אלגוריתם למסלולים קצרים ממקור יחיד
בלי משקלות: BFS · אי-שליליים: דייקסטרה · שליליים בגרף מכוון: בלמן-פורד · גמ"ל: מיון טופולוגי והרפיה, O(V + E)
DFS בצעדים וסיבוכיות
DFS: רקורסיה · O(V + E) ברשימות, O(V²) במטריצה · העץ תלוי בקודקוד ההתחלה ובסדר השכנים
BFS מול DFS
BFS: תור, שכבות, מסלולים קצרים · DFS: רקורסיה, לעומק, לא בהכרח קצר · בגרף מלא: עץ BFS כוכב, עץ DFS שרשרת
קשתות הגרף ביחס לעץ ה-DFS
לא מכוון: רק קשתות עץ וקשתות אחורה · מכוון: עץ, אחורה, קדימה, חוצות · מעגל ⇔ קשת אחורה
קשירות חזקה ורק"חים בעזרת DFS
קשיר היטב: סריקה מ-v ב-G ובגרף ההפוך מגלה את כל הקודקודים · רק"חים: DFS, גרף הפוך, DFS לפי סדר סיום יורד · גרף על: רק"ח = קודקוד, ואין בו מעגלים
מיון טופולוגי בעזרת DFS
מיון טופולוגי: DFS, וכל קודקוד שמסתיים נכנס לתחילת הרשימה · קיים רק בגמ"ל · קשת אחורה = מעגל · O(V + E) ברשימות, O(V²) במטריצה
מסלולים קצרים בגמ"ל
מסלולים קצרים בגמ"ל: מיון טופולוגי, ואז הרפיה של הקשתות היוצאות לפי הסדר · O(V + E) · גם עם משקלות שליליים
האלגוריתם של קרוסקל
קרוסקל: ממיינים קשתות בסדר עולה, מוסיפים כל קשת שלא סוגרת מעגל, עד V − 1 קשתות · O(E·log E)
עפ"מ מול עץ מסלולים קצרים
עפ"מ ממזער את משקל העץ כולו ואינו תלוי במקור · עץ מסלולים קצרים ממזער את המרחק מהמקור לכל קודקוד
תכונות של עפ"מ שנשאלות
משקלות שונים ⇒ עפ"מ יחיד, אבל לא מסלול קל יחיד · משקלות שווים ⇒ ייתכנו כמה עפ"מים · הקשת הכבדה ביותר יכולה להיות בעפ"מ (כשהיא הדרך היחידה לקודקוד)
נושא בחירה: מודלים חישוביים
טבלת מעברים
אוטומט סופי דטרמיניסטי = א"ב Σ, קבוצה סופית של מצבים, מצב התחלתי, מצבים מקבלים, פונקציית מעברים: לכל מצב ולכל אות מעבר אחד בדיוק · מילה מתקבלת = המסלול מסתיים במצב מקבל
מה המצב זוכר: התבניות שחוזרות
ספירה: מצב = שארית · חיפוש רצף: מצב = האות האחרונה · בלוקים: מצב = הבלוק הנוכחי · מונה חסום: מצב לכל ערך עד החסם · שני תנאים: מצב = זוג, מספר המצבים = מכפלה
פעולות על שפות
איחוד = או · חיתוך = וגם · משלים = Σ* פחות L · A·B = כל xy, x מ-A ו-y מ-B · L⁰ = {ε} · R(L) = ההיפוך של כל מילה
זהויות שכדאי לזכור
∅·L = ∅ · {ε}·L = L · R(A·B) = R(B)·R(A) · A·(B∪C) = A·B ∪ A·C · שרשור לא חילופי
רגולרית או לא: איך מזהים
שפה סופית ⇐ רגולרית · זוגיות, שארית, מונה חסום ⇐ רגולרית · השוואה בין שתי כמויות לא חסומות ⇐ לא רגולרית
תכונות הסגירות של השפות הרגולריות
הרגולריות סגורות למשלים, חיתוך, איחוד, הפרש, שרשור והיפוך · משלים = החלפת מקבלים ולא מקבלים באוטומט מלא · חיתוך ואיחוד = אוטומט מכפלה
מה לא נובע מהסגירות
חיתוך של שתי לא רגולריות יכול להיות רגולרי · תת-שפה של לא רגולרית יכולה להיות רגולרית · בודקים את השפה שיוצאת
מלא, לא מלא, לא דטרמיניסטי
מלא: בדיוק מעבר אחד · לא מלא: לכל היותר אחד, מעבר חסר = דחייה · לא דטרמיניסטי: כמה מעברים, מתקבלת אם יש מסלול מקבל · שלושתם מקבלים את אותן שפות
סימון המעברים
מעבר = אות, ראש המחסנית / דחוף X או שלוף או ללא שינוי · דטרמיניסטי: לכל מצב, אות וראש מחסנית לכל היותר מעבר אחד · מתקבלת = בסוף הקלט במצב מקבל
תבניות של מחסנית
שוויון: דוחפים על a, שולפים על b · סכום: שולפים על כל אות של הצד השני · משקל k: דוחפים k סימנים · חסום או זוגיות: במצבים · סימן ראשון מיוחד = יודעים מתי המחסנית מתרוקנת
טבלת מעברים וטבלת מעקב
x / y, R = קוראים x, כותבים y, זזים ימינה · עוצרת כשאין מעבר · מקבלת = עצרה במצב מקבל · Δ = תא ריק · אונרי: n = n אחדות
טכניקות שחוזרות
דילוג · חזרה עד תחילת הסרט · זוגיות בשני מצבים · סימון ב-x ו-Y · סבבים בזוגות · הזזה: מצב לכל אות
נושא בחירה: תכנות מונחה עצמים
העתקת הפניה מול יצירת עצם
b = a = אותו עצם · new X(a) = עצם חדש (פעולה בונה מעתיקה) · == על עצמים משווה הפניות · new X[n] = n הפניות null
הרשאות גישה
private = רק במחלקה · protected = גם ביורשת · public = בכל מקום · static = עותק אחד לכל העצמים, Class.x
תבנית: מונה עצמים
static int count גדלה בפעולה הבונה = מונה עצמים · number = count ברגע היצירה
מערך עם count
new X[n] = n הפניות null · סורקים עד count, לא עד length · הוספה: arr[count] = x; count++
ירושה ב-Java וב-C#
extends / : · super(...) שורה ראשונה / : base(...) בכותרת · super.f() / base.F() · בלי קריאה = הבונה בלי פרמטרים
דריסה מול העמסה
דריסה = אותה כותרת ביורשת, נבחרת בזמן ריצה (C#: virtual / override) · העמסה = אותו שם ופרמטרים אחרים, נבחרת בהידור
מה עובר הידור ומה עובר ריצה
Base r = new Derived() תקין · (Derived) r עובר הידור, נכשל בריצה אם העצם אינו Derived · instanceof / is לפני המרה · המהדר בודק לפי טיפוס ההפניה
ירושה או הכלה
"סוג של" = ירושה, חץ ◁ אל הבסיס · "יש לו" = הכלה, תכונה מטיפוס המחלקה, ◆ בצד המכיל · תכונה משותפת = רק בבסיס
שני השלבים של כל זימון
הידור: טיפוס ההפניה + טיפוסי הארגומנטים = חתימה · ריצה: טיפוס העצם = גרסה דורסת · this.f() בתוך פעולה = לפי העצם · super.f() = הבסיס