אוספים - Collections - חלק 4
GetEnumerator, שמחזירה אובייקט מסוג IEnumerator. האובייקט הזה הוא מה שמאפשר לרוץ על האוסף.פרקי ההרצאה: אוספים - Collections - חלק 4
תמלול ההרצאה: אוספים - Collections - חלק 4
הטקסט המלא של הדקות הראשונות בהרצאה «אוספים - Collections - חלק 4» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
ובואו נקרא לפרויקט הזה טסט אינומרבל. יש לנו פה פרויקט חדש ואנחנו רוצים לייצר מחלקה שכמו מקודם תהווה לנו איזשהו קולקשן, איזושהי מחלקת אוסף שאנחנו רוצים לבנות בכדי שנוכל להשתמש בה שוב ושוב.
והדוגמה שאני רוצה להראות כרגע זה דוגמה לא סטנדרטית בכדי להראות את היכולות ואת השימוש בשני הממשקים האלה של ה-i-numerable וה-i-numerator.
המחלקה שאני רוצה לבנות זו מחלקה שנקראת ריינבואו והיא מתארת קשת בענן. למה המחלקה הזאת היא קולקשן? הרי קשת זה אובייקט בודד, היא לא מתארת הרבה קשתות, היא מתארת קשת אחת.
מפני שניתן להסתכל על קשת בתור אוסף של צבעים. אז בוא נניח שאנחנו רוצים עכשיו בתוך המחלקה הזאת להגדיר את צבעי הקשת.
צבעי הקשת הראשונים שהתגלו היו בסך הכל חמישה צבעים. לאחר מכן גילו עוד שניים ויש שבעה צבעים. כמובן שבמציאות זה יכול להיות אינסוף צבעים וגוונים שונים אבל בהתחלה היו חמישה צבעים בגלל שאנחנו מתעסקים פה כרגע עם קונסול נגדיר קשת עם חמישה צבעים בלבד.
אז יש לנו כאן קודם כל משתנה אינטג'רי שמתאר כמה צבעים יש לנו, Total Colors. אנחנו מדברים על חמישה צבעים, ויש לנו את הצבעים עצמם, Read Only. כל אחד מהצבעים, אני לא רוצה שמישהו ישנה לי אותו, ולכן הוא מוגדר כ-Read Only.
בגלל שאנחנו בקונסול, נגדיר קונסול Color. צבע ראשון, בקשת האמיתית שגילו, ואדום. לאחר מכן יש לנו Second Color, זה צהוב. צבע שלישי זה ירוק, צבע רביעי זה כחול, הצבעים האלה זה אכן הצבעים האמיתיים שמוגדרים בצבעי הקשת, והצבע החמישי זה צבע סגול שאין לנו סגול בקונסול, יש לנו מג'נטה שזה סוג של סגול.
שני הצבעים הנוספים שהתגלו אגב זה כתום שמופיע אחרי האדום ואינדיגו שמופיע אחרי הכחול, אבל אין לנו כרגע את הצבעים האלה, אז נסתפק באלה ופתאום אנחנו רואים שיש לנו פה איזושהי מחלקה שאומרת אני קשת בענן ויש לי חמישה צבעים first, second, third, fourth ו-fifth אדום, זהוב, ירוק, כחול ומג'נדה ואני רוצה שהמחלקה הזאת תהיה מחלקה שניתן להתייחס אליה
כאילו שזאת מחלקת קולקשן רגילה כי יש בתוכה סדרת פריטים כאילו שהיא קולקשן. אוקיי, אז כל מה שאנחנו רוצים זה שתהיה לנו את היכולת לרוץ עליה ב-4H.
דבר ראשון, בואו נבנה אובייקט ממנה. ריינבו, ריינבו שווה New Rainbow, ושימו לב שאין לנו שום בעיה לגשת ולהסתכל, ריינבו עם R קטנה כמובן, מהו ה-First Color, ה-Second Color וכו'.
בואו נלך ל-First Color ול-Second Color של קשת בענן, נריץ ונראה Red וYellow. סבבה. אבל אני לא רוצה לעשות את זה בצורה כזאת.
מה שאני רוצה לעשות זה for each. כל אחד מהפריטים של האוסף הוא כמובן console. color משתנה color בתוך rainbow. ושימו לב שאנחנו כבר הולכים לחטוף את אותה שגיאת קומפילציה שראינו מקודם, שאומרת רגע מה אתה מנסה לעשות?
המחלקה הזאת לא מוגדרת בתור מחלקת אוסף בכלל. איך אתה מנסה לרוץ עליה אם היא לא מחלקת אוסף? אז התשובה, אנחנו באמת לא יכולים לרוץ על המחלקה הזאת בצורה כזאת, כמו שאנחנו לא יכולים לרוץ בפוריץ' בפוריץ' סתם על מחלקת פרסון.
אנחנו יכולים לרוץ רק על אוספים. ופה פעם ראשונה אנחנו רואים את ההגדרה הטכנית האמיתית של אוסף. ההגדרה המילולית שראינו בהתחלה בהתחלה אומרת, אוסף זה מחלקה שמכילה סדרת פריטים בעלי מכנה משותף כלשהו אבל ההגדרה הטכנית אומרת שזה משהו שניתן לרוץ עליו על ידי לולאת for each כאשר כדאי לנו מאוד
שניתן יהיה לעשות את זה לדוגמה על ידי הורשת i-enumerable ובייסיקלי אפשר להגיד שאתה קולקשה אם אתה ירשת את i-enumerable ופה בדוגמה הזאת אנחנו הולכים להיכנס יותר לעומק ולראות מה זה באמת אומר לרשת את i-numerable?
אז דבר ראשון אני מממש או יורש את i-numerable ומממש את הפונקציה שבו, ואנחנו רואים שיש ל-i-numerable פונקציה אחת שנקראת get-numerator.
אוקיי, פונקציית get-numerator מחזירה לנו אינטרפייס שנקרא i-numerator. מה זה בדיוק האינטרפייס הזה?
אז בואו נסתכל. בדוגמה שראינו של המחלקה products, מה שעשינו זה החזרנו את הפונקציה getEnumerator של הרייליסט אבל אין לנו פה בדוגמה בכלל הרייליסט ואין לנו שום קולקשן פנימי בתוך הריינבואו שעשינו.
אז איך אנחנו יכולים לבנות את הדבר הזה ותוך כדי הבנייה אנחנו הולכים להבין כמה דברים לגבי קולקשן. דבר הראשון היא נומרטור ובעצם אובייקט שמאפשר לעשות כמה דברים עבור הריצה על האוסף.
כלומר, בעזרת אובייקט אינומרטור אנחנו יכולים לבצע ריצה על האוסף. זה כל הסיפור של אובייקט אינומרטור. והממשק IEnumerable, כל מה שהוא עושה הוא אומר הנה בבקשה קחו אובייקט אינומרטור בכדי שבעזרתו תוכלו לרוץ על האוסף.
אינומרטור זה בעצם אותה יחידה שמאפשרת לרוץ על האוסף. אפשר להגיד שאם אתם בונים לולאת for רגילה אז המשתנה i זה האינומרטור של הלולאה כי הוא זה שמאפשר לרוץ על האוסף ולקבל את כל אחד מפריטי האוסף.
for each עובדת בצורה שונה לגמרי. היא לא רצה על ידי אינדקס כמו לולאת for. היא צריכה את אותו אובייקט מוזר שנקרא אינומרטור שהאינטרפייס הזה אמור לתאר אותו.
אז בואו נייצר אובייקט כזה. אם אנחנו רוצים לייצר אובייקט כזה אנחנו צריכים לבנות מחלקה ייעודית. אז בואו נבנה קלאס, והמחלקה הזאת אפילו יכולה להיות פרייבט שנקראת ריינבו אינומרטור והיא בייסיקלי מתארת את אותו אובייקט אינומרטור עבור ריצה על מחלקה ריינבו.
והיא יורשת את i-נומרטור. בואו נממש את i-נומרטור. שימו לב כמה דברים פנימיים יש בתוכו. ושימו לב גם שבנינו את הקלאס הזאת כ-Inner Class.
טוב, אז בואו נסתכל מה הם הדברים האלה. אז בעצם ל-i-נומרטור יש שלושה דברים בתוכו. reset זה הפונקציה שמחזירה את ה-Numerator, אני מזכיר לכם, הנומרטור זה אותו בייקט שמסוגל לרוץ על האוסף, מחזירה את הנומרטור לתחילת האוסף.
זה ריסט. moveNext מזיזה את הנומרטור אחד קדימה ומחזירה true אם יש פריט לקריאה. Current מחזירה את אותו פריט שאנחנו רוצים לקרוא.
ForEach חייבת את הדבר הזה בכדי להיות מסוגלת לרוץ על האוסף. ולכן מה ש-ForEach עושה זה קוראת לגטי נומרטור, גטי נומרטור אמורה להחזיר אובייקט כזה שמסוגל לתאר את האוסף ואז פוריץ' משתמשת בשלושת הערכים האלה, או יותר נכון הפונקציות האלה, בכדי לבצע ריצה על האוסף.
אז בואו נראה איך אנחנו יכולים לממש את כל הסיפור הזה בכדי שפוריץ' תוכל לרוץ באמת על אוסף הריינבור שלנו ולהציג לפי סדר את הצבעים השונים של הקשת.
מה שאנחנו נעשה זה נבנה קודם כל איזשהו משתנה פרייבט בתוך המחלקה שלנו, שזה יהיה ה-position שלנו. בהתחלה ה-position צריך להיות בעצם להצביע על פריט אחד לפני הפריט הראשון.
אם הפריט הראשון זה 0 לדוגמה, אז for each צריכה להצביע על מינוס 1. אם הפריט הראשון הוא 1, forEach צריכה להצביע על 0. בוא נניח ש-forEach כרגע תצביע על 0, הפוזישן ליתר דיוק.
הדבר השני שאנחנו נעשה זה ניצור אובייקט ריינבור. אנחנו רוצים איזשהו קונסטרקטור שיקבל ריינבור בכדי שנדע מה הצבעים שאנחנו צריכים להחזיר.
והנה הקונסטרקטור שלנו מוכן. ריסט מחזירה בחזרה את הפוזישן ל-0. בואו נשים את ריסט פונקציה ראשונה move next וזאת הפונקציה הבאה בתור שאנחנו צריכים לממש צריכה לקדם את ה-position ב-1 ולהחזיר האם אנחנו מכילים או עדיין לא הגענו לסוף האוסף אנחנו נמצאים במצב שבו אנחנו יכולים להחזיר את אחד מפריטי האוסף מה אנחנו צריכים להחזיר האם ה-position
קטן או שווה ל-rainbow נקודה total colors כמה צבעים סך הכל יש לנו בתוך ה-collection שלנו. אז הנה קידמנו את ה-position ב-1 ואמרנו האם יש לנו צבע או אין לנו צבע להחזיר.
current זאת הפונקציה החשובה ומה שהיא אמורה לעשות זה להחזיר את הפריט כתלות ב-position. אז בואו קודם כל אפילו נעשה פה switch על ה-position ונתחיל לבדוק.
אם אנחנו 1, 0 אנחנו לא יכולים להיות מפני שקודם כל יש קריאה למוב נקסט ורק אחר כך לקורנט אם מוב נקסט החזיר הטור. אם אנחנו 1, כל מה שאנחנו רוצים להחזיר זה את ה-first color, 2, 3, 4, 5. אם אנחנו 2 אנחנו רוצים להחזיר את ה-second color, פוזישן 3, 3rd color, פוזישן 4, 4th color, פוזישן 5, 5th color,
אפילו אפשר את זה לעשות default כי אין לנו אפשרויות אחרות. אוקיי, עכשיו כל מה שאנחנו צריכים לעשות זה להחזיר מגט אינומרטור אובייקט חדש מסוג rainbow enumerator ולתת לו את עצמנו, כי אנחנו בעצם קשת ולנו יש את הצבעים ומה שאנחנו שולחים לקונסטרקטור וכך האובייקט