>> Tianyu LIU: היי, איך זה זה הולך כולם?
וזה App iOS תכנות של סמינר ג האובייקטיבי.
והשם שלי הוא Tianyu ליו.
אני זוטר לואל עכשיו, להתרכז במדעי מחשב.
אז בסמינר זה אני הולך ללמד אתכם
קצת על איך לעשות אפליקציה.
Yay, להתרגש על זה.
>> אז לפני שאנחנו אפילו להתחיל לצלול לצד תכנות בפועל,
בואו פשוט באמת במהירות לדבר על מדוע ייתכן שתרצה לבנות יישום iOS?
למה הוא כל כך מדהים iOS?
אז הבעיה הראשונה, הראשון דבר שהוא די מדהים עבורנו,
במיוחד כCS50 סטודנט, הוא שiOS
משתמש Objective C. ובכן, יש שפה חדשה בשם סוויפט,
אבל אנחנו לא הולכים ל להשתמש בזה בסמינר זה.
אם אתה מעוניין בסוויפט, שם הוא סמינר עצמאי על זה.
אבל מטרת C היא בעצם קבוצה-על של משמעות ג
שכל מה שאתה משתמש ב- C יכול יתורגם לC Objective
מאוד בקלות.
>> כפי שאפשר לראות בהמשך, כי אכן יש כמה תחביר בסיסי מאוד, הם
בעצם בדיוק אותו דבר, C ומטרת C. אז,
מאז שצילמת CS50 עד לכאן, אתה כבר
יודע Objective-C, לפחות 40%.
כמו כן, אפל יש באמת API חזק עבור iOS.
יש הרבה של ממש מטורף דברים שאתה יכול לעשות עם זה.
אחד מהם הוא מישהו למעשה נוצר אפליקציה iOS
למכוניות שליטה, ש הוא די מעניין.
כנראה מסוק הוא יותר מרגש.
אבל ככה חזק API iOS יכול להיות.
>> וכפי שאולי יש לי הבין עכשיו,
הצפת המחסנית היא כנראה אחד המשאבים מקוונים החשובים ביותר
לרשותך.
וחדשות טובות, לכל אחת בעיה אולי אתה יכול
חושב עליך בעת הבנייה פרויקט גמר בObjective-C,
יש סיכוי תשובה הצפת מחסנית.
זה פשוט מדהים.
בנוסף לכך, iOS הוא באמת פלטפורמה
שבו אתה יכול להגיע ענק קהל עם מעט מאמץ.
זה לא כמו אנדרואיד, שבו הכל די מקוטע.
>> הכל iOS הוא אחיד.
וכל עוד אתה יוצר אפליקציה לאייפון,
אתה יכול מאוד בקלות נמל שלiPad, iPad mini, או גדלים שונים iPhone.
כל אלה הם ממש נוחים.
וזה פשוט ממש טוב בכדי להרשים את החברים שלך.
אתה פשוט יכול להחזיק iPhone ולספר לחבר שלך היי,
זה האפליקציה שאני עושה.
אתה יכול לעשות את זה עבור כל יישומי שולחן עבודה, וזה נחמד.
>> בסדר, עכשיו בואו ממש מקבלים לג Objective השפה
אז למה שלא תתחילו עם כמה באמת תחביר בסיסי.
כפי שציינתי קודם Objective C זה בעצם על של ג
כל כך הרבה תחביר הבסיסי למעשה בדיוק אותו הדבר.
הכרזה על משתנה ו הוספת שני משתנים יחד
בדיוק כפי שעשינו במריו.
שום דבר לא חדש כאן.
>> באופן דומה, הדייר ללולאה ותנאי הוא גם אותו.
אתה יכול לעשות עבור לולאה בדיוק כפי שאתה יש לי עשה במריו [לא ברור].
ואתה יכול לעשות תנאים בדיוק כמו מה שאתה
כבר עושה בסטי p הקודמים שלך.
עם זאת, מטרת C לא לגמרי C,
ויש משהו ש הוא סוג של מוזר על זה.
>> להיות ראשון שכאשר אתה עושה תכנות C, אתה בדרך כלל קורא ל
כולל ולאחר מכן את שם ספרייה.
אבל בC Objective אתה קורא יבוא ש.
בעצם אומר פונקציונלי, שמות פשוט שונים.
והמחרוזות למעשה קצת מוזר.
ניתן לראות כי הראשון דבר שהוא סוג של מוזר
הוא שיש לך די weird-- sorry-- יש לך NS די מוזר
לחתום כאן.
והדבר השני זה קצת מוזר
הוא שיש לך בסימן לפני למעשה מכריז על המחרוזת.
אז בסימן יסודו שמחרוזת היא לא רק מחרוזת,
הוא למעשה אובייקט.
אנחנו הולכים להסביר שתעשה מאוחר יותר, כדי לא
פאניקה אם לא להבין מה זה אומר.
והדפסה לקונסולה היא קצת שונה, כי בC אנו קוראים printf,
אבל בC Objective אנו קוראים [לא ברורים].
>> ייתכן שאתה תוהה מה זה.
זה בעצם printf, רק בשפה שונה.
בדיוק באותו השימוש, בדיוק את אותה פונקציונלי.
ובכן מתברר ש C האובייקטיבי למעשה
יש ns הקידומת כמעט ב הכל, כל סוג נתונים בסיסי,
nsstring, nsarray, nsdictionary.
הסיבה לכך היא ns למעשה עומד לשלב הבא,
אשר הינה חברה ש סטיב ג'ובס הקים,
אשר הינה חברה שבי C Objective שפה נולד.
אז זה בעצם מסורת.
אני יודע שזה קצת מוזר, אבל זה של אפל.
>> אז משהו שהוא אפילו יותר מוזר יותר מזה הוא הצהרה על פונקציה.
זה שונה מאוד ממה שאנחנו לראות בC, כי כאן זה בעצם
לא נראה כמו C יותר.
מה שיש לך על ידי here-- דרך זו אינה נקודת כדור,
זה סימן מינוס.
יש לך סוגריים סימן מינוס חלל ולאחר מכן את שם הפונקציה.
בואו נגיד אם יש לי שלום עולם, ולאחר מכן
סוג ההחזרה יהיה חלל כי אנחנו חוזרים שום דבר.
>> מה מקבל ממש מוזר הוא שכאשר אתה
יש פרמטר אחד או יותר עובר לאותו תפקיד ש
יהיה ממש מוזר כפי שמוצגים כאן.
יש לנו שם שיטה, addInt נקרא ל[ לא ברורה]
ואנחנו עוברים פרמטר אחד.
אבל אחרי זה, יש לנו יותר שם שיטת שיחה עם.
ואחרי עם אנחנו עוברים הפרמטר השני.
זהו למעשה קצת מוזר, אבל כל הצהרות הפונקציה הבאות
בצע את אותו דפוס כמו זה.
>> יש לנו סימן מינוס מלכתחילה.
סימן מינוס יכול להיות סימן הפלוס לפעמים מבוסס על איזה סוג של שיטה
זה.
שיטה היא בעצם שם אחר לתפקיד.
ואנחנו הולכים ל להסביר שמאוחר יותר, כאשר
על אובייקט שאנחנו מדברים תכנות מונחה.
אתה מציין את החזרה הראשונה הקלד סוגריים בפנים,
לאחר שמגיע שם השיטה.
אתה עובר פרמטר אחד.
ואם יש לך יותר פרמטרים אתה צריך להאריך את שם השיטה
ובעצם לכתוב משהו יותר כאן.
>> זה יכול להיות כל דבר שאתה רוצה.
במקרה שלנו זה עם.
אבל אפשר לומר סוף, או או, או בר abc מלא, מה שאתה רוצה.
ואז אחרי שאתה עובר פרמטר b.
זה ממש מוזר אבל אמנה אנחנו
הולך לראות למה Apple רצה לעשות את זה מהר מאוד.
אז איך אתה קורא לפונקציה?
קורא לפונקציה במטרה C הוא גם שונה מג
>> למעשה, קורא פונקציה בC Objective
הוא יותר כמו שאתה מדבר עם מישהו.
כאן יש לנו עצמי, ש נקרא אובייקט.
אתה רוצה להגיד לי בעצם מתנגד עצמי לומר "שלום העולם!"
כלומר איך לקרוא לפונקציה.
אובייקט ושם שיטה בשילוב עם אחד את השני.
וזה המקום שבי הסיומת המוזרה לשם שיטה באמת נכנס לתמונה.
>> בואו נסתכל על הדוגמא השנייה.
אנחנו פשוט מוגדרים בשיטה המכונות addInt עם בלה בלה בלה.
אז במקרה הזה כאשר אתה מתקשר [ספציפי ש? הודעה?] זה הולך
להיראות כמו addInt העצמי: 10 עם: 2.
זה נשמע כמו אנגלית.
למרות שהפונקציה הצהרת פונקציה היא מוזרה,
נקודת C של המטרה דפוס הצהרת שיטה,
הוא שכאשר אתה מתקשר הפונקציה או שיטה
זה נשמע כמו אנגלית בפועל.
אז זה מאוד אינטואיטיבי ברגע שאתה נכנסת לזה.
>> במיוחד במקרה זה, שבו אתה יכול בעצם
רואה ששם הפונקציה הוא סוג של התיעוד עצמו.
אתה לא צריך שום הסבר יותר לראות
מה בדיוק קורה, מה בדיוק פרמטר אחד עושה.
הולך מעבר לזה, בואו נדבר קצת קצת על תכנות מונחה עצמים.
תכנות מונחה עצמים הוא אחת מתכנות הבסיסי
טכניקות או דפוסים שהן בשימוש על ידי C Objective C. מטרה
נקרא Objective-C, לא C, מסיבה ממש טובה.
>> אז לפני שאנחנו נכנסים ל תחביר C אובייקטיבי,
בואו באמת נראים במהירות ב מה בדיוק הוא אובייקט.
כנראה שעשינו משהו כמו אובייקט לפני ש
נקרא struct כאשר אתה יישום עץ או רשימה מקושרת
או [? לנסות. ?] אז, זה בעצם כמו struct,
אבל זה הרבה יותר חזק ממה ש.
יש אובייקט שיטות ומאפיינים.
שיטות הן בעצם פונקציות.
בעצם פונקציות ש ספציפי לאובייקט מסוים.
>> ומאפיינים הם בעצם שדה ציינת בstruct.
אז עבור כל אובייקט יש לנו כמה רכוש
שיש לו כמה משתנים ש ספציפיים לאובייקט.
ויש לנו כמה פונקציות ש גם ספציפיים לאובייקט.
והפונקציות נקראות שיטות והמשתנים נקראים מאפיינים.
זה פשוט שם מפואר.
בעוד העובדה שאתה, כל מבט אתה רואה בזמן שאתה פותח את יישום iOS,
בואו נגיד טוויטר או פייסבוק, כל מבט שאתה רואה זה אובייקט.
ואפילו כל האפליקציה היא אובייקט להתחיל עם.
מושג מאוד מעניין.
>> ולמה אנחנו רוצים אובייקט תכנות מונחה?
אז אתה יכול לדמיין שכאשר אתה תכנית שהוא מקבל די מסובך.
בואו נגיד כשאתה יישום לוח שחמט,
ההיגיון הולך להיות מסובך באמת.
יש לך 36 שונה חתיכות, כך שאם אתה
רוצה לכתוב היגיון לכל 36 חלקים שונים בשחמט,
זה הולך להיות הרבה פונקציות שונות ומשתנים.
זה הרבה צרות.
וכנראה שאתה הולך לכתוב שיטה אחרת או תפקיד אחר
לכל אחד מהחתיכה ל בדיוק לשלוט במה שהם עושים.
>> אבל אם אתה עושה מונחה עצמים תכנות, כל היצירות האלה
ניתן הפשטה ל אובייקט אחד ואחד.
והאובייקט יהיה קצת נפוץ תכונות, כמו איזה סוג של פיסה
זה?
איזה צבע זה?
איך זה יכול לעבור?
וכך יש לך מאוד פישט את ההיגיון שלו.
אז זה רק דרך ממש טוב כדי להפוך את התוכניות מסובכות,
ומערכת יחסים היררכיות במסגרת התכנית, פשוט מאוד.
כפי שאנו הולכים לראות למה מהר מאוד כש
אנחנו בעצם עושים programming-- כשאנחנו למעשה
עושה קוד S תכנות פגישה מאוחרת יותר.
>> ובכן, בנוסף לזה, תכנות מונחה עצמים
רק הרבה כיף.
יש לך לעצב האובייקט שלך.
יש לך לעצב את מה שעושה זה נראה כמו בעצמך.
אין תשובה נכונה לזה.
וזה מעניין לחלוטין.
אז בתכנות מונחה עצמים, שני מושגי יסוד
יהיה מעמד ודוגמה.
כיתה היא בעצם תבנית לאובייקט.
ודוגמה היא בעצם אובייקט ספציפי אחד.
>> בואו נגיד שאתה עושה את עוגייה.
במקרה זה, כל אחד עוגייה אתה באמת בסופו של דבר עם
הולך להיות אובייקט.
אבל צלחת העוגיות אתה משתמש כדי לאפות כל העוגיות תהיה בכיתה.
כיתה היא בעצם תבנית.
והדוגמא תהיה ספציפית אחד אובייקט שנוצר מהכיתה ש.
>> ודוגמה תיווצר בהסתמך על הצהרה בכיתה,
כפי שנראה בשקופיות מאוחר יותר.
אז בואו באמת עושים באמת דוגמא מהירה [לא ברור].
נניח שאנחנו מכריזים אובייקט לחתול.
האובייקט צריך have-- כיתת החתול צריך
יש כמה מאפיינים ושיטות.
איזה סוג של תכונות צריכים כיתת have-- צריכה החתול?
>> לדוגמא, צבע, גיל וגזע, אלה
יהיה משתנה ש הם ספציפיים לכל חתול.
ואלה כמה דברים שאנו משתמשים כדי לתאר את חתול.
איזה סוג, של שיטה או מה חתול יכול לעשות?
כמה דוגמאות מהירות תהיה מרדף עכבר, לאכול דגים או פשוט meow.
זה באמת מהיר דוגמא לכיתת חתול.
ובאמת ספציפי אובייקט חתול יהיה חתול
שבו אנו מציינים את צבע, הגיל וגזע.
>> במקרה זה, האובייקט שלנו הוא כבר לא ברמה יותר.
אנו להעתיק את התבנית מהכיתה ו אנו מציינים כל מידע ספציפי
שלאובייקט מסוים כדי להפוך אותו עצמאי.
וכשאתה מתקשר שיטה בתוך אובייקט,
אתה פשוט קורא meow על האובייקט, שהוא החתול שזה עתה יצר.
>> כנראה שתדפיס משהו כמו "Hello World!
מייאו. "
די חמוד.
בסדר, בואו פשוט להיכנס לכמה פרטים
ולראות מה עושה בדיוק את זה לתרגם להיות תכנות iOS.
אז בiOS תכנות כל כיתה תיושם בשני קבצים.
קובץ אחד הוא כאן, ש נקרא הממשק.
קובץ נוסף הוא כאן, ש נקרא יישום.
>> בדרך כלל הממשק יהיה לי extension.h
כפי שראינו בספריות C.
וקובץ יישום הוא הולך להיות extension.n.
זה קצת מוזר.
אבל .n בעצם אומר .ג, אין הבדל מהותי בין
שתי.
אז במקרה הזה, אנחנו יכולים לראות שאנחנו הכרזת ממשק, חתול: אובייקט.
זה נקרא ירושה.
אנחנו יורשים בעצם כיתת חתול מכיתת האובייקט.
אז כל רכוש ושיטה שהיה שהוגדר בעבר בכיתת האובייקט
יוגדר באופן אוטומטי בכיתת חתול גם כן.
>> בנוסף לכך, אנו מגדירים צבע, גזע, וגיל, שלושה משתנים.
שבאמת נראה כמו משהו שעשית בעבר.
זה נראה כמו struct.
זה בעצם התחביר להצהרת struct,
וזה נכון לחלוטין.
ומכיוון שהזכיר לי לפני, ההבדל struct
ואובייקט, אחד מ הבדלים בסיסיים
הוא שיש אובייקט שיטה, בעוד struct יש רק משתנה.
אז בנוסף לתכונות או משתנים שיצרנו עבור האובייקט,
אנו מציינים כמה שיטה.
>> בואו נגיד שיש לנו כאן שתי שיטות, אחת היא מיאו,
עוד אחד הוא עכבר מרדף.
אנחנו כנראה רוצים להיות חולפים פרמטר המבוסס על השיטה הקודמת שלנו
דפוס הצהרה.
אתה בטח רוצה להיות עובר עכבר.
ואתה בטח רוצה לחזור מסמנים bool
אם החתול שלך יש בהצלחה תפס את העכבר או לא.
>> זהו הממשק, אבל אנחנו יכולים רואה שהממשק למעשה
לא עושה כלום.
זה רק אומר לי תכנית מה exists-- מה שמקיים בכיתת החתול.
אז על מנת ש תכנית לעשות משהו,
אנחנו צריכים קבצי יישום.
אז הנה, הדבר הראשון שאנחנו עושים הוא ברור שאנו מייבאים את הממשק.
לאחר שאנו מייבאים הממשק, אנו מגדירים את השיטה.
>> בואו רק נאמר כאן meow היה להדפיס את פשוט
"Hello World!" למסוף.
ולאחר היישום קובץ, אנחנו די הרבה לעשות.
זהו בעצם כיתה הכרזה לכיתה אחת.
אז עכשיו השאלה הוא, איך אתה מצהיר על משתנה?
הדרך בה אתה משתמש בכיתה כדי ליצור אובייקט במטרת C שכתוב כאן.
>> אתה מציין ראשון ש זה הוא מצביע חתול,
משום שכל אובייקט במטרת C לבסוף מיושם כמצביע.
ואתה קורא בכיתה, קורא להם כalloc, שהוא בעצם malloc,
אומר לי מערכת ההפעלה שב צריך קצת מרחב זיכרון לאובייקט זה.
אחרי שיש לך אובייקט כבר ואתה פשוט לאתחל אותו.
זוהי רק מוסכמה.
אני יודע שזה הוא קצת מוזר, אבל זה בעצם איך אפל עושה דברים.
>> הקצאת נכסים הוא למעשה די פשוט.
זה מאוד דומה ל מה אתה עושה כש
אתה הקצאת חלקם ספציפי שדה הפנימי של struct.
רק יש לך משתנה שם, שם הרכוש,
ולהקצות ערך ספציפי אליו.
וקורא שיטה דומה מאוד.
שיטה קוראת היא בעצם מה שאני מדבר על
להעמדת שיטה כלשהי בג Objective
>> אתה עובר אובייקט, ב מקרה זה הולך להיות myCat,
ואתה עובר שם השיטה.
כאילו שאתה מדבר על האובייקט, myCat, כי אתה צריך meow.
זה די מעניין.
לאחר מכן, יש אחד תבנית עיצוב חיונית יותר
שאנחנו צריכים לדבר על לפני שמגיעים לקוד S בפועל.
שדפוס העיצוב נקרא אירוע מונע תכנות.
זו גם כנראה אחד ביותר רעיונות בסיסיים בתכנות iOS.
>> אז אתה כנראה לא יודע מה בדיוק הוא תכנות האירוע מונחה,
אבל זה לא באמת כל כך מפחיד.
ובכן למעשה, יש לך כבר עשה את זה לפני.
זהו אחד מהקווים שיש לך כנראה כבר נכתב ב[ לא ברור] האחרונה
של CS50, google.maps.event.addListener (סמן,
"לחץ", פונקציה () {}) :.
על ידי קורא את הקו הזה אתה למעשה הוראה למחשב
כי בכל פעם שנקרא האירוע "לחץ על" קורה על הסמן,
להשתמש בפונקציה ש.
>> זה שונה מאוד מ מה שאתה עושה בmario.c.
בmario.c אתה פשוט להפעיל את התכנית פעם אחת, זה נותן לך פלט,
ותסיים.
אלה הם כמו סוג של תוכניות ירייה אחת.
תוכניות אירוע מונע מאוד, מאוד שונים.
בואו נדמיין, אם פייסבוק הוא אחד תכנית ירייה זה לא ממש טוב.
אתה פשוט ללכת לפייסבוק פעם אחת וזה נעשה.
זה נותן לך כמה פלט ואתה אף פעם לא קיבלת אותו בחזרה.
אתה אף פעם לא קיבלת שום דבר יותר.
>> אז הנה, במיוחד הדפוס אנו משתמשים הוא
אירוע מונע, כך ש כל פונקציה
להיתפס על סמך מה אירוע שקרה.
לדוגמא, אם יש לנו כפתור ולציין
כי בכל פעם שלוחץ על הכפתור, לקרוא לפונקציה הנקראת "Hello World!"
בדרך זו אנו יכולים באמת לנהל את היגיון הפונקציה
לזרום בצורה גמישה מאוד.
המשתמש יכול לעשות או לקרוא לפונקציה שכבר קרא כבר.
זה מבוסס לחלוטין על מה שמשתמשים עושים.
>> אז אנחנו יכולים לראות שזה הוא למעשה הרבה יותר טוב מאשר mario.c.
וחדשות טובות היא שזה בעצם לא רעיון חדש.
אתם כבר עשיתם שבבעיה האחרונה שנקבעה.
אז במטרת C יש שלושה תרשימים שונים
לתכנות מונחה אירוע.
התרשים הראשון הוא נקרא פעולת יעד,
שבו אתה קושרים כפתור עיתונאים עם כמה פונקציה.
בואו רק נאמר, בכל פעם שאתה לוחץ איזה כפתור, אתה קורא כמה פונקציה.
זוהי פעולת יעד מאוד פשוט.
>> השני הוא למעשה הכי הקשה,
זה נקרא משלחת בפרוטוקול.
אנחנו הולכים להסביר כי בפירוט רב מאוחר יותר.
והדרך השלישית היא הודעה.
זהו למעשה לא חשוב מאוד מבחינת
כפי שאנו מודאגים, משום שהסיכוי כי אתה הולך להשתמש הודעה
בפרויקט הגמר שלך הוא די נמוך.
אז אנחנו הולכים לדלג על החלק הזה.
>> ואנחנו הולכים לצלול למשלחת בפרוטוקול.
אז מה בדיוק פרוטוקול?
או מה בדיוק הוא משלחת?
בואו נדבר על פרוטוקול להתחיל עם.
פרוטוקולים אינם אלא אירועים.
אבל מקבלים את האירועים הללו ל לך על ידי Apple כדי להתחיל עם.
לדוגמא, אני לא לגמרי בטוח כמה מכם
בחורים להשתמש המקורי של אפל דואר אפליקציה או מגע,
אבל בכל פעם שאתה לגלול שולחן ולחץ על תא המסוים
על השולחן, כי הוא אירוע.
>> ואם אתה רוצה לעשות אירוע זה בעצמך,
זה בעצם קצת קשה.
אז אפל נתנה שגם לך כך שאתה יכול פשוט להשתמש ישירות
האירוע לעשות משהו בעצמך.
פרוטוקולים הם למעשה באמת, באמת בשימוש נרחב
במטרת ג ובכן ב למעשה, כל יישום
יש משהו תפס את נציג אפליקציה.
בתוך עדין הוא כל פרוטוקולים לטעינת האפליקציה.
>> בואו נגיד שיש אירוע לאפליקציה עשה עומס.
אז מה צריך לקרות אחרי שיש לך נוצרה אפליקציה, לאחר שאתה פותח את האפליקציה,
לאחר שתסגור את האפליקציה, או לאחר אתה שם את iPhone לישון.
כל אלה הם האירועים שיש כבר ניתנו לך.
ובמקור בתוך חלקיקים אלה לא יהיה יישום.
אפל פשוט אמר לך שפונקציה זו יקרה כאשר אירוע כלשהו קורה,
אבל מה שאתה עושה עם זה פונקציה היא לגמרי תלויה בך.
>> משלחת היא בעצם אומר לי הכיתה
כי אתה צריך לטפל בפרוטוקולים אלה.
זה קצת מבלבל, אבל זה יהיה
הרבה יותר ברור כאשר אנו עושים הקודים של בפעולה.
משלחת בפרוטוקול היא למעשה מנגנון חזק מאוד במובן
שאם אנחנו עושים משלחת למחלקה מסוימת,
אנחנו יכולים להתמודד עם מהות כל מיני אירועים
שימוש בכל כיתה יש לנו, כלי נוח מאוד.
>> אז דוגמא מהירה אחת ל משלחת בפרוטוקול
יהיה מה שאני רק דיברתי עליו.
פרוטוקול זה במיוחד נקרא tableview [לא ברור] בחר תפקיד
ב[? מדד?] [? האחרון. אז?] זה אירוע שייתפס כשאתה
למעשה להקיש על ספציפי תא בtableview שלך,
בואו נגיד בדואר שלך או ביישום אנשי הקשר שלך.
>> בתוך פונקציה הייתה במקור ולא עושה כלום.
הפונקציה לא לעשות כל דבר כברירת מחדל.
אבל אתה יכול לציין מה הפונקציה עושה,
בהתחשב במה שאתה רוצה מתוך היישום שלך.
כלי נוח מאוד.
ועם כל זה נאמר, אני בעצם
לכסות חלק תחביר בסיסי מאוד ו מושג יסוד לC Objective
תכנות, ואנחנו יכולים לעשות קצת קוד של.
הרבה יותר מרגש.
אז הקוד של הוא למעשה קצת מכריע
כאשר אתה פותח אותו בפעם הראשונה.
>> הערה מהירה אחד, כך שאם אתה רוצה לעשות פיתוח iOS,
אני מאוד ממליץ לך מק.
מכיוון עושה פיתוח iOS ב Windows היא באמת, באמת קשה.
זה בר ביצוע, אבל זה ממש קשה.
ואתה בהחלט לעשות לא רוצה להשתמש בעריכת ז.
אז בקוד של שיש לנו מספר תחומים שונים.
כאשר אתה ראשון לפתוח את קוד של תוכל לראות אזור ניווט,
אשר בעצם מראה את כולכם קבצים שנמצאים בפרויקט הנוכחי שלך.
>> יש לך אזור סרגל כלים, ש הוא בעצם ניהול תצוגות,
או כמה מעט מהיר כלים על הקוד של עצמו.
וזה אזור העורך בפועל.
אזור זה הוא לערוך g דומה מאוד, אבל הרבה יותר טוב מאשר לערוך g.
ובאזור זכות זו, היא נקרא אזור השירות.
האזור הופך להיות ממש שימושי כאשר אתה יוצר ממשק או ציון
כמה הגדרות מהירות עבור היישום שלך.
>> והשטח הסופי הוא ניפוי השגיאות.
אזור זה כולל את הקונסולה.
אז בכל פעם שאתה אומר printf, או nslog במקרה שלנו,
כל התוצאות שלך הולך להיות מודפס כאן.
בסדר?
אני מניח שאנחנו באמת יכולים לעשות במהירות דוגמא לתכנות iOS.
ובואו למעשה לפתוח את קוד של.
אז בכל פעם שאתה פותח את קוד של, זה הולך להראות משהו כזה.
זה הולך לשאול אותך מה אתה רוצה לעשות?
האם אתה רוצה להתחיל משהו אקראי, מגרש משחקים, בעצם אתה
רק יכול לבדוק את קוד ללא למעשה התחייבות לכל יישום.
>> האם אתה רוצה ליצור פרויקט חדש?
או שאתה רוצה להמשיך לעבוד על הפרויקט קיים?
במקרה שלנו אנחנו הולכים כדי ליצור פרויקט חדש.
אז זה ממש נחמד, S קוד בעצם יש כבר
נתתי לך כמה תבניות ליצירת אובייקטים.
אם אתה רוצה לעשות משחק, זה קוד למעשה יש תבנית משחק בשבילכם,
יש יישומי דף מבוסס, יישום מבוסס כרטיסייה.
במקרה זה, אנחנו הולכים לעשות משהו מאוד פשוט,
ואנחנו הולכים להשתמש ב יישום תצוגה אחת.
>> לאחר שרק מה שאתה רוצה לקרוא ל המוצר שלך, ומה השם שלך,
מה המזהה שלך, ו באיזו שפה אתה משתמש.
כאן אנחנו לא רוצים לבדוק באמצעות Core נתונים.
Core Data הוא בעצם databasing iOS.
אם אתה עושה Core Data, זה קוד הולך להגדיר
שיעורים מסובכים הרבה יותר בשבילך.
אז כדי לשמור על הכל פשוט, אנחנו רק הולך לעשות בלי Core Data
עכשיו.
>> הבעיה שאנחנו הולכים להיות באמצעות הוא that-- הבעיה
אנחנו הולכים להיות יצירת הוא שאנחנו בעצם רוצה לייבא מריו מC
ליישום iOS.
אז בואו נקראים לזה מריו iOS.
כמובן שתציין את מה שאתה רוצה לשים בפרויקט שלך.
ויש לנו ללכת.
>> אז זה קצת מכריע, אבל זה בעצם
מה שראינו בשקופיות.
והאזור הראשון שאנחנו רואים עכשיו הוא בעצם פרויקט תצורה.
אז כל מה שאתה רוצה לעשות פרויקט, איזה סוג של מכשיר,
בואו נגיד איזה סוג של מכשיר אתה רוצה האפליקציה שלך תופיע ב?
האם זה iPhone, iPad או אוניברסלי?
אז אורינטציה של מכשיר, את כל הדברים האלה.
לא מאוד חשוב, אבל יכול להיות, אבל זה
הוא מקום שבו אתה מגדיר את הפרויקט שלך אם אתה באמת
רוצה לפרוס בחנות של אפל.
>> בסדר, בואו נסתכל על משהו שהוא בתוך הקוד שלנו.
בואו נעבור נווט הקובץ.
וכל אלה הם הקבצים שכבר באתי עם התבנית, נחמדה מאוד.
לכן, כאשר אנו לחצו על אחד מהם זה מה שזה נראה.
דומה מאוד לעריכת g.
אבל אתה יכול לראות ש הדגשת תחביר היא כנראה
קצת יותר נחמד.
וזה בעצם הרבה יותר חזק מאשר עריכת g.
ואתה יכול להשלים אוטומטי הרבה דברים בשבילך,
כפי שנראה מהר מאוד.
>> בואו לפתוח את האזור לאיתור באגים גם כן.
בסדר, כפי שניתן לראות, הקונסולה היא ממש כאן.
זה מה שאתה הולך לראות בי אתה בprintf או nsloging משהו.
אז בלי עיכובים נוספים, בואו למעשה לקמפל את האפליקציה ולראות מה קורה.
תכונה חיונית אחד ל קוד של, הוא שהקוד של
מגיע עם סימולטור iPhone.
אז אתה לא צריך iPhone לנסות את הפרויקט שלך,
קוד של שיכול לדמות ל אתה, כפי שאנו רואים עכשיו.
>> זה די נחמד.
זה לוקח קצת קצת זמן כדי ללקט
ובעצם יש לנו יישום ריק,
אשר למעשה לא עושה כלום.
אבל זה הידור.
זה די מדהים.
זה הרבה יותר טוב מאשר C, הא?
בסדר, אז בואו תנסה להוסיף משהו.
קובץ אחד שהוא קצת מוזר כאן נקרא לוח תכנון.
זהו למעשה גדול, תכונה מדהימה לקוד של.
משום שבקוד של, אתה בעצם יכול לגרור ושחררו אלמנטים על הממשק
וזה יהיה ישירות להופיע.
בואו ננסה את זה.
>> אנחנו שחררו תווית כאן, "Hello World !!!"
אנחנו יכולים למרכז ש.
די מגניב.
עכשיו בואו נרוץ סימולציה תחנה זו.
כאן יש לנו "Hello World !!!"
אנחנו אפילו לא עשינו שום קידוד עדיין.
מה לעזאזל קורה?
כך חזק ממשק Builder יכול להיות.
מישהו אפילו אמר ש כנראה שאתה יכול פשוט
להשלים את יישום ללא כתיבה כנראה אלף שורות קוד
רק על ידי שימוש בממשק Builder.
אבל זה כנראה לא הדרך הטובה ביותר לעשות את זה.
>> עכשיו בואו באמת ניגשים לקידוד.
אז המבנה של הקובץ הוא למעשה באמת מעניין
כי, כפי שאתה יכול לראות, יש אין פונקציה העיקרית בכל מקום.
רואה?
כפי שהזכרנו קודם, אתה יכול לראות שזה
הוא קובץ יישום למחלקה מסוימת.
אבל אין בשום מקום עיקרי.
אז איפה הוא עיקרי?
למעשה, יש עיקרי, אבל עיקרי הוא למעשה מוסתר ממך.
העיקרי הוא כאן.
שנראה מוכר.
>> אז בעצם מה שiOS הוא עושה בתוך ראשי
הוא שכל פעם שעיקרית הוא בשם, שהוא בעצם
בכל פעם שהאפליקציה מבוצעת, זה יוצר אובייקט נקרא AppDelegate.
כפי שציינתי קודם, כל אפליקציה היא למעשה אובייקט בפני עצמו.
אז בדרך זו, בעצם האפליקציה iOS אומרת למהדר
אישור זה, אני הולך ליצור מוצר שנקרא AppDelegate,
וכי הוא הולך להיות האפליקציה שלי.
אז אתה צריך ללכת דרך AppDelegate ש
ותראה מה הבחור הזה עושה.
התפקיד שלי הוא עשה בשבילי.
>> ובAppDelegate אתה יכול לראות ש יש כמה פונקציות ממש מוזרות,
גם למעשה שיטות, ש אפל כבר נתן לך.
מה אלה?
אלה הם למעשה רק פרוטוקולים שאני מדבר.
אז אלה הם אירועים שApple נתן לך להתחיל עם.
אין שום דבר בכמה של הפונקציות עכשיו,
אבל אם אנחנו רוצים לאתחל משהו לאפליקציה שלנו
לפני שנכנס למוצגות כל תצוגה, אנחנו עושים את זה כאן.
>> רק אתה יכול לקרוא את שמו ואני מניח ש האירוע הוא למעשה ממש ברור.
אז עכשיו עיקרי יצר אובייקט לAppDelegate.
ומה AppDelegate הוא הולך לעשות הוא למעשה גם מוסתר ממך.
AppDelegate עומד להתחיל טעינת מניית ViewController.
אז זה בעצם הולך להתחיל טוען את כל הדעות שיש לך
ורק להבהיר את התצוגה המבוסס על ההיררכיה.
>> אז במקרה הזה יש לנו רק מבט אחד, שהוא כאן.
כך שהוא יחיד ש זה הולך להיות בשם.
היגיון ViewController הוא ממש כאן.
זהו הקוד שלמעשה שולט בנוף רק שראינו.
בסדר, בואו נעשה משהו כאן.
אז viewDidLoad נשמע כמו אירוע, כאשר למעשה זה הוא גם נציג,
זה גם פרוטוקול.
>> אז מה הדעה נטענת, כל מה שבתוך הפונקציה
ייקרא.
במקרה זה אנו צריכים לראות "שלום Tianyu! "אם אנחנו מפעילים את התכנית.
זה מתחיל להיות קצת איטי עריכת קבצי לוח תכנון.
ובכן אכן, אנו רואים פלט עבורו.
זה די מגניב.
עכשיו בואו בעצם לעשות מריו.
אני הולך להגדיר את לתפקד מהר מאוד.
marioWithLevels: תוצאות (int) רמה.
>> בסדר, זה בעצם מדהים תכונת השלמה האוטומטית של קוד.
לכן, כאשר אתה כותב ולהקלד להיכנס, זה כבר נתן את התבנית
בשבילך, וזה די מגניב.
זה צריך להיראות ממש מוכר לכם.
מצטער, זה באשמתי.
בסדר, מגניב.
ההיגיון שצריך נראה ממש מוכר לכם, במיוחד רק מריו.
>> אבל אנחנו עכשיו להדפיס ל הקונסולה בכל פעם,
כי אנחנו רוצים לשמור איכשהו מסלול של מה שאנחנו מדפיסים.
אנחנו הולכים להשתמש ב תוצאות איכשהו מאוחר יותר,
כדי להציג את ההדפסה את התוצאה למשתמש.
אז במקום שאנחנו פשוט nslogging הכל,
שאנחנו אחסון הכל לקריאה לפונקצית תוצאה מכך,
אבל ההיגיון הוא בדיוק אותו הדבר.
אחרי שנסיים את זה, אנחנו פשוט להדפיס את התוצאות שלנו.
>> וכאן במקום להדפיס אותי שם, אנחנו הולכים לקרוא לפונקציה.
בואו לראות מה קורה.
אופס, כמובן.
יש לנו נחמד פירמידה קטנה כאן.
זה בעצם C, אנחנו רק מניפולציה שבו אתה קורא לפונקציה
ואיך פונקציה נראית כמו.
אין שום דבר שונה.
אבל זה בעצם לא מאוד מרגש כאן,
בגלל שאנחנו לא רואים שום דבר מיישום iPhone.
>> אז אם אתה באמת צריך iPhone app-- אם באמת יש לך זכות מריו iOS
עכשיו, אתה לא הולך לראות כל דבר ש
יש משהו לעשות עם מריו כי כל יציאות אלה לקונסולה
הם מוסתרים ממשתמש.
זה מה שאתה רואה, אשר הוא "Hello World !!!"
לא טוב.
עכשיו בואו ננסה לעשות את המשתמש לראות מה בדיוק אנחנו מדפיסים את.
אז אנחנו לא צריכים לתייג יותר.
בואו ננסה להבין משהו אחר שיכול להיות שימושי.
>> יש למעשה אחד אלמנט שנקרא
שדה טקסט, שיכל להיות מאוד מועיל לנו.
זה בעצם מציג אזור טקסט שניתן לערוך.
אז זה נראה באמת מועיל.
עכשיו בואו לגרור אותו ושחרר אותו.
וואו, יש לנו תצוגת טקסט לדעתנו, מפואר באמת.
זה קצת גדול מדי.
בואו נעשה את זה קטן יותר.
הכניס אותו לתוך מרכז.
יקטין אותה גם כן.
>> עכשיו יש לנו תצוגת טקסט, שבו אנו יכולים לשמש כדי להציג התוצאה הסופית שלנו.
אבל כרגע זה בהחלט לא הולך לעבודה
כי יש no-- ViewController אנחנו פשוט
מוגדר לא יודע ש יש תצוגת טקסט שם בחוץ.
אז אנחנו צריכים איכשהו לקשר את תצוגת הטקסט פשוט
נוצר עם הכיתה ש כבר בא איתנו.
>> הדרך בה אנו עושים את זה היא למעשה קסום באמת.
אז לפתוח את לוח תכנון.
יש [לא ברור] מיוחד נקרא [? עוזר? [לא ברור]].
כאשר אתה לוחץ על זה, זה הולך לפתוח שני קבצים.
אחת מהן היא בכיתה ואחרת אחד הוא נוף מקביל לזה.
זה מאוד, מאוד מועיל.
ובואו פשוט עוברים את קובץ .h.
שליטה, זה [לא ברור] הוא היגיון.
לחץ בקרה וגרור תצוגת טקסט להכרזה.
אנחנו הולכים לקרוא outputView ש.
חבר.
אז הנה אנחנו הכרזנו חדשים נכס לכיתת ViewController שלנו.
והנכס החדש רק תצוגת הטקסט
שיצרנו בבניין הממשק.
אז ככה שיכולנו גישה לכל הנתונים
ולתפעל את כל מה שיש בתוכו צפה בפלט, וזה מדהים.
>> אז בקוד האמיתי שלנו, בואו נעשה עם זה משהו.
אז זה זמן שבו אנחנו כמו הדפסה את התוצאה הסופית למריו,
אנחנו בכניסה לא שום דבר.
אני אומר שאנחנו יכולים לשמור הצהרת הרישום.
בנוסף לכך, אנחנו לשלוח את ההודעה אנחנו פשוט
נוצר לתצוגת הפלט, ש הוא ממשק משתמש TextView אנחנו פשוט נוצרו.
עכשיו בואו לראות מה קורה.
וואו.
יש לנו פירמידה באפליקציה עכשיו.
>> כך שהמשתמש יכול לראות הפלט שלנו, כי יש לנו להעתיק את הפלט מהקוד שלנו
לממשק שלנו.
זה די טוב.
זה בעצם לא כל כך מרגש כי אנחנו can--
כל האפליקציה עושה היא מראה פירמידה אליך,
ואין שום דבר שאתה יכול לעשות בקשר לזה.
זה לא מרגש במיוחד.
אז עכשיו בואו נעשה את כפתור שינקה את הנוף.
נראה כי לחץ יהיה מועיל.
גרור ושחרר.
כפתור אחד.
לחצן שני.
>> לכן, כאשר אנו לחצו השמאל כפתור, התצוגה צריכה לנקות.
לא צריך להיות שום דבר על המסך.
וכאשר אנו לחצו הלחצן ימני, מריו,
התצוגה עומדת להופיע שוב.
אז ככה אנחנו גם עושים דברים קסם, שליטה וגרור
להכרזת הכיתה בdirector-- העוזר
במציג העוזר.
במקרה זה אנו מפרטים שזה צריך להיות פעולה.
clearMario.
>> אז הנה אנחנו כבר נוצרו פעולה נקראת clearMario,
שהיא השיטה שתיקרא בכל פעם שאנו לוחצים על הכפתור ברור.
אז בלמעשה הקוד שלנו, בואו פשוט לשים את טקסט הפלט ותצוגת הפלט
לשום דבר, ודרך ש היא תופיע להיות ברורה.
בנוסף לכך, בואו ליצור שיטה אחרת, הנקראת runMario.
אה מצטער, שלא צריך להיות רכוש.
בסדר, כי במקרה ש להיות פעולה גם כן.
>> וכאשר הפונקציה ש בשם, אנחנו פשוט לרוץ מריו עשר.
אני מקווה שיהיה בסדר.
האם זה לקמפל?
כן.
עכשיו יש לנו נוף.
יש לנו פלט.
ובואו רק לראות מה קורה.
שנעלם.
היא חזרה שוב.
אז הנה יש לנו מפורט איזה סוג של פונקציה
ייקרא כאשר אנחנו סוג ב משהו,
כאשר אנו לוחצים על כפתור מסוים.
זה בעצם תכנית פעולת יעד
לאירוע מונע תכנות ב C. המטרה
>> בנוסף לכך, זה לא מאוד מרגש
כי אנחנו לא באמת יכולים לשנות כמה גבוה תהיה הפירמידה,
אז כנראה שאנחנו רוצים איכשהו לקבל קלט מהמשתמש
ולשנות את הגובה של פירמידה מבוססת על מה שהם פלט.
אז אנחנו הולכים לעשות את זה.
אז זה זמן שבו אנחנו קוראים runMario, אנחנו פשוט לא קוראים מריו ישירות.
הכותרת של אחד זה.
>> נציג.
זה מאוד מעניין.
מהו ציר?
אני הולך לשים עצמי כאן.
ואנחנו הולכים לראות מה זה אומר מאוחר יותר.
אז הנה יש לנו בעצם נוצרו מקרה מסוים שנקרא התראת UI
תצוגה.
תצוגת התראת UI היא בעצם מה שאתה רוצה
לראות כל פעם שדבר אבא ושואל אותך לקלט,
כמו מה יקרה כאשר אתה מנסה לרכוש משהו בחנות אפליקציות.
>> בנוסף לכך, לאחר ש ליצור אותו, אנחנו פשוט נציג את ההתראה.
בסדר, בואו פשוט במהירות בדיקה שעבודה או לא.
זה מאוד מגניב.
עכשיו בואו למעשה ליצור קלט שדה להתראת UI.
כך אנחנו עושים את זה.
ואנחנו צריכים קלט מבט להתראה.
מאוד מגניב.
בואו נגיד 10.
>> זה לא עושה שום דבר נכון עכשיו בגלל השיחה בפועל
לא שיניתי לביצוע מריו.
אז זה הפך לקטן קצת מוזר, כי בכל פעם ש
אנחנו לוחצים על כפתור למטה, בכל פעם שאנו ללחוץ על כפתור בתצוגת ההתראה,
משהו צריך לקרות, אבל זה לא קורה.
איך לתפוס את זה?
איך אנחנו יודעים שהמשתמש דחה תצוגת התראה
וכבר נכנס מספר, כי עכשיו שום דבר לא באמת קורה.
>> ובכן, אתה יכול לנחש זה נכון, משלחת.
אז בנוסף לכל הצהרות אלה,
אנחנו צריכים להוסיף משלחת חדשה ל זה נקרא ציר תצוגת התראת UI.
כך שכל אחת אינטראקציה או אירוע
שאנחנו הולכים יש לי עם הנוף להתראת UI
הולך להיות מטופלים על פי המעמד שלנו גם כן.
>> אז בנוסף לזה, יהיה לחצן לחץ על צג התראה במדד.
זה הגיע.
אז במקרה שיש לנו already-- כך שיש לנו
גילה פרוטוקול ש יהיה לטפל באירוע כאשר
אנו לחצו על כפתור Done במבט הערני.
אז בכל פעם שאנו דוחים את מבט ערני, זה צריך לקרות.
תן לי רק לבדוק את זה מהר מאוד.
ובכן אכן, הגענו לכאן.
>> אז הנה, מה שאנחנו לא יהיו ממש מקבל הוא למעשה
לקבל the-- אז אנחנו רוצים לצאת הטקסט שיש לנו בעבר
נכנס בתצוגת ההתראה.
ומבוסס על טקסט, אנחנו הולך להציג מריו.
זה מתברר מהר מאוד אם זה באמת עובד או לא.
אז במקרה כזה, אם אנחנו קלט, נניח, 10, אנחנו צריכים לראות 10.
>> טוב מאוד, יש לנו מספר כאן.
זה די טוב.
עכשיו השלב האחרון יהיה be-- אז הצעד אחרון שאנחנו צריכים לעשות עכשיו
הוא פשוט קורא מריו עם רמה מבוססת על הקלט
שיש לנו לשים לעין התראה.
אז אנחנו צריכים להמיר מחרוזת זו לתוך iOS.
גלישת סטטי היא מאוד מדהימה.
ואז אנחנו פשוט קוראים עצמיים ערך marioWithLevels.
בואו לראות יהיה ש באמת עובד או לא.
>> אנחנו כבר נתנו פירמידה.
בואו ננסה לשנות את הגובה.
זה באמת עובד.
זה די מגניב.
כך שעכשיו אתה יכול פשוט קלט כל ערך שאתה רוצה.
בואו נגיד ארבעה.
זה די מדהים.
אז זה בעצם דוגמא ממש מהירה
לכיצד ליצור פרויקט בקוד של ואיך להתניע ככה ממש מהר
כמה אירועים ממש פשוטים ופונקציות.
>> אז המקור הולך כדי לשים מקוון מאוחר יותר.
אז אם אתה מעוניין באופן iOS מריו עובד,
אני הולך לשים בדיוק אותו הדבר פרויקטים על אתר CS50 מאוחר יותר.
אנחנו עושים בעצם עם הקיץ, ולפני שנסיים
אני רק רוצה לציין שאתם ל כמה משאבים באמת מדהים ש
זמין באופן מקוון.
>> ברור תיעוד Apple הולך להיות מאוד מועיל.
אבל בנוסף לזה, אני במיוחד ממליץ ארבעה מקורות, בית ספר קוד,
בית עץ, קטעי וידאו וAppCoda WWDC.
בית ספר קוד ובית העץ הם שני אתרי האינטרנט מחנכים,
שדווקא להתמקד בהנדסת תוכנה.
במיוחד עבור בית ספר קוד, הם יש לי הדרכה ממש טובה על iOS.
>> זאת דוגמא ממש מהירה לזה.
הם בעצם ליצור באמת cute-- מסתכל שiPhone הקטן והחמוד
אחי שם, זה די מדהים.
והדרך בה הם מסבירים Objective תחביר C הוא ברור לחלוטין.
בית העץ הוא אותו הדבר.
וAppCoda הוא פורום.
זה בעצם בלוג שנוהל על ידי C Objective באמת חווה
מתכנת.
וכל הדרכות אלה בAppCoda הן די קצר וקל ליישום,
מומלץ מאוד.
>> ואם אתה מפתח, בהחלט ללכת לבדוק
כיצד סרטוני WWDC שבו אתה יכול ללמוד על תכנות iOS האחרון
טכניקות, APIs וספריות.
אז זה פחות או יותר זה לסמינר.
תודה רבה לך.
ואני מקווה שיהיה לך כיף יצירת האפליקציה iOS שלך.