[Powered by Google Translate] [סמינר] [iOS: כתיבת Apps כמו בוס]
[טומי MacWilliam] [אוניברסיטת הרווארד]
[זה CS50.] [CS50.TV]
>> בסדר, כולם, מוזמן iOS: כתיבת Apps כמו בוס.
סמינר זה הוא הולך להתמקד בכתיבת יישומים לאייפון
ובתורו בכתיבת יישומים לאייפד, וכך אנו בעצם הולכים לעבור
כמה דוגמאות שונות של איך לעשות אפליקציה, משחק פשוט כמו בוהן טיק טק,
או אם אתה מעוניין יותר בקבלת אפליקציה כמו איזה קורא חדשות
או משהו שמתקשר עם האינטרנט אני אדבר על זה גם כן.
הנה סדר היום הקצר שלנו.
>> יישומי IOS נכתבים בשפה הנקראת Objective-C,
ואז זה קצת דומה ל C, אבל לא ממש בכל,
אז אנחנו נדבר קצת על השפה עצם
ולאחר מכן כיצד לבנות אפליקציות אייפון באמצעות תכנית יישום זה נקרא Xcode,
שאם לא הוריד את זה עדיין מרגיש חופשי כדי להתחיל בהורדה עכשיו.
זה כמה ג'יגה.
זה צריך להיות בחינם ב-App Store, ולכן אתה צריך מק
באופן אידיאלי מריץ את הגרסה האחרונה של OS X.
אם אתה לא, אין בעיה.
יש לנו מחשבי מקינטוש במרכז המדע הזמין לשימושך
עם Xcode מותקן, ולכן אל תהסס להשתמש בם לפיתוח.
אם אתה רוצה להפוך את אפליקציה אבל אין לי מק, אל תדאג.
יש הרבה משאבים בקמפוס לשם כך.
וכך אז אנחנו הולכים לכיסוי 2 דוגמאות גדולות יותר של יישומים שונים שניתן לבצע.
Objective-C היא מבחינה טכנית מה שנקרא סט סופר של ג
זה אומר שכל קוד C הוא גם קוד חוקי Objective-C.
זה אומר שאנחנו סוג של צינור מודבק על כמה תכונות נוספות לג
חלק מהתכונות הללו כוללים לא נתקל אי פעם לכתוב malloc שוב, תודה לאל,
אין צורך לדאוג למצביעי הטיפשים האלה ושחררו אותם וכל הדברים האלה
אתה שונא על C, וזה סוג של נעלם בObjective-C.
>> עכשיו, Objective-C יש גם ספרייה סטנדרטית הרבה יותר גדולה,
כך שיש הרבה יותר פונקציונלי אתה מקבל עבור בתוך חופשי של Objective-C.
זכור כשכתבנו PHP שמנו לב שעברנו מ
שפה זו הקטנה ביותר לספרייה הענקית של כל הדברים המטורפים האלה שאתה יכול לעשות.
אותו הדבר קורה בiOS.
יש אובייקטים על דברים כמו בלוח השנה הבודהיסטית, ובעצם כל דבר
אתה יכול לחשוב על מקיים כנראה כבר ביישום של Objective-C.
חלק האובייקטיבי של Objective-C הוא התייחסות משהו
נקרא תכנות מונחה עצמים.
זה סוג של רעיון חדש, אבל אנחנו ממש בעיקר למדנו
הרבה המושגים האלה כבר.
הרעיון מאחורי תכנות מונחה עצמים הוא שאתה הולך לבנות
הרבה הקוד שלך סביב הדברים האלה נקראים שיעורים,
והשיעורים האלה באמת מהוללים structs.
בתוך struct אנו בעצם אמרנו כאן הוא דבר,
והדבר הזה יכול להיות חברים.
לדוגמה, בצומת רשימה מקושרת יכולה להיות דברים אחרים
כמו ערך, מצביע לצומת הבאה ברשימה,
ויחד שמצביע ושהערך מורכבים מופע של struct זה.
שיעורים דומים מאוד חוץ
שיעורים יכולים להיות גם בתוך פונקציות שלהם.
כשהכרזנו struct, תוכל לומר n int או * צומת הבאה בלבד.
>> עכשיו עם Objective-C אנחנו יכולים ממש לשים את הפונקציות
בתוך הדברים האלה.
דבר נוסף שניתן לעשות הוא שיעורים שהם יכולים לרשת נתונים מסוגים אחרים.
לדוגמה, יהיה לנו להסתכל על חבורה של מובנהיות בכיתות Objective-C.
אחד מהם היה יכול להיות ברמה שמייצגת את ההשקפה על מסך,
וכך באומרו שאני רוצה ליישם את ההשקפה האישית שלי
אנחנו בעצם אומרים שמישהו מעל באפל, כנראה אנשים ממש נחמדים,
כתב את זה בשבילי בכיתה, ומטפל בדברים כמו הצגת כפתורים
או להוציא מהמסך, ונהיה ממש כואב
כדי ליישם את כל הפונקציונליות שאת עצמנו, וזאת על ידי פשוט
ירושת נתונים שאנחנו יכולים לומר את כל מה שעשיתם באותה הכיתה
אני גם רוצה בתוך הכיתה שלי, ואז אני הולך לעשות כמה דברים אחרים,
כלומר ליישם אפליקציה.
זה מה שאומר מילת ירושה. נצטרך לראות דוגמה מוחשית יותר.
>> ולבסוף, את המפתח עם תכנות מונחה עצמים הוא כי
זה מוביל לאנקפסולציה נתונים.
בחלק מהבעיה שלנו מקובע שנהיה לנו המשתנים הללו הגדולים, הגלובליים
וGLOBALS בכל מקום, וככה היינו לעקוב אחר המצב.
עם כיתות אנחנו יכולים להתחיל encapsulating מידע הפנימי של אובייקט.
אם יש לנו מסך אחד באפליקציה שלנו, אנחנו לא באמת צריכים את כל נתונים מ
מסך אחר בבתוך האפליקציה שלנו לכך,
וזאת על ידי encapsulating דברים במסגרת שיעורים זה בעצם מוביל
לעיצוב קוד הרבה יותר טוב, וזה אפשרי עם כמה מהתכונות הנוספות
של Objective-C.
התראה מוקדמת, התחביר לObjective-C היא בננות.
זה כמו שום דבר שראינו קודם לכן,
כך שזה קצת זמן להתרגל עקומה למידה
מה לעזאזל זה אומר?
אבל ברגע שאתה מצליח לעבור כי עקומת למידה ראשונית זה ממש, ממש חלק
להתחיל לכתוב יישומים.
>> להכריז כיתה, לומר כאן היא הכיתה שלי, היא קיימת,
ואולי כאן כמה דברים שאני הולך להגדיר מאוחר יותר,
אני הולך לומר @ ממשק.
אני הולך לומר @ ממשק. אני הולך לתת לכיתה שלי שם.
ואז מאוחר יותר במקום אחר אני הולך לומר @ סוף,
וכל מה שבין הממשק @ והסוף @
הוא הולך להיות בכיתה שלי.
זה הולך להיות מה שבפנים. של קבצי h שלנו.
בדיוק כמו ב-C. קבצי h בעצם אמרו כאן כמה דברים שיהיו קיימים.
אני לא בהכרח אומר לך מה שהם עושים זאת,
אבל המהדר צריך לדעת שהם קיימים.
מאוחר יותר בתוך. מ 'שלנו קבצים, כי מ' ל- Objective-C
זה מקום בו אנחנו בעצם הולכים להגדיר מה השיעורים האלה לעשות.
כמו הרבה. קבצי C שלנו, ספק לנו יישום לפונקציות.
בתוך הקובץ. מ 'שלנו שאנחנו הולכים לומר כאן הוא מה שכל הפונקציות
בתוך הכיתה שלי מה לעשות כולם.
ולבסוף, בתוך struct נוכל לומר בתוך הסוגריים המסולסלים האלה
int n * או צומת הבאה,
ובObjective-C שאנחנו הולכים להשתמש במילת מפתח @ רכוש,
וזה מה שהולך להגדיר את התכונות,
או הפונקציות שאינן, כי הם חלק מהשיעורים שלי.
>> קוראים פונקציות בObjective-C הוא גם בננות.
כשהכרזנו פונקציות ב-C אמר משהו כמו int foo
ופתוח סוגריים ולאחר מכן נתן לו רשימה של טיעונים.
זה מה שהצהיר שיטות או פונקציות נראה כמו בObjective-C.
אם אני רוצה להכריז על פונקציה או שיטה
איפה שאני אומר שיטה היא באמת רק פונקציה שהוא חבר של כיתה,
כך סוג של החלפה, אבל לא ממש,
כך בתוך השיטה שלי אני רוצה ליצור שיטה חדשה.
זה הולך לחזור כלום, אז זה הולך להיות סוג של חלל.
זה סוג ההחזרה של הפונקציה שלי.
עכשיו יש לנו parens כאן כי, אני לא יודע.
הבא הולך להיות השם של הפונקציה שלי,
ואז סוף סוף יש לנו פסיק בדיוק כמו שהיינו לנו בג
מה חדש כאן הוא הבחור הזה כאן.
המקף הזה הוא בעצם צורך, ומה שזה אומר הוא ש
שיטה זו כאן צריכה להיקרא על מופע של מחלקה.
>> אחרי שהכרזנו structs אנחנו כנראה אמרנו משהו כמו
struct n צמתים, ושיצר בפועל
או אחד ממופעי structs הללו, כך שאני יכול פשוט להתחיל לעבוד
עם מה שיש בתוכו, כך שמקף זה אומר שאנחנו צריכים
מופע הכיתה בדיוק כמו שאנחנו מופעים שstruct
לפני שאנחנו יכולים לקרוא לשיטה זו על זה.
אם אני רוצה להתחיל להוסיף טיעונים לשיטות שלי
זה נהיה אפילו יותר בננות.
הנה שם בשיטה שלי.
אז אני הולך לי מעי גס, מעי גס ואחרי זה הוא אומר הנה מגיע כמה טיעונים.
שיטה זו לוקחת טיעון אחד.
הסוג של הטיעון שלו הוא int, ושמו של שהטיעון
או משתנה שאני הולך להתחיל להשתמש בחלק פנימי של השיטה נקראת i.
שוב, זה שיטה. זה לוקח טיעון אחד.
>> אם ברצונך להתחיל להוסיף עוד טענות שהוא מקבל יותר בננות
שביש לנו נקודות זה אומר שהנה מגיעה רשימת הטיעונים שלי.
הטיעון הראשון הוא מספר שלם.
עכשיו, הטענה השנייה היא מעניינת.
משתנה שאני הולך להיות באמצעות הפונקציה פנימית שלי
נקרא f, ולכן בתוך הפונקציה שלי אני יכול לומר
f + = 1 או משהו.
הדבר הזה כאן הוא בעצם מפתח שלטענה או פרמטר.
בדיוק כמו שהיינו לנו זוגות ערך מפתח ומשהו כמו JSON או מערכים אסוציאטיביים
Objective-C את ההחלטה להגיד, בסדר, רק כדי שזה ממש ברור
כשאתה קורא לשיטה מה כל הפרמטרים הללו הם
בעצם אני מתכוון לקרוא את כולם.
כשאתה מתקשר לשיטה, אתה למעשה אומר andFloat,
ואז אתה עובר אותו פנימה
>> מעניין לציין, שזו לא בשם, אבל בכל פרמטרים האחרים,
כך שאם היו לנו ויכוח 3 אני יכול להגיד andFloat
ולצוף אחרים וכן הלאה.
כשאני קורא בשיטות אלה הוא כמובן של בננות,
כך שאם יש לי אובייקט, ואני הגדרתי שיטה הנקראת foo,
ואני רוצה לקרוא לזה, ולא אומר foo פתוח / parens הקרוב
אני הולך לפתוח סוגר.
הנה שמו של השיטה שלי.
אני הולך לסגור את הסוגר, וזה האובייקט שאני קורא את זה הלאה.
זכור, כל השיטות האלה קיימות בתוך כיתות
בגלל שיעורים יכולים להיות שיטות המוגדרות בתוכם.
>> כאן יצרתי אובייקט של מחלקה מסוימת באופן שרירותי,
וזה התחביר שעשה את זה.
יש 2 שלבים ליצירת אובייקט.
הצעד הראשון הוא אומר שאני רוצה להקצות שטח.
זו מקבילה של malloc. אין לנו לומר malloc יותר.
אנחנו ירדנו מ ', עשו את זה alloc, והוחלפנו. ג ב. מ'.
אחרי משהו alloc אז אנחנו צריכים לאתחל אותו.
בעיקרון בעת ​​יצירת אובייקטים שאולי תרצה לקבל קצת היגיון
שמבצע כאשר הם יצרו, כך שתוכלו לעבור בכמה ערכי ברירת מחדל
או משהו כזה, ולכן שיטת init זה מה שבעצם יוצר את האובייקט.
אנו מקצים מקום הראשון, בדיוק כמו שעשינו ב-C,
ואז לאתחל אותו, מה שיכול או לא יכול לעשות הרבה.
ואז אנחנו חוזרים את הדבר הזה לאובייקט O.
יש כוכב לכאן כי זו היא טכנית מצביע,
אבל אל תדאגו, מצביעים הם לא כזה עניין גדול בObjective-C יותר.
>> עכשיו אנחנו כבר מופעי המעמד הזה שנקרא NSObject,
וזה רק בכיתה אקראית שאפל.
יש לנו מופעים זה, ועכשיו יש לי מופע של מחלקה זו
באובייקט o זה, אז זה אומר שאם אני מוגדר
שיטות אלה הייתי יכול לקרוא להם ככה.
בדומה לכך, אם אני רוצה לקרוא לשיטה בטיעון אחד,
אז זה שיטת הבר, שלוקח את טיעון אחד,
וכאן הוא באז: שיטת qux, אז זה לוקח 2 טענות.
זו קריאה לפונקציה אחת על האובייקט o זה.
הגיוני?
התחביר צריך להיות הגיוני, אבל אתה סוג של להתרגל לזה.
>> אוקיי, בואו נדבר על כמה דברים שבנויים לתוך Objective-C
שלא נבנו בהכרח לג
ב C אנחנו סוג של נאלצו להתמודד עם מחרוזות כמערכי אופי המטומטמים האלה,
וזה נהיה ממש מעצבן.
Objective-C יש אלה שנבנו בכל בשבילנו, והוא בנוי ב
באמצעות מחלקה זו נקראת NSString.
כשאני רוצה ליצור NSString יש לנו תחביר מסתורי יותר.
במקום לומר "cs50" אנחנו אומרים @ "cs50"
וזו רק התחביר להכרזה על מייתרים בObjective-C.
זה מאוד קל לשכוח, כל כך לא.
עכשיו, ברגע שיש לי את זה, זה הוא מחרוזת, אבל שם לב
זה באמת רק אובייקט.
אמרתי NSString, מה שאומר שמופעים בכיתה
קרא NSString, שמישהו אחר כתב בשבילי,
והם היו נחמדים מאוד על זה, ואז עכשיו
אני יכול להתחיל לקרוא על שיטותיו.
אם אני קורא את אורך השיטה על אובייקט של זה
זה הולך לחזור אליי לאורכו של החוט.
זה בדיוק כמו strlen ב C.
זה יחזיר 4.
>> בדומה לכך, בשיטה אחרת שאולי ירצה אכפת לי היא זו characterAtIndex.
זוהי שיטה שאומרת על מחרוזת של זה
אני רוצה שתקבל את התו 0,
וכך זה היה חוזר אליי ג האופי,
ויש חבורה שלמה יותר מהשיטות הללו שאתה יכול לגגל ממש בקלות.
התיעוד של אפל הוא גדול, ואנחנו נסתכל על זה קצת.
אלה הם מייתרים.
יש לנו גם מערכים בגודל משתנים בנויים פנימה
זכור ב-C כאשר הכריזו מערך
היו לנו לומר שיש לך 5 אלמנטים, סוף הסיפור.
כשהגענו לJavaScript ו-PHP שאנחנו יכולים להתחיל
לעשות דברים כמו הוספת אלמנטים או הזזת אלמנטים.
אנחנו יכולים לעשות את אותו הדבר בObjective-C.
במקום ליצור מערך בצורת C הרגילה
יש לנו שוב כיתה נוספת הנקראת NSMutableArray.
יש גם NSArray,
וזה הולך בעצם לתמצת חלק המערך.
זה אומר שהדבר הראשון שאני רוצה לעשות הוא שאני רוצה להקצות
מקום למערך חדש, ולאחר שאקצה אותו
ואז אני צריך לאתחל אותו.
שוב, רק להתקשר ל2 שיטות אלה.
עכשיו זה אומר שבתוכו של אובייקט זה
יש לי מערך ריק שישב שם.
אם אני רוצה להוסיף משהו למערך הזה, אני יכול לקרוא לשיטת addObject.
אני רוצה להוסיף אובייקט למערך, ואני רוצה להוסיף את מחרוזת CS50.
אם אני רוצה לחלופין להסיר שאני יכול להגיד שאני רוצה
להסיר את האובייקט במקום הראשון במערך או להתנגד.
>> הגיוני?
אוקיי, אתה סוג של להתרגל לדבר סוגר המרובע הזה.
אגב, בתוך המון הספריות של אפל תראה NS זה.
NS למעשה עומד לצעד הבא, שהיה אחד מחברות סטיב ג'ובס 1,
וזה המקום שבו באמת התחיל לכתוב הרבה קוד
כסוג של בסיס ל- Mac OS X וכל מיני דברים האחרים,
וכך NS זה סוג של מורשת זה נחמד לצעוק לאחת מהחברות הקודמות
בחזרה כאשר אפל היה בתחילת קריירה.
זה בכל מקום.
בואו נסתכל על דוגמה הוליסטית יותר Objective-C.
הנה אני בתוך Xcode.
כדי להגיע לכאן, אני הורדתי Xcode 1 מ-App Store,
פתח אותו, ואז הייתי עולה כאן לקובץ,
כאן לפרויקט חדש, ולאחר מכן.
אחרי שאני עושה כי יש לי את כל האפשרויות האלה של מה שאני רוצה ליצור,
ואז אנחנו נסתכל על אפשרויות אלה מאוחר יותר,
אבל רק לדוגמה זו, כי אנחנו לא ממש הולכים לי אפליקציה עדיין,
כשהגעתי לכאן, ואמרתי כלי שורת פקודה,
וזו אפליקציה שאני יכול לרוץ בשורת הפקודה
בדיוק כמו שאנחנו כבר מפעילים מג
ככה אני יצרתי את הפרויקט הזה, ואז עכשיו אני כאן,
אז תן מבט הראשון בקובץ זה, וזה צריך להיראות די מוכר.
יש לי שם int. יש argc החבר שלי, החבר האחר argv שלי.
וכך אנו יכולים לראות שזה הוא נקודת הכניסה ליישום הראשון שלי Objective-C.
כאן אנו יכולים להתעלם מזה לעת עתה.
זה בעצם כמה דברי ניהול זיכרון שאתה לא באמת
אף פעם לא צריכים לדאוג.
>> בואו נסתכל על הבלוק הראשון זה כאן.
השורה הראשונה זו, אם אני אומר לסטודנטים * אליס = [[alloc סטודנטים] init] מה זה עושה?
תלמיד ראשון זה כאן, זה כנראה כיתה.
זה לא מעמד שאפל כתב, אבל זה ברמה שאני כתבתי.
הדבר הראשון שאני רוצה לעשות הוא שאני רוצה להקצות שטח לתלמיד חדש,
ולאחר מכן אני רוצה לאתחל אותו, אז זה נותן לי גב
אובייקט התלמיד החדש הזה, ואני זה אחסון במשתנה בשם אליס.
איפה הכיתה שבאה?
ובכן, כאן בצד השמאל אלה את כל קבצים השונים בתוך הפרויקט שלי.
אנחנו יכולים לראות כאן יש לי Student.h וStudent.m.
. קובץ h, זוכר, מקום שבו אני מצהיר שכל הדברים
שיתקיים במסגרת הכיתה.
>> בואו נסתכל על זה.
בסדר, הנה יש לנו ממשק @ זה, וזה אומר שמגיע לכאן
הצהרותיו של כל מה שיהיה קיימים בתוך הכיתה שלי.
אז יש לי סרטן מעי גס. אז יש לי דבר NSObject זה.
מעי גס זה מסמל שקצת ירושה אנו דנים מעט מוקדם יותר.
זה אומר הכל NSObject יכול לעשות
בי NSObject היא זו כיתה שנכתבה על ידי מישהו אחר,
הכל NSObject זה יכול לעשות אני רוצה להיות מסוגל לעשות את זה.
באומרו: NSObject זה אומר שאני בעצם
ירש את כל הפונקציונליות של כיתה אחרת.
זה באמת נתן לי חבורה שלמה של שיטות שונות ומאפיינים שאני יכול להשתמש.
כאן אני יוצר 2 נכסים.
כלומר, התלמיד שלי, אם זה היה struct, אלה יהיו 2 הדברים
בתוך struct שלי, כך שכל תלמיד יש שם
שהיא מחרוזת, וסטודנט יש גם כיתה,
שהוא int.
>> לבסוף, כאן אני הולך ליצור שיטת התלמיד שלי.
התקשרתי בשיטה שלי, initWithName, וזה לוקח טיעון אחד,
והטענה שהוא חוט, ואני קראתי לזה שם.
עכשיו בואו נסתכל על איך אנחנו מיושמים המעמד הזה דווקא.
הנה, עכשיו אני פנימי של הקובץ. מ 'שלי,
מ 'ליישום, אני מניח.
יש לי ביצוע שלי, המטרה שלי, וכאן אני בעצם הגדרה
מה initWithName עושה.
יש לי initWithName, שמו של הפרמטר שלי, ואז זה
מקום בו אני למעשה יצירת תלמיד,
ואז זה קצת מסתורי, אבל זה סוג של טקסט סטנדרטי
שברצונך לכלול בבנאים שלך.
פונקציה זו אתחול כאן, initWithName, היא סוג של בנאי.
אתה בעצם בונה אובייקט תלמיד חדש
ואולי לשלוח כמה מידע שבתוכה.
הדבר הראשון שאני רוצה לעשות זה אני רוצה להתקשר לinit על דבר הסופר הזה.
>> זכור שכאשר אמרתי יחזרו לכאן ב. קובץ h
שכל מה שיש NSObject סטודנט גם.
זה אומר שכשאני יוצר תלמיד מה אני גם צריך לעשות הוא
לוודא כי NSObject שאני יורש את כל נתונים מ
גם הוא אותחל כראוי.
מה שאני צריך לומר הוא סופר היא בעצם הולך להתייחס למעמד ההורה
שאני יורש מ, אז אני רוצה לוודא שאני לאתחל
כל מה שאני בהתאם לפני שאני מתחיל לנסות להשתמש בו.
אז אם שאותחל כהלכה זה בדיוק כמו שיגיד אם malloc
לא תחזיר null אז אני יכול להתחיל בהגדרת מספר מאפיינים.
>> ב-JavaScript ו-PHP שמילה מפתח זו קראה לזה,
וזה התייחס למופע הנוכחי של כיתה.
בObjective-C שאנו מכנים עצמיים.
כשאני אומר self.name, זה אומר שהאובייקט
אני פשוט יצרתי כשאמרתי alloc התלמיד init,
זה הולך להחזיר לי את אובייקט.
זה אומר שאני רוצה להגדיר את שמו של אותו האובייקט
לכל מה שאני רק עברתי פנימה
בדיוק כמו ב-C, אנחנו חברים לגשת עם נקודה זו,
כך self.name אומר את השם של אובייקט התלמיד
עכשיו הוא הולך להיות כל מה שאתה רק עברת פנימה
ואז בסוף, אני לא יכול להחזיר את זה אז אני ממש מקבל משהו בחזרה.
>> שאלות?
אוקיי, אז זה עצמי = סופר init,
אם אתה לא לגמרי מבין את חומר התורשה אל תדאגו.
רק יודע שאם אי פעם תרצה לעשות שיטת init שלך פשוט
לעשות את זה, ואתה תהיה טוב ללכת.
כן. >> [סטודנטים] מה עושה אם אומר עצמי?
פירושו של הדבר כאשר אנו malloc משהו שתמיד בדק אם זה היה שווה לריק,
ואם זה היה ריק, אז יצא.
זה אותו הדבר, כי אם null חוזר הזה, אז אנחנו כנראה הולכים אשמת seg
אם תתחילו מנסה לתמרן אותו.
זה התלמיד בכיתה שלנו.
זה אומר שאנחנו יכולים לאתחל את התלמידים שלנו באחת משתי דרכים.
אם אני אומר alloc התלמיד init אני לא משתמש בשיטה שאני פשוט כתבתי,
ובמקום שאני יכול להגיד פשוט alice.name,
ועכשיו אני הולך להגדיר ששם המאפיין.
>> בדומה לכך, אם אני רוצה להשתמש בשיטת שinitWithName
אני פשוט יכול להגיד alloc, ואז במקום לומר init
אני הולך לקרוא לשיטה שזה עתה יצר, ואני הולך לעבור בבוב.
בשלב זה, האובייקט בוב הזה יש שם שווה לבוב.
אוקיי, כאן אני משתמש NSMutableArray שהסתכלנו קודם לכן.
אני הקצאת space.Then אני מאתחל את מערך חדש.
אני הולך להוסיף 2 דברים אליו.
מערך זה מחזיק כעת אובייקטי סטודנטים.
שים לב שבשום מקום לא הייתי צריך להגיד את זה הוא מערך של תלמידים.
אני אמרתי שזה מערך, נקודה.
אז אני יכול לשים את מה שבתוכו שאני רוצה.
כאן יש לי 2 אובייקטים.
>> לבסוף, יש לי אובייקט אחר כאן, TF זה.
כאן בTF.h בעצם את אותו הדבר.
אני יורש מNSObject, ודרך אגב,
בעת יצירת מעמדות זה נעשה הכל בשבילך,
סוג זה של ממשק מוכן מראש.
יש לו רכוש של תלמידים.
יש לי כמה שיטות פה שלא ממש עושים הרבה,
ואז זה אומר שאחרי שאני יוצר אובייקט TF זה
אני יכול לקרוא לכיתה בשיטה זו על זה ככה.
כל שאלות בתחביר Objective-C לפני שאנחנו מתחילים לנוע ליותר חלק
יישומי חומר התפתחות מעניין?
>> אוקיי, אז בואו בעצם לעשות אפליקציית אייפון.
שיעורי הליבה, כי אתה תהיה באמצעות בפנים של אפליקציית אייפון שלך נקראים בקרי נוף,
ובקר נוף בעצם מייצג מסך יחיד
בתוך היישום שלך, כך שאם אני באפליקצית המוזיקה, למשל,
בקר תצוגה אחת יכול לייצג את הנוף שבאני רואה את כל השירים באייפון שלי.
בקר תצוגה אחרת יכול להיות כאשר אני לוחץ על שיר ולהתחיל לשחק אותו
או כפי שאני קודח לתוך אמנים.
כל אחד מהמסכים האלה שונים יכול להיות מיוצגים כבקר מבט שונה,
ובקר נוף הוא באמת רק בכיתה שאומרת איך המסך הזה עובד.
דברים בתוך נוף של בקר, אנחנו הולכים ליש תכונות,
כך הדברים כמו כפתור הולכים להיות רכושו של בקר הנוף שלנו.
>> אנחנו גם הולכים להיות לי שיטות, ואלה הם בעצם מטפלי אירועים.
שיטה זו אומרת כאשר אתה לוחץ על כפתור זה
אני רוצה לעשות משהו, ולבסוף, שוב,
אנחנו הולכים להיות באמצעות מילות מפתח עצמית לכניסה למופע הנוכחי.
כדי לבנות ממשקים בiOS הוא בעצם ממש ממש קל.
יש להם לגרור זה נחמד ושחרר ממשק נקרא Interface Builder,
ואת 2 מושגי הליבה שתיל את Objective-C שלך לממשק Builder
הם IBOutlet וIBAction.
IBOutlet פשוט אומר שאם אתה מצהיר על רכוש זה כפתור,
ואתה רוצה לחבר את זה למשהו בממשק המשתמש שלך בפועל,
אתה הולך להגיד שזה שקע.
בדומה לכך, אם אתה רוצה לייצג מטפל באירועים
ואז אתה הולך להגיד שזה פעולה.
>> למעשה תמלכד את הייצוג גרפי זה
והקוד שלך שזה ממש ממש פשוט.
אם ברצונך לצרף IBOutlet, כל מה שאתה צריך לעשות הוא לשלוט קליק,
ואנו רואים דוגמה לכך זה ממש מהר.
אתה שולט על איפה זה אומר בקר תצוגה.
אתה הולך לגרור לתוך הממשק, או לחלופין,
אם אתה רוצה לחבר את מטפל באירועים שאתה הולך לגרור מתוך הממשק
בכיוון השני.
בואו נסתכל על דוגמא iOS ממש פשוט.
>> בואו ליצור פרויקט חדש.
אני לא מגיע לכאן לבקשה,
ואני הולך לחץ על יישום צפייה בהודעה בודד.
אני הולך ללחוץ על בא. אני אתן לי הפרויקט שלי שם.
אני אקרא לו שלום.
מעניין, אפל מניח שאתה יוצר מוצר
כך שאתה יכול למכור אותו והם יכולים להרוויח כסף.
כאן אני הולך להגיד שזה אפליקציית אייפון.
באפשרותך ליצור יישום ל-iPad, או אם ברצונך ליצור אחד מאלה Apps
שתומך בשני ההתקנים שאתה יכול לעשות גם את זה.
אלה הם מה שאתה רוצה checkmarks להיראות.
>> ברצונך להשתמש storyboards, שנראים בהמשך,
ואתה בהחלט רוצה להשתמש ספירה מכוונת אוטומטית,
בו היא תכונה נחמדה שמונעת ממך את הצורך לומר malloc וחופשי.
אלא אם כן אתה רוצה לקרוא לmalloc וחופשי, הייתי משאיר את בדק את זה.
אני לוחץ על בא, ולבסוף, זה הולך לשאול אותי איפה אני רוצה לשמור אותו.
אני אכה ליצור, והנה זה בא.
אני יצרתי את פרויקט חדש.
כאן בצד השמאל נמצאים כל הקבצים הנמצאים בתוכו של הפרויקט שלי,
ושים לב שיש לי חבורה שלמה, ואני אפילו לא עשיתי שום דבר.
IOS הוא גדול.
>> לדוגמה, הנה זה ViewController.h,
זה הולך לייצג בקר הפעם הראשונה שלי,
כך במסך הראשון בתוך האפליקציה שלי.
עכשיו אנחנו יודעים מה שזה אומר.
אנחנו אומרים אני מתקשר ViewController המעמד הזה,
וViewController עושה כל מה שעושה UIViewController,
וזה, שוב, הוא חלק הכיתה שאפל כתב שעושה המון דברים שימושיים עבורנו
רוצים להציג את המסך.
כאן מקום שבו אני יכול באמת להתחיל להגדיר מה בקר דעתי עושה,
ומתברר שאני באמת לא צריך את כל זה.
זה קוד מוכן מראש כי אפל נותן לי בחינם.
אני באמת זקוק שהשורה ראשונה, או שאין לי מעמד,
כדי שנוכל להיפטר מזה ולהיפטר מזה.
אוקיי, אז זה המסך הריק שלי.
>> עכשיו בואו לחצו על MainStoryboard.storyboard זה,
וזה המקום שבו מתחיל להיות מעניין.
זה מייצג את המסך הראשון על האפליקציה שלי.
אם אני רוצה להוסיף כפתור, ב-HTML הייתי צריך ליצור תג כפתור.
באנדרואיד אתה צריך ליצור תג כפתור,
אבל בiOS אם אני רק באתי לכאן כדי ימני התחתון
ואם אני לוחץ על אחד 3 זה כאן איפה זה אומר אובייקטים,
ואני יכול לגלול למטה, או שאני יכול להתחיל לחפש כפתור.
ותראה, כפתור, כך שאם אני ממש לגרור ולשחרר זכות זו קיימת,
רק אני הוספתי כפתור למסך הזה באפליקציה שלי.
אם אני רוצה לשנות את הטקסט, אני יכול ללחוץ לחיצה כפולה עליו,
לומר משהו מפתה כמו "לחץ עליי."
אוקיי, עכשיו אם אני מפעיל את היישום הזה, כדי שנהדר אותו,
כך כדי להפעיל אותו אני לוחץ על כפתור ההפעלה בצד השמאל למעלה, ויש האפליקציה שלי.
אני לא עשיתי שום דבר, ויש לי אפליקציית אייפון מחפש מתוקה.
אם אני רוצה להפסיק את זה, אתה יכול ללחוץ על כפתור העצירה
כי זה יותר כיף.
>> בואו נגיד שאני ממש רוצה שמשהו יקר, כאשר אני לוחץ על כפתור זה.
כדי לעשות את זה מה שאני צריך לעשות זה אני צריך ליצור
מטפל חדש אירוע או פעולה.
זה אומר שאני צריך ליצור כמה שיטה שאני רוצה שייקרא
כשאני לוחץ על הכפתור, אז בואו ליצור שיטה חדשה.
אני פנימי של ViewController.h.
אני צריך לומר ששיטה קיימת.
אני צריך מקף ראשון, כי אני הולך להתקשר אל זה בבקר התצוגה.
אני צריך לתת לזה סוג.
הסוג זה הולך להיות דבר IBAction שראו קודם לכן.
זה מטפל באירוע, כך שזה הולך לחזור IBAction,
וזה רמז כדי Xcode לומר כי
זה משהו שאני רוצה להעביר משהו.
אני יכול לתת לו שם, כמו, פסיק buttonPressed.
>> עכשיו אני כבר הכרזתי על שיטה חדשה בתוך הכיתה שלי.
אני כבר אמרתי בשיטה זו צריכה להתקיים.
עכשיו בואו ניכנס לViewController.m,
ובואו נגיד את מה ששיטה זו יכולה לעשות.
אם אני מתחיל להקליד, למשל, (void) buttonPressed
ההודעה Xcode הוא ממש נחמד וautocompletes בשבילי.
זה ממש נפלא.
שים לב כאן שבתוך הקובץ. אני יכול גם לומר הריק,
וזה בגלל שIBAction לא ממש סוג.
זה בעצם hashtag מוגדר איפשהו להיות מבוטל,
ושוב, זה רק ברמז כדי Xcode שאומר
אני רוצה שזה יהיה מטפל באירועים, ואנו רואים במה רק לשנייה.
כאשר לחצן זה נלחץ שאני הולך לעשות משהו מעצבן
רוצים להציג חלונות קופצים.
>> כדי לעשות את זה אני יכול ליצור מופע חדש של מחלקה זו נקראת UIAlertView,
וזו כיתה שאפל כתב שהולך להצגת חלונות קופצים מעצבנים.
אנחנו נתקשר התראת צץ זה, ויש לי 2 צעדים, זוכרים, ליצירת אובייקט זה.
הדבר הראשון שצריך לעשות הוא להקצות שטח.
אני רוצה UIAlertView.
אני רוצה להקצות שטח. זאת השיטה הראשונה שלי.
השיטה הבאה שלי היא שאני רוצה לאתחל אותו,
ואז יש לי זמן רבה בשיטה זו גדולה, הנקראת initWithTitle.
זה בעצם הולך לשלוט במה צץ זה אומר.
הכותרת שלי קופץ יכולה להיות שלום.
המסר של זה קופץ יכול להיות "זה iOS."
דבר נציג, אני לא יודע מה זה.
בואו נגיד שזה כלום.
עכשיו כפתור שהולך להופיע יכול לומר משהו כמו "זה בטוח",
ואני לא באמת רוצה את כל כפתורים אחרים, אז בואו נמחק את זה ולסגור את הסוגר.
>> אוקיי, אני יצרתי אחד נוסף. הנה.
זה איך אני יכול ליצור קופץ חדש.
אם אני רוצה באמת להראות קופץ אני רוצה להתקשר לשיטת ההצגה.
כדי לעשות את זה אני יכול לומר ערני ותכנית,
ושוב, השלמה האוטומטית הייתה סופר נחמד.
אם שכחתי מה זה היה, אם אני פשוט הקלדתי בים,
אני יכול לגלול לכאן כדי להבין מה זה היה,
והוא מסנן בצורה נאה.
עכשיו אני יצרתי קופץ החדש הזה.
אנחנו נחזור למה שאומר נציג מאוחר יותר,
ועכשיו אני רוצה לומר שאני רוצה בשיטה זו כדי להיות מפוטרת
כשאני לוחץ על הכפתור, ולכן אני מתכוון לחזור ללוח התכנון שלי,
ועכשיו אני רוצה לצרף IBAction זה.
הדבר הראשון שאתה רוצה לעשות הוא ללחוץ על הכפתור.
כאשר אני לוחץ על כפתור זה אני רוצה שמשהו יקר.
אני לא מתכוון להחזיק את השליטה.
אני הולך ללחוץ ולגרור מהכפתור
לכאן איפה זה אומר בקר תצוגה.
אנחנו יכולים לראות שזה יפה מצית.
>> אם אני עוזב עם העכבר שלי עכשיו יש לי זה קופץ לכאן שם יש לי כמה אפשרויות.
אחד מאלה הם האירועים שאני יכול להירשם.
כל אלה הם השיטות האלה אני מוצהר בתיק שלי כשעתי IBActions.
כך Xcode יודע מה צריך להופיע ברשימה הקטנה הזה,
אז זה רק רמז.
אם אני לוחץ על כפתור לחוץ, אני כבר עכשיו נרשמתי המטפל באירועים.
ב-JavaScript יש לנו לומר שיש לי קצת קוד שנרשם המטפל באירועים.
בObjective-C שזה באמת כל כך קל.
אם אני מפעיל את זה שוב
עכשיו כשאני לוחץ על כפתור המטפל באירועים שלי הולך לירות,
ואני הולך לקבל את זה קופץ.
סופר, סופר פשוט שם.
>> אם אתה רוצה לראות את כל האירועים שקורים לי להיות רשומים
ברכיב אם אני לוחץ על הכפתור הזה
ואני בא לכאן לצד ימין
ראשון שאתה יכול לראות כאן שאני יכול לעשות דברים כמו הסוג של הכפתור,
כך שאם אתה רוצה אחד שלי כפתור מגע התוספת של או אלה
או משהו כזה.
אם אני רוצה לראות את כל אירועים שעל הכפתור הזה
אם אני עושה את כל הדרך לכאן לצד ימין
אנחנו יכולים לראות כאן באירועים שיש לי את כל האירועים הללו.
אני יכול ללחוץ על הכפתור, כשאני משתחרר מלחץ, כשלהכפיל רז או משהו כזה,
והאחד אני פשוט נרשמתי הוא האירוע הזה שנקרא ריטוש בפנים
וזה אומר שברגע שהאצבע שלי מגיעה מהכפתור
אירוע שהוא הולך לאש, וזה בדיוק מה שקרה.
זה סוג של אירוע לחץ על כפתור ברירת המחדל.
>> כל שאלות עד כה?
אוקיי, זה איך אנחנו יכולים להתחיל נמלכד את הדברים בקוד שלנו
לדברים בתוך הממשק שלנו.
זכור הדבר הראשון שהיה צריך לעשות זה למצוא את הקוד,
ואז אנחנו חוטית את הממשק לקוד,
ויש האפליקציה הראשונה שלנו.
אוקיי, זה היה ממש מגניב, ויצרנו לחצן זה.
מה אם אנחנו לא רוצים שנהיה לי ליצור חבורה של נכסים
מייצג את הכפתורים האלה?
לדוגמה, בבוהן טיק טק, יש לי 9 לחצנים,
וזה יהיה סופר, סופר מעצבן צריך לגרור ולשחרר 9 פעמים
או שאם הייתי צריך לעשות בוהן טיק טק, עם 81 במקום 9
והייתי צריך לגרור ולשחרר 81 פעמים, וזה צולע.
מה אנחנו יכולים לעשות במקום זה הוא הרבה יותר כמו HTML
כאשר היו לנו דברים כמו תעודות זהות ושמות ואנחנו יכולים לחפש דברים
לפי תעודת הזהות שלהם, יש רעיון דומה בשם iOS תגים.
>> תג הוא פשוט מזהה מספרי ייחודית לרכיב.
אם אני אומר את זה יש לו תג של 0, למשל,
אם אני יוצר כפתור ונותן לו תג של 0, ואנחנו נראה איך לעשות את זה ברגע,
אם אני רוצה לקבל את הכפתור שאני פשוט יכול להגיד שאני רוצה לקרוא
viewWithTag שיטה על האובייקט כאן,
self.view, המייצג את המסך הנוכחי, למשל.
אם אני קורא לזה שיטת viewWithTag, אני הולך למשוך חזרה את הכפתור עם תג 0.
בואו נסתכל על זה על ידי בניין בוהן טיק טק.
ראשית, זה התכנון שלי.
יצרתי 10 כפתורי UI אלה.
שים לב שכולם באותו הגודל.
אם אני לוחץ על אחד מאלה ואני חוזר לכאן בצד זכות זו
תראה אני מותאם גופן ממש כאן, אז עשיתי את הגופן קצת יותר גדול,
אבל מה שגם אני עשיתי הייתה לי להגדיר את התג הזה.
אמרתי שיש לזה תג של 1, וזה למעלה משמאל.
>> עכשיו, אם אני לוחץ על כפתור אחר, כמו שנייה אחת זה כאן,
עכשיו תראה שהתג שלי הוא 2.
כל אחד מהכפתורים האלה פשוט יש תג ייחודי,
ואז זה מאוחר איך אני הולך להתחיל אינטראקציה
עם האפליקציה שלי.
כל זה הוא החלק פנימי של בקר תצוגה אחת,
אבל הנה מה שיש לנו.
יש לנו 3 נכסים כאן.
הראשון והאחרון הולכים לייצג את המדינה של הלוח שלי.
העיקרון ראשון זה הוא מערך שבו מייצג X ו הם.
אחד האחר כאן אומר לנו התור של מי.
תוכל להבחין כי יש לי גם את הדברים האלה כאן.
לפני כשהכרזנו מאפיינים שנתנו להם שם וסוג.
אנחנו גם יכולים לתת להם קצת מידע נוסף כאן.
זה ראשון אומר nonatomic, ומה זה אומר
הוא בעצם רק דבר אחד לא שאתה מנסה לגשת משתנה זה בכל פעם.
אתה יכול לעשות יישומים מורכבים יותר, כי הם ריבוי הליכים,
וזאת שוב בשריטה שהיינו לנו נושאים שונים,
ושדונים שונים יכולים לעשות דברים שונים באותו הזמן.
>> אם זה לא מקרה, שזה לא בכל דבר שאנחנו יהיו מסתכלים,
אם אנחנו אומרים nonatomic זה באמת הולך לעשות את הדברים בצורה קצת יותר מהר.
יש לנו גם הדבר הזה שנקרא הקצאה, חזק, או חלש.
זה להקצות רק אומר שזה סוג סטנדרטי.
זה לא אובייקט או מצביע כי זה פשוט bool,
כך bool בנוי לתוך Objective-C.
זה אומר אל תנסה לעשות משהו מפואר עם מצביעים כאן.
זה Scaler ישן רגיל.
חזק וחלש, זה אומר שבעצם חלש
אני רוצה שזה יהיה הצבעה על משהו בבקר התצוגה.
אני לא מתכוון דווקא להקצאה או init את זה בעצמי.
ממשק הקבלן, כאשר אני מפעיל את היישום, הוא הולך להתמודד עם כל אתחול זה.
אם אני אומר חלש, שאומר שמישהו אחר הולך להיות יצירה זו.
אם אני אומר חזק, זה אומר שאני הולך להיות זה
זה יוצר אובייקט הלוח הזה,
אז הנה יש לי עוד כמה שיטות כאן,
לדוגמה, פעולה לכאשר כפתור המשחק החדש כלשהו,
פעולה לכאשר כל כפתורים האחרים נלחצים,
וכדומה.
>> אנו לא נכנסנו ליותר מדי ההיגיון של בוהן טיק טק,
למרות שזה מאוד מרגש, אבל בואו נסתכל על
כמה מהדברים שאנחנו יכולים לעשות בתוך iOS.
שיטת משחק חדש זה הולכת להיות מפוטר
בכל פעם שאני לוחץ על כפתור המשחק החדש.
כדי לחבר את זה פשוט לבוא אל לוח התכנון שלי.
אני לוחץ על משחק חדש.
אם אני בא לכאן, מצד הימין, ניתן לראות כי
לגעת בתוך מחווט לשיטת newGame.
זו הסיבה שזה הולך להיות מפוטר.
שיטת newGame הוא הולך לעשות קצת סט.
זה הולך להגיד שאני רוצה אותך כדי לנקות את המדינה של הלוח.
זוהי שיטה נחמדה במערכים משתנים.
זה הולך לומר עכשיו זה תורו של X,
ועכשיו אני הולך לקחת את היתרון של דבר viewWithTag זה.
>> אני יודע שיש לי כפתורי התגים 1-9,
וזה משהו שאני באופן שרירותי בחרתי.
אם אני רוצה להגדיר את הטקסט של כל כפתור כדי להיות ריק
כי אני פשוט התחלתי משחק חדש ואני לא רוצה שכל
Xs או OS להיות שנשאר אני יכול לעשות את זה.
אני יכול להגיד שאני רוצה את התצוגה עם התג, 1, 2, 3, 4 וכולי '.
זה ימשוך כפתור אחר בכל פעם.
הנה אני הולך להפיל אותו לUIButton.
בדיוק כמו שאנחנו יכולים להטיל ints לצף ולהיפך
זה אומר שאני רוצה להטיל את זה לUIButton.
כלומר, הסוג של זה יהיה * UIButton
בגלל מצביעים, אבל אל תדאגו, הם לא מפחידים יותר.
>> ברגע שיש לי לחצן זה אני הולך לקרוא לשיטה על זה.
שיטה זו נקראת setTitle forState, ואז זה אומר
אני רוצה להגדיר את הטקסט של הכפתור להיות המחרוזת הריקה,
ואני רוצה שזה יהיה המחרוזת הריקה כאשר זה לא נלחץ.
אם אני משתמש בשיטה זו, אני יכול לשנות את הטקסט של הכפתור
ברגע שמישהו פוגע בו, אבל אנחנו רוצים לומר כאשר הכפתור פשוט יושב שם
אני רוצה שהטקסט יהיה ריק.
לבסוף, אנחנו הולכים לאתחל הלוח שלי,
ואני הולך לומר שהכל נמצא כרגע ב 0,
אז זה לחברי הנהלה הוא בלתי ניתן לשינוי משתנה מערך,
מה שאומר שאני יכול לקרוא את שיטת addObject ורק 0 בתוכו.
זה מה שקורה כשאני יוצר משחק חדש.
>> בואו נסתכל על זה.
שיטה זו הנה IBAction זה הולך להיות לחוץ
בכל פעם שאחד מהריבועים האלה נלחצה.
עכשיו יש לנו קצת היגיון טיק טק טו כאן.
אנו להבין תורו של מי,
ועל סמך זה אנו גם להגדיר X או O,
אבל אנחנו שמים לב שאנחנו שימוש חוזרים באותו מטפל אירוע זה
לכל אחד ואחת מהכפתורים האלה.
זה אומר שאין לי שיטה לכפתור השמאלי העליון,
שיטה שונה לכפתור הימני התחתון, למרות שהייתי יכול לעשות את זה.
זה אפילו לא יהיה עיצוב טוב.
מה שאני עושה כאן הוא בעצם אני הולך לקבוע
מה התג של הכפתור שנלחץ הוא.
אתה שם לב ששיטת המחזה הזה לוקח טיעון אחד.
זה נקרא שולח, ומה ששולח הוא השולח הולך
מייצג בדיוק את מה שנלקח על פעולה.
אם אני לוחץ על כפתור, שולח זה הולך להיות שUIButton
שלחצתי ממש, אז זה אומר שUIButton
יש תג משום שאני יצרתי תג.
>> אם אני רוצה להגיע אליו התג אני יכול פשוט לומר
אני רוצה תג של השולח,
ושוב, אני פשוט casted לUIButton.
אני במקרה יודע שהשולח יהיה UIButton.
זה לא תמיד חייב להיות UIButton.
אני יכול, למשל, לרשום אותו המטפל באירועים
לאחד לכפתור, אחד למחוון.
במקרה זה, אני יודע שהם כל הכפתורים, אז אני הולך להגיד
אני רוצה שזה יהיה כפתור, ואז אני יכול לקבל את התג,
ומהתג שאני יודע עכשיו איפה אני פנימי של הלוח.
ואז אני יכול פשוט להגדיר X או O, יכול להעיף את התור,
לבדוק מי נצח, וכולי.
>> כל שאלות על זה עד כה?
אוקיי, את כל הקוד שפורסמנו באינטרנט, אנחנו לא רוצים להיכנס ליותר מדי
של היגיון טו טיק טק, אבל עכשיו אתה יכול לראות שבאמת
כל מה שאנחנו עושים הוא שאנחנו מלפפים על מערך זה,
אז יש לנו כמה לולאות לכאן, ואנחנו רק משווים לראות
יש לנו משחק בכל השורות, התאמה בעמודה או משהו כזה.
בפועל כדי להפעיל את היישום הזה, אם אני מקיש על אחד מהכפתורים האלה
כי שיטת המשחק פוטרה, אז זה אומר שאני פשוט להגדיר
הכפתור כדי להיות X, אז עכשיו על כפתור זה יהיה O, וכן הלאה,
ואז ככה אנחנו מתחילים אינטראקציה עם יישום הדף הבודד הזה.
>> אנחנו מתכוונים לכתוב קוד, אז אתה מוזמן לעיין כי,
אבל בואו עכשיו מדברים על יישומים מסוימים, כי הם יותר מאשר רק דף אחד.
מרגש כמו בוהן טיק טק, היה, הרבה יישומים הפנימיים של iOS
הוא סוג של תרגיל אלה את הדברים עם מסכים מרובה.
המושג הראשון שאנחנו צריכים לדבר עליהם פרוטוקולים,
ופרוטוקול הוא פשוט קבוצה של שיטות
כי אתה יכול להבטיח להגדרה.
אם אני יוצר בפרוטוקול זה חדש עם 2 שיטות, אחת ראשונה זו,
אם סוג החזרה הוא חסר תוקף, אני קראתי לזה foo.
זה לוקח אין ויכוחים. יש לי שיטה אחרת.
זה מחזיר int. אני קראתי לזה בר, וזה לוקח טיעון אחד.
כל פרוטוקול זה הוא שנקרא SomeProtocol עד כאן,
זו היא קבוצה של דברים שמישהו יכול ליישם.
אני לא בתוך של פרוטוקול זה שאמרתי את מה foo עושה.
במקום זאת, אני רק אומר שאתה יכול להגדיר את foo אם אתה רוצה.
אם אני יוצר בקר תצוגה או יצירת מעמד
אני יכול בתוך מהבטחת המעמד ליישם
חלק מהשיטות הללו, כך לדוגמה, אם אומר
זה אומר עכשיו אני עושה ההבטחה שבתוך
כיתה של בקר תצוגה זו תהיה לי הגדרות לשניהם foo ובר.
>> למה זה שימושי?
הרבה רכיבים בתוך של iOS לנצל את זה
תבנית עיצוב בשם משלחת, ומה אומרת משלחת
הוא כי, למשל, אם יש לי תיבת טקסט
ויש כמה אירועים שיכולים להיות רשום בתוך תיבת הטקסט שלי,
ולא יצירת אירועים נפרדים מה שאני יכול לעשות הוא שאני יכול לומר
הנציג של תיבת טקסט זו יהיה חפץ כלשהו.
כשאני אומר שזה נציג עכשיו זה אומר ש
בכל פעם שאירוע היה ירה בתיבת הטקסט
במקום שתצטרך לרשום אותו או משהו כזה
זה רק הולך לקרוא לשיטה בנציג.
לדוגמה, בתוך תיבת הטקסט שלי יש לי שיטה לכאשר אני לוחץ
שעשה כפתור בפינה הימנית התחתונה,
וכך, במקום רישום מטפל באירועים מה שאני יכול לומר הוא
תיבת טקסט, כאן היא אובייקט שאני רוצה שתקרא על שיטה
בכל פעם שמישהו לוחצת על הכפתור, עשה
וזה אומר שאובייקט שיש ליישם חלק הפרוטוקול
שאומר אני מבטיח להגדיר שפעולת הכפתור עשתה,
כי אם זה לא מגדיר את השיטה שאתה וללחוץ Done
אז זה הולך להיות מבלבל.
>> בואו נסתכל על דוגמה.
כאן פשוט אין לי תיבת טקסט אחת,
ואחד מהמאפיינים של תיבת הטקסט הזה כאן בצד זכות זו הוא הנציג.
זהו מאפיין של המעמד.
מה שעשיתי כאן הוא שאני שולט לחצתי, ואני נגרר מהמקום הזה כאן
להשקפת בקר, ואומר שנציג של תיבת טקסט זה עכשיו
הולך להיות בקר התצוגה.
כלומר, כאשר כמה פעולות לקרות, ולא רישום
מטפלי אירועים נפרדים שאני רוצה שתשלח אותם לנציג.
עכשיו בואו נסתכל על בקר דעתי.
בתוך. קובץ h שהבטחתי.
אני הבטחתי ליישם כמה שיטות הפנימיות של פרוטוקול זה
קרא UITextFieldDelegate, ושוב,
זה רק חלק מהרשימה כמה דברים שאני יכול לבחור ליישום.
>> אם אני מגיע לכאן בקובץ. מ 'שלי, אני יישמתי שיטה אחת כזאת.
אני קראתי לזה textFieldShouldReturn
כי זה מה שזה נקרא בתוך הפרוטוקול.
ועכשיו בכל פעם שאני לוחץ על הכפתור בתוך עשה של שדה טקסט
זה מה שהולך לקבל קרא, ואני לא רשמתי את מטפל באירועים.
אני מחובר לנציג, וכל פעם שאירוע זה ירה
זו השיטה שיקבל בשם, כך שאם אני בא לכאן כדי התכנון שלי ולהפעיל אותו,
תוך שהוא טוען שאנחנו יכולים לראות מה זה עושה.
על המסך שלי יש לי 2 דברים.
יש לי שדה הטקסט הזה, ויש לי תווית זו.
אני רק אומר שאני רוצה את הטקסט של תווית זו
להיות שווה לכל מה שהקליד את המשתמש בצד פנימי של שדה הטקסט.
השורה הבאה זה כאן, זה פשוט שיטה שאני מתקשר
בשדה הטקסט שאומר שאני רוצה אותך כדי להסתיר את המקלדת.
זה רק השיטה השרירותית שאפל בחרה.
>> שוב, לפני שעשיתי משהו שהיה לי כדי לחבר את הכל, אז אני ראשון הגעתי לכאן.
מן בקר הנוף אני גורר מעל לתיבת הטקסט.
אני משתחרר, ואני יכול לראות כאן שאני יכול להפוך את נכס שדה טקסט זה
מאז כאן בבקר הנוף שמוגדר רכוש
כי הוא IBOutlet של שדה טקסט.
זה אומר שאני יכול להעביר את הרכוש הזה
לשדה טקסט בממשק המשתמש שלי.
עכשיו כשאני לוחץ זה אני יכול להתחיל להקליד.
עכשיו אם אני לוחץ על הכפתור עשה זה הולך לירות
אירוע שכעת אני יכול להגיב.
אין טפל באירועים.
ככה אני רק הגבתי ללחצן זה נעשה.
הגיוני?
>> זה לא תבנית עיצוב ש- ייתכן שלא תמצאו את עצמך אי פעם
יצירת פרוטוקול משלך, אבל שתדע כמה
רכיבי iOS שונים לרשום אירועים בדרכים שונות.
כפתורים, למשל, להשתמש בIBActions אלה.
שדות טקסט, לעומת זאת, הולכים להשתמש בצירים.
אנחנו יכולים לראות ואתה יכול להסתכל כל זה בתוך מהתיעוד.
דרך אגב, יש בעצם טון של חומר UI הבנוי לתוך iOS בשבילך,
כך לדוגמה, הדרך שעשיתי שאמרו כל כבוד בפינה הימנית התחתונה
הוא בחרתי שדה הטקסט הזה.
אני באתי לכאן.
אני גללתי למטה קצת לחזור מפתח,
ואני באמת יכול לעשות את זה חבורה שלמה של דברים, כמו שאם אני רוצה לומר
חירום קורא במקום שאני יכול לעשות את זה, שהוא אקראי לחלוטין,
ואני לא יודע למה יש כפתור שיחת חירום מובנה,
אבל שם, זה אומרת שיחת חירום באותיות קטנות באמת.
הנה לך.
>> בהחלט לחקור את כל אלה אפשרויות השונות בiOS.
כל שאלה על צירים?
שוב, רק תבנית עיצוב מעניינת, כי אתה צריך להיות מודע.
אוקיי, בואו הבא נסתכל על נוף בטבלה.
תצוגת טבלה היא בעצם שהרשימה של פריטים הנמצאת בכל המקום בiOS.
כשאתה מהרפרף דרך כל אנשי הקשר שלך, אתה מסתכל
דף ההגדרה, וזה סוג של רשימה של דברים שנקרא תצוגת שולחן.
יישום תצוגת שולחן בiOS הוא די פשוט.
במקום לעשות בכיתה שיורדת מזה UIViewController
כמו שעשינו לפני שאנחנו פשוט צריכים לומר ולא
הכל UIViewController לא שאני רוצה לעשות,
אני אומר הכול UITableViewController אין אני רוצה לעשות,
כך שפשוט מוסיף כמה דברים נוספים שנעשים לחלוטין עבורנו.
אנחנו צריכים לעשות מעט מאוד בעצם כדי למלא את החסר הפנימי של השולחן.
>> כדי להציג טבלה שאני צריך לענות על כמה שאלות.
השאלה הראשונה שצריך לענות עליה היא כמה חלקים הם בטבלה?
כאשר אתה מדפדף ביישום אנשי הקשר שלך תוכל להבחין כי זה סוג של
מאורגן על ידי כ, אז יש לך ארוחת בוקר, ויש לך שכותרת המשנה קטנה.
כל אחד מאלה נקרא סעיף.
אתה יכול או לא תזדקק לזה.
הדבר הראשון שאתה צריך לעשות הוא ליישם שיטה
קרא tableView: numberOfSectionsInTableView.
זה פשוט מחזיר כמה סעיפים שיש לך,
אז זה יכול להחזיר אחת אומר אם יש לך תצוגת שולחן אחד גדולה.
השאלה הבאה שiOS צריך לדעת היא כמה שורות יש לך?
לדוגמה, אתה מדפדף בתצוגת טבלה.
יש לך מספר קבוע של שירים אתה מסתכל או מספר קבוע של אנשי קשר.
אם אתה אותי, כמובן, לא רב,
ואז ככה iOS יודע כמה תאים להצגה.
>> שוב, זה יכול להגיד משהו כמו תשואה 3.
תצוגת שולחני יש 3 שורות.
לבסוף, iOS צריך לדעת מה כל תא נראה,
אז מה זה בעצם הולך לעשות זה להתקשר שיטה זו כאן,
tableView זה: cellForRowAtIndexPath.
זה הולך לקרוא לשיטה זו בכל תא ותא בתוך הטבלה שלך.
איך הוא יודע כמה פעמים לקרוא לזה?
ובכן, אמר לו בתוך מספר השורות בקטע.
אנחנו הולכים לקרוא לזה בכל אחד מהתאים שלנו,
ובתוך זה שבו אתה באמת יכול לעשות דברים כמו
להגדיר את הטקסט או להגיד לך מה שהכפתור הכחול הקטן בצד ימין עושה.
הדפוס להשגת תאים אלה, אנחנו הולכים להשתמש בשיטה זו
קרא dequeueReusableCellWithIdentifier.
>> Objective-C היא למעשה מאוד ידוע לאורך המגוחך של שמות שיטתם,
וזה באמת מקרה נחמד בדוגמא נקודה.
מה עושה בשיטה זו הוא זה רק אומר שאני רוצה שתתן לי תא.
רק דבר iOS.
אם יש לך משהו כמו 100.000 שירים ב-iPod
מה iOS לא רוצה לעשות הוא להקצות 100.000 תאים,
כי אם אתה בראש הרשימה שלך, האם אתה באמת צריך להקצות זיכרון
לתא זה 99000 שורות למטה?
לא, כי כמו שאתה גלילה אתה יכול להקצות סוג של כמו שאתה הולך יחד.
זה נעשה בשבילך.
אתה לא צריך לדאוג לכל הדברים האלה ביצועים טפשים.
כל מה שאתה אומר הוא שאתה קורא dequeueReusableCellWithIdentifier שיטה זו,
וזה אומר, בסדר, אם אתה צריך אני הולך ליצור תא חדש עבורך.
>> אבל אם אתה ובחלק התחתון של הטבלה כבר הוקצה כמה תאים
בחלק העליון של הטבלה שאתה ממש לא הולך צריך בזמן קרוב
אני הולך לתת לך אחד מאלה אחוריים במקום הקצאה חדשה,
ואז זה דאגת ביצועים נחמדה.
אתה לא צריך להקצות את התאים בעצמך.
זה הולך לתת לך בחזרה לתא.
זה הולך לחזור אליכם אובייקט תא.
ברגע שיש לך את אובייקט התא אתה יכול לעשות את הדברים אליו.
באפשרותך להגדיר את הטקסט של התא עם מאפיין זה נקרא תווית טקסט.
אתה יכול להוסיף חץ שמצד ימין או כמה דברים אקראיים אחרים
עם הרכוש האחר הזה שנקרא accessoryType, וכן הלאה וכן הלאה.
>> בואו נסתכל על יישום תצוגת שולחן עכשיו ממש.
כשיצרתי את הפרויקט הזה
במקום לומר יישום תצוגה יחידה שהגעתי דווקא לכאן
לבקשת אב - פרטים, ואז בעצם זה מתאים ליישום האלקטרוני
באייפד עם תצוגת השולחן בצד השמאל ולאחר מכן את התוכן בצד ימין.
ב-iPod או iPhone זה הולך מתאים לתצוגת שולחן אחד.
כי שם קבלתי את קוד המתנע שלי.
>> בואו נסתכל על לוח התכנון ראשון.
כל זה נעשה בשבילי, בעצם נוצר.
סרגל ניווט זה הראה לי מה תא דוגמה יכול להיראות כמו,
ואני יכול ללחוץ את זה, לשנות את הכותרת.
כל חששות UI אחרים אני יכול להתמודד שם.
קובץ הכותרת נראה ממש פשוט.
במקום לומר זה UIViewController עכשיו אתה אומר זה
TableViewController, כך שאנחנו יודעים שאנחנו רוצים לקרוא לכל השיטות הללו בטבלה.
הבא אני רוצה ליצור נכס שהולך לייצג את
גם הדברים בשולחן שלי.
שולחן זה הולך באופן שרירותי כדי להציג
רשימה של פרי, ולכן אני צריך ליצור כמה מערך
שבו אני יכול להכניס פרות.
בתוך קובץ היישום שלי הדבר הראשון שאני רוצה לעשות
הוא שאני רוצה לוודא שאני לאתחל מערך זה.
>> אמרתי alloc init, יצרתי מערך פריי,
ואני מוסיף 4 דברים אליו, שאחד מהם הוא הרבה יותר שנוי במחלוקת מ3 האחרים.
ועכשיו יש לי מערך בגודל 4.
אנחנו לוחצים אותו בCS50.
עכשיו יש לי מערך בגודל 4.
עכשיו אני הולך להתחיל לענות על שאלות אלה, ובעצם,
כשיצרתי את היישום הזה כל זה כבר עשה בשבילי.
לא היה לי להקליד את מספר הסעיפים בתצוגת טבלה.
זה כבר היה שם, ואני ממלא את החסר.
כמה מקטעים יש לי?
אחד. הכל נעשה.
כמה שורות יש לי?
ובכן, יש לי שורה אחת לכל פרי, ולכן ספירה זו
הוא רכושו של כל מערך שאומר כמה גדול הוא?
זה כמה שורות שיש לי.
לבסוף, אני צריך לומר מה כל תא נראה?
אני הולך לומר dequeueReusableCellWithIdentifier.
>> שוב, זה כבר נכתב בשבילי.
אני לא צריך לעשות את זה בעצמי, ואני רוצה לחזור
תא זה במיקום זה.
זכור שאנחנו קוראים באותה שיטה כל תא ותא,
וזה ויכוח כאן, ויכוח indexPath זה,
מה אומר שורה אני בפנים
אם אני אומר indexPath.row כאן
זה יהיה 0, ואז זה יהיה 1, ואז זה יהיה 2, וזה כל כך אני יודע
מה תא אני כרגע הצגה.
אני רוצה להגדיר את הטקסט של התא באמצעות מאפיין זה textLabel
ללכת בתוך מערך הפרות שלי ולקבל
האובייקט המתאים לכל שורה.
אם זה חוט, אני עכשיו הגדרה
מאפיין הטקסט למחרוזת.
אני יכול לעשות עוד דבר אחד.
אני גם יכול לרשום טיפול באירועים בכל אחד מהתאים,
ולכן כאשר אני נוקש כל אחד מהתאים האלה
didSelectRowAtIndexPath זה, זה הולך להיות שם עבורי,
כל כך פשוט על ידי ההגדרה הזו אני יכול להתמודד עם מה שקורה עכשיו
כאשר תקישו על תא, ושוב, אנחנו עוברים שבתא היה האזנה
כדי שנוכל לעשות שימוש חוזרים באותו מטפל אירוע זה לכל התאים שלנו.
>> שוב, זה משהו iOS עושה בשבילי.
בואו להציג עוד קופץ מעצבנת
זה פשוט אומר שבחרת בו משהו שמשהו
הולך להיות אובייקט השורה.
כאשר אני מפעיל את זה, אני הולך להיות תצוגת שולחן זה נחמד
בשורה אחת עבור כל אחד מפרות אלה, ואם אני מקיש 1
זה אומר לי מה קרה.
הגיוני?
בואו נבנה קצת יותר מורכב של יישום,
ככל שהלחיצה הרימה עגבנייה.
חלק נחמד על storyboarding
הוא שזה לא רק יעזור לנו מסכי עיצוב בנפרד,
זה גם יעזור לנו לקשור יחד את כל האפליקציה שלנו,
כך האפליקציה הסופית אהיה בניין זה נחמד ספורט קורא חדשות,
ואז זה הולך ליש מסכים מרובה, ולכן אני בעצם יכול לייצג
כל אחד ממסכים המרובים אלה בלוח התכנון,
ואני יכול להקטין את התצוגה ולראות האפליקציה שלי מרמה גבוהה.
>> על מנת ליצור בתוך אלמנט חדש של לוח התכנון שלי
זה ממש פשוט בתוך ממשק קבלן.
אם אני רוצה להוסיף מסך נוסף לזה, לדוגמה,
אני יכול להקטין את התצוגה ראשונה עם זום הקמצוץ כי אפל אוהב כל כך הרבה,
וכאן לפני שאחפש כפתור
ואני לגרור ולשחרר כפתור
אם אני רוצה ליצור רשת חדשה שבעצם יכול פשוט לגרור ולשחרר
בקר נוף כולו, כך שאם אני לוקח את זה, מושך אותו לכאן,
היי, יש מסך אחר, ואז עכשיו משתמש באותו קובץ לוח תכנון זה
אני יכול לקבל את כל המסכים בתוך האפליקציה שלי, ואני יכול להקטין את התצוגה
ולראות כיצד הם פועלים.
אלה לא יהיו אינטראקציה עדיין.
אופן שבו 2 המסכים האלה הוא אינטראקציתך להגדיר קשרי גומלין.
אתה בעצם יכול לומר מסך זה, כאשר אתה לוחץ על כפתור זה,
אני רוצה שמחליק מעל למסך החדש.
זה אומר שיש סוג כזה של יחסים בין
המסך הראשון והמסך השני.
יהיה לך חץ מכפתור למסך השני בעצם
אומר שכשאתם לוחצים על כפתור זה ששם אני רוצה ללכת.
בדיוק כמו שאנחנו שליטה לחצנו וגררנו להגדיר שקעים אלה
אנחנו הולכים לעשות את אותו דבר להגדרת segues אלה.
>> נראים דוגמה לכך, ולפני שאנחנו בעצם מעבר
ממסך אחד למשנה iOS הוא נחמד מספיק כדי לקרוא לשיטה זו
קרא prepareForSegue, וזה שבו אנחנו יכולים להתחיל
שליחת נתונים מיישום אחד למשנו.
בדוגמא שאנחנו עומדים מסתכלים על זה יהיה בעצם לאפשר לנו
כדי לסנן קבוצות בייסבול בליגות ופיצולים.
כאשר אני בוחר את הליגה, לדוגמה, אני רוצה מעבר
למסך הבא שבו אני יכול להציג את כל החטיבות
בליגה הזאת או כל הצוותות השונים.
אני צריך לשלוח לאותו מסך מה אתה צריך להציג צוותות.
כדי לעשות את זה אני הולך לנצל את השיטה הזאת כאן.
>> לבסוף, רק נקודה אקראית על iOS.
אם ברצונך לאחסן את הנתונים יש הדבר הזה שנקרא נתוני ליבה,
שהוא למעשה סוג של מסובך לעבוד איתו.
אתה יכול גם להשתמש ב-SQL לאחסון נתונים,
ששוב, הוא נחמד, אבל סוג של בצד המסובך יותר לעבוד איתו,
אבל iOS תומך גם דברים ממש מגניבים שנקראים רשימות רכוש,
ורשימת רכוש היא רק קובץ שמייצג זוגות ערך מרכזיים.
אתה מגדיר רשימה של מפתחות, ואתה אומר את המפתח הזה הולך להיות מערך.
מפתח זה הולך להיות מחרוזת, ובעצם כל דבר שאתה יכול לעשות
בJSON אתה יכול לעשות בתוך רשימת רכוש,
ואז זה באמת יפה מאפשר לנו לעבוד עם נתונים מסוימים.
לדוגמה, יש לי Teams.plist זה שאני יצרתי.
אני יצרתי קובץ plist חדש, ואני יכול להסתעף.
זהו מילון, זה מילון, אלה הם מחרוזות,
ואז זה ייצוג גרפי נחמד של מסמך JSON
או סתם אוסף של זוגות ערכי מפתח,
ואז זה את הנתונים שאני אעבוד עם האפליקציה פנימית שלי.
>> בואו נבוא לכאן לראשונה. יש לנו הרבה יותר קבצים עכשיו.
אבל בואו נבוא לכאן לראשונה ללוח התכנון.
לוח התכנון כאן, ואם אני יכול להקטין את התצוגה,
עכשיו אנחנו יכולים לראות שזה הוא הזרימה של האפליקציה שלי.
אני נוסע תחילה להתחיל במסך זה.
אני הולך לתחקור מטה למסך הזה,
ואני הולך לתחקור מטה למסך הזה, ואנחנו יכולים לראות כאן שאם אני סוג של
להזיז אחד מאלה שסביב החצים הללו הולכים מכאן לכאן,
וכפי שאני מגדיר את החץ שהיה אם אני להתקרב קצת,
אם נבוא לבקר השקפה זו ו,
והנה תא, ואני רוצה לומר שכאשר אתה מקיש תא
אני רוצה שמחליק מעל למסך אחר.
אני פשוט יכול להחזיק את השליטה,
לגלול על קצת, החזק את מקש שליטה, לגרור את התא הזה ולהרפות.
>> וכאן אנחנו אומרים מה המעבר שברצונך להשתמש?
האם אתה רוצה להשתמש שבשקופית דבר שנקרא לדחוף?
האם אתה רוצה להחליק למעלה מהתחתית?
זה נקרא מודאלית.
וברגע שאני לוחץ על אחד מאלה, זה הולך לצייר את החץ הזה בשבילי,
וזה אומר שגם אני מתייחס למה שקורה בפועל כאשר אני לוחץ על כפתור זה בצורה גרפית.
אני לא כתבתי את כל קוד למעשה להחליק ממסך אחד לאחד הבא.
אני הגדרתי את זה בתוך חזותי של ממשק קבלן.
אם אני לוחץ על החץ הזה, אנו יכולים לראות שנתתי את הדבר הזה שם.
אני קראתי לזה showDivisions, וזה כל כך שאני יכול לדעת
מה מעבר עומד להתרחש, ואנו רואים במה רק לשנייה.
ככה אני חוטית את המסכים השונה ביישום שלי.
אם זה היה כפתור, לדוגמה, במקום תצוגת שולחן,
אני יכול לשלוט ללחוץ על הכפתור, גרר מעל למסך הבא,
וככה אני יכול לעשות את זה דרך ניווט.
>> מהר מאוד, אם אנחנו באים לMasterViewController,
שוב, אנחנו פשוט הולכים להגדיר רשימה של דברים
שיוצג בתצוגת הטבלה.
כאן אני אומר שאני רוצה שתיקח אותו קובץ plist,
ואני רוצה אותך לטעון אותו למילון,
וברגע שיש לך מילון ש, אני הולך לענות את אותן שאלות שוב.
הנה מספר הקטעים.
אחד, יש שורה אחת עבור כל ליגה, ואת הטקסט של כל תא
צריך להיות ראשון, הליגה הראשונה, הליגה השנייה, וכן הלאה.
לבסוף, אני הולך להשתמש בשיטה זו שראינו הרגע קראה prepareForSegue,
וזו היא השיטה שהולכת להיות מפוטרים כאשר אני לוחץ
באחת מהשורות אלו, ולכן הפעלת מעבר ש
שאקים עם החצים.
זה אומר שאני יכול להיות מרובה
יחסים בין מסך אחד למשנו.
אם יש לי 2 כפתורים וכל כפתור יעביר אותך למסך אחר
אני הולך להיות 2 segues, 1 לכל כפתור.
אבל prepareForSegue זה הוא, שוב, הולך לשימוש חוזר
לכל אחת ממערכות היחסים השונים, אז זה אומר שאני צריך דרך
זיהוי אם אתה לוחץ על הכפתור הראשון, או שתלחץ על הכפתור השני.
>> זוכר שנתתי את הקונצרט ששם, זה showDivisions,
ככה שאני יודע עכשיו שזה על העניים שהופעלו.
כל מה שאני רוצה לעשות זה שאני רוצה להגיד
אני רוצה להבין מה בדיוק פגעתי,
וכך לקבל את זה, אני יכול להגיד שאני רוצה indexPath לשורה הנבחרת,
זוכר את indexPath רק אומר שבו אני פשוט לוחץ,
ואז אני רוצה לומר שאני רוצה להבין איפה אני עומד.
destinationViewController זה, זה רכושו של הרצף.
זה המסך שאני עומד,
אז אני יודע שהמסך אני הולך נקרא DivisionsViewController
משום שאני יצרתי מעמד ש,
ואז עכשיו אם אני אומר d.divisions
אני עכשיו הגדרת רכוש של בקר הנוף שאני עומד לעבור.
זה איך אני שולח נתונים ממסך אחד למסך אחר.
>> פשוט מסתכל על זה DivisionsViewController
אתם יכולים לראות כאן שב. קובץ h
יש שחטיבות הקניין, וזה מה שבעצם אני אכלוס,
אז ככה אני יודע שאני מציג את החטיבות המקבילות ל
הליגה שאני לוחץ, ושוב,
תצוגת השולחן בפועל נראית פחות או יותר אותו הדבר, רק עונה אלה
3 שאלות פשוטות, כמו גם זיהוי
מה קורה כאשר אתה עובר למסך הבא.
רק כמה דברים אחרים כאן.
שמתם לב שבחלק העליון כאן שבמקום לומר # כולל
עכשיו אני אומר # לייבא.
זה פשוט דבר Objective-C.
היבוא הוא בעצם גרסה יותר נחמדה מכולל,
ולדוגמה, אנחנו צריכים לדעת מה המעמד הזה הוא,
אז אני לא יכול פשוט להגיד DivisionsViewController.
אם לא הייתי בתוך hashtag standardio.c של. קובץ C שלנו
המהדר לא היה מושג מה היה printf.
בדומה לכך, אם אני לא לייבא DivisionsViewController
המהדר באמת אין לו מושג מה הוא DivisionsViewController.
רק לוודא שיש בתוך הקבצים מ שונים. לך לוודא לייבא
את קבצי h המתאימים. כך שהמהדר יודע מה קורה.
>> לבסוף, מה שאפל סופו של דבר עושה הוא להציג כמה נתונים באמצעות תצוגת אינטרנט,
וכן תצוגת אינטרנט היא אובייקט שבו אתה יכול להטביע
דפדפן אינטרנט קטן בתוך היישום שלך.
כל מה שאתה צריך לעשות הוא לספק כתובת אתר לדפדפן האינטרנט שלך,
אז אני רוצה ללכת לmlb.mlb.com,
וזה איך אני יכול לגשת לדף הבית לכל צוות,
וזאת על ידי ההעברה בכתובת זו
תצוגת האינטרנט יכול להציג את זה בשבילי, ואני יכול לגלוש בסביבה,
סימולטור ונמצא בשימוש על ידי זה.
עכשיו זה הגיע מplist.
אם אני לוחץ על זה זה גם בא מplist, וזזה זה טופלה
על ידי הגדרת segues אלה.
אני לוחץ על זה ועוד אחד,
ועכשיו הוא כאן UIWebView, כל כך פשוט כמו ש
הנה האתר לכתובת האתר שאני פשוט משובץ,
ולא היה לי להתמודד עם כל דבר מטורף.
זה איך להציג דף אינטרנט.
דברים כמו כפתור חזרה זה כאן גם ניתנו לי
לגמרי בחינם בגלל שהגדרתי את הקשרים הללו באמצעות segues.
>> יש שאלות? כן.
[סטודנטים] לכן, כאשר אתה משתמש alloc, אתה לא צריך שום דבר בחינם?
בדיוק, כאשר אתה קורא alloc וinit אתה לא צריך לשחרר אותו.
IOS הולך להתמודד עם כל זה בשבילך.
זה נפלא, ואתה לא שובר את כל כללים. כן.
[סטודנטים] אם היית כולל יותר קבוצות שיכולים להתאים על המסך,
הייתי זה באופן אוטומטי יש אפשרות גלילה, או משהו שאתה צריך להוסיף?
בדיוק, אם היה לי יותר צוותות, למשל, זה יהיה באופן אוטומטי להתמודד
הגלילה בשבילי, ואת כל חששות ביצועים
עם השולחן הענק מטופלים גם לגמרי בשבילי.
>> שאלות אחרות?
כל קוד שזה הולך להתפרסם.
אנחנו סוג של טושטשנו מעט את הפרטים הקטנים יותר,
אבל דברים כמו הגדרת מאפיינים מסוימים לאינטרנט הנוף
רק דברים שאתה יכול להשיג על ידי גלישת התיעוד של אפל,
שהוא באמת, באמת מסודר יפה.
יש להם הרבה של יישומים ושימושים לדוגמא דוגמה
של APIs השונה, אז בהחלט לעיין אלה אם אתה יכול.
רק כמה קישורים מועילים אולי כדאי לך להעיף מבט.
אלו הן כמה מדריכים שימושיים תיעוד.
את הכתובות הן מסיביות, אז הם קצרו.
הראשון זה כל הספרייה של תיעוד.
יש סורגי חיפוש קטנים, כך שאם אתה מתחיל כפתור הקלדה
הוא יתחיל לתת לך את כל המידע על כל הדברים שאתה יכול לעשות עם כפתור.
צרפתי גם מדריך תכנות צפו בטבלה.
הוא מטפל בנופי שולחן בפירוט רב יותר,
איך לעשות דברים כמו דינמי להוסיף תאים או תאים לערוך או להסיר אותם.
>> יש המון יישומים לדוגמה מתוך אפל שיראה לך איך לעשות את זה,
ולבסוף, אחרון זה את הנחיות ממשק אדם,
וזה בעצם חלק מדיון רכיבי ממשק משתמש,
דברים כמו לא עושים כפתור זה 4 פיקסלים על 4 פיקסלים.
זה רעיון לא רע, ודברים אחרים שאפל רוצה שתעשה
לעודד עיצוב טוב.
>> כל השאלות האחרונות לפני שאנחנו לסיים כבר?
בסדר, בהחלט מרגיש חופשי לשיחתנו תהיה לי תוויות מיוחדות על מה לדבר.
נצטרך iOS אחד, אז בהחלט תרגיש חופשי לנצל את זה.
אם אתה רוצה לעבוד עם החברים לכיתה שלך על פרויקטים
או לעזור להבין כמה דברי iOS אקראיים
תרגיש חופשי לשלוח לי דוא"ל, ובהחלט לעיין בכל הקוד באינטרנט כי
רק בעניין של זמן שאנחנו סוג של טושטשנו יותר
פרטים גרעיניים ממוקדים יותר בדברים.
אבל אם לא, אז מזל טוב על פרויקטי iOS שלך, ואני מקווה שיש לנו
נהירה גדולה של יישומים ב-App Store.
[CS50.TV]