1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [סמינר] [iOS: כתיבת Apps כמו בוס]

2
00:00:02,000 --> 00:00:04,000
[טומי MacWilliam] [אוניברסיטת הרווארד]

3
00:00:04,000 --> 00:00:08,000
[זה CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> בסדר, כולם, מוזמן iOS: כתיבת Apps כמו בוס.

5
00:00:12,000 --> 00:00:16,000
סמינר זה הוא הולך להתמקד בכתיבת יישומים לאייפון

6
00:00:16,000 --> 00:00:19,000
ובתורו בכתיבת יישומים לאייפד, וכך אנו בעצם הולכים לעבור

7
00:00:19,000 --> 00:00:23,000
כמה דוגמאות שונות של איך לעשות אפליקציה, משחק פשוט כמו בוהן טיק טק,

8
00:00:23,000 --> 00:00:26,000
או אם אתה מעוניין יותר בקבלת אפליקציה כמו איזה קורא חדשות

9
00:00:26,000 --> 00:00:30,000
או משהו שמתקשר עם האינטרנט אני אדבר על זה גם כן.

10
00:00:30,000 --> 00:00:32,000
הנה סדר היום הקצר שלנו.

11
00:00:32,000 --> 00:00:36,000
>> יישומי IOS נכתבים בשפה הנקראת Objective-C,

12
00:00:36,000 --> 00:00:39,000
ואז זה קצת דומה ל C, אבל לא ממש בכל,

13
00:00:39,000 --> 00:00:41,000
אז אנחנו נדבר קצת על השפה עצם

14
00:00:41,000 --> 00:00:45,000
ולאחר מכן כיצד לבנות אפליקציות אייפון באמצעות תכנית יישום זה נקרא Xcode,

15
00:00:45,000 --> 00:00:48,000
שאם לא הוריד את זה עדיין מרגיש חופשי כדי להתחיל בהורדה עכשיו.

16
00:00:48,000 --> 00:00:50,000
זה כמה ג'יגה.

17
00:00:50,000 --> 00:00:54,000
זה צריך להיות בחינם ב-App Store, ולכן אתה צריך מק

18
00:00:54,000 --> 00:00:57,000
באופן אידיאלי מריץ את הגרסה האחרונה של OS X.

19
00:00:57,000 --> 00:00:59,000
אם אתה לא, אין בעיה.

20
00:00:59,000 --> 00:01:02,000
יש לנו מחשבי מקינטוש במרכז המדע הזמין לשימושך

21
00:01:02,000 --> 00:01:05,000
עם Xcode מותקן, ולכן אל תהסס להשתמש בם לפיתוח.

22
00:01:05,000 --> 00:01:07,000
אם אתה רוצה להפוך את אפליקציה אבל אין לי מק, אל תדאג.

23
00:01:07,000 --> 00:01:09,000
יש הרבה משאבים בקמפוס לשם כך.

24
00:01:09,000 --> 00:01:15,000
וכך אז אנחנו הולכים לכיסוי 2 דוגמאות גדולות יותר של יישומים שונים שניתן לבצע.

25
00:01:15,000 --> 00:01:19,000
Objective-C היא מבחינה טכנית מה שנקרא סט סופר של ג

26
00:01:19,000 --> 00:01:24,000
זה אומר שכל קוד C הוא גם קוד חוקי Objective-C.

27
00:01:24,000 --> 00:01:29,000
זה אומר שאנחנו סוג של צינור מודבק על כמה תכונות נוספות לג

28
00:01:29,000 --> 00:01:33,000
חלק מהתכונות הללו כוללים לא נתקל אי פעם לכתוב malloc שוב, תודה לאל,

29
00:01:33,000 --> 00:01:36,000
אין צורך לדאוג למצביעי הטיפשים האלה ושחררו אותם וכל הדברים האלה

30
00:01:36,000 --> 00:01:40,000
אתה שונא על C, וזה סוג של נעלם בObjective-C.

31
00:01:40,000 --> 00:01:43,000
>> עכשיו, Objective-C יש גם ספרייה סטנדרטית הרבה יותר גדולה,

32
00:01:43,000 --> 00:01:47,000
כך שיש הרבה יותר פונקציונלי אתה מקבל עבור בתוך חופשי של Objective-C.

33
00:01:47,000 --> 00:01:50,000
זכור כשכתבנו PHP שמנו לב שעברנו מ

34
00:01:50,000 --> 00:01:54,000
שפה זו הקטנה ביותר לספרייה הענקית של כל הדברים המטורפים האלה שאתה יכול לעשות.

35
00:01:54,000 --> 00:01:56,000
אותו הדבר קורה בiOS.

36
00:01:56,000 --> 00:01:59,000
יש אובייקטים על דברים כמו בלוח השנה הבודהיסטית, ובעצם כל דבר

37
00:01:59,000 --> 00:02:05,000
אתה יכול לחשוב על מקיים כנראה כבר ביישום של Objective-C.

38
00:02:05,000 --> 00:02:08,000
חלק האובייקטיבי של Objective-C הוא התייחסות משהו

39
00:02:08,000 --> 00:02:11,000
נקרא תכנות מונחה עצמים.

40
00:02:11,000 --> 00:02:14,000
זה סוג של רעיון חדש, אבל אנחנו ממש בעיקר למדנו

41
00:02:14,000 --> 00:02:17,000
הרבה המושגים האלה כבר.

42
00:02:17,000 --> 00:02:19,000
הרעיון מאחורי תכנות מונחה עצמים הוא שאתה הולך לבנות

43
00:02:19,000 --> 00:02:23,000
הרבה הקוד שלך סביב הדברים האלה נקראים שיעורים,

44
00:02:23,000 --> 00:02:26,000
והשיעורים האלה באמת מהוללים structs.

45
00:02:26,000 --> 00:02:30,000
בתוך struct אנו בעצם אמרנו כאן הוא דבר,

46
00:02:30,000 --> 00:02:32,000
והדבר הזה יכול להיות חברים.

47
00:02:32,000 --> 00:02:35,000
לדוגמה, בצומת רשימה מקושרת יכולה להיות דברים אחרים

48
00:02:35,000 --> 00:02:38,000
כמו ערך, מצביע לצומת הבאה ברשימה,

49
00:02:38,000 --> 00:02:44,000
ויחד שמצביע ושהערך מורכבים מופע של struct זה.

50
00:02:44,000 --> 00:02:47,000
שיעורים דומים מאוד חוץ

51
00:02:47,000 --> 00:02:50,000
שיעורים יכולים להיות גם בתוך פונקציות שלהם.

52
00:02:50,000 --> 00:02:54,000
כשהכרזנו struct, תוכל לומר n int או * צומת הבאה בלבד.

53
00:02:54,000 --> 00:02:57,000
>> עכשיו עם Objective-C אנחנו יכולים ממש לשים את הפונקציות

54
00:02:57,000 --> 00:02:59,000
בתוך הדברים האלה.

55
00:02:59,000 --> 00:03:03,000
דבר נוסף שניתן לעשות הוא שיעורים שהם יכולים לרשת נתונים מסוגים אחרים.

56
00:03:03,000 --> 00:03:07,000
לדוגמה, יהיה לנו להסתכל על חבורה של מובנהיות בכיתות Objective-C.

57
00:03:07,000 --> 00:03:11,000
אחד מהם היה יכול להיות ברמה שמייצגת את ההשקפה על מסך,

58
00:03:11,000 --> 00:03:14,000
וכך באומרו שאני רוצה ליישם את ההשקפה האישית שלי

59
00:03:14,000 --> 00:03:18,000
אנחנו בעצם אומרים שמישהו מעל באפל, כנראה אנשים ממש נחמדים,

60
00:03:18,000 --> 00:03:21,000
כתב את זה בשבילי בכיתה, ומטפל בדברים כמו הצגת כפתורים

61
00:03:21,000 --> 00:03:25,000
או להוציא מהמסך, ונהיה ממש כואב

62
00:03:25,000 --> 00:03:28,000
כדי ליישם את כל הפונקציונליות שאת עצמנו, וזאת על ידי פשוט

63
00:03:28,000 --> 00:03:31,000
ירושת נתונים שאנחנו יכולים לומר את כל מה שעשיתם באותה הכיתה

64
00:03:31,000 --> 00:03:34,000
אני גם רוצה בתוך הכיתה שלי, ואז אני הולך לעשות כמה דברים אחרים,

65
00:03:34,000 --> 00:03:37,000
כלומר ליישם אפליקציה.

66
00:03:37,000 --> 00:03:40,000
זה מה שאומר מילת ירושה. נצטרך לראות דוגמה מוחשית יותר.

67
00:03:40,000 --> 00:03:42,000
>> ולבסוף, את המפתח עם תכנות מונחה עצמים הוא כי

68
00:03:42,000 --> 00:03:45,000
זה מוביל לאנקפסולציה נתונים.

69
00:03:45,000 --> 00:03:48,000
בחלק מהבעיה שלנו מקובע שנהיה לנו המשתנים הללו הגדולים, הגלובליים

70
00:03:48,000 --> 00:03:51,000
וGLOBALS בכל מקום, וככה היינו לעקוב אחר המצב.

71
00:03:51,000 --> 00:03:55,000
עם כיתות אנחנו יכולים להתחיל encapsulating מידע הפנימי של אובייקט.

72
00:03:55,000 --> 00:03:58,000
אם יש לנו מסך אחד באפליקציה שלנו, אנחנו לא באמת צריכים את כל נתונים מ

73
00:03:58,000 --> 00:04:01,000
מסך אחר בבתוך האפליקציה שלנו לכך,

74
00:04:01,000 --> 00:04:04,000
וזאת על ידי encapsulating דברים במסגרת שיעורים זה בעצם מוביל

75
00:04:04,000 --> 00:04:08,000
לעיצוב קוד הרבה יותר טוב, וזה אפשרי עם כמה מהתכונות הנוספות

76
00:04:08,000 --> 00:04:11,000
של Objective-C.

77
00:04:11,000 --> 00:04:15,000
התראה מוקדמת, התחביר לObjective-C היא בננות.

78
00:04:15,000 --> 00:04:19,000
זה כמו שום דבר שראינו קודם לכן,

79
00:04:19,000 --> 00:04:22,000
כך שזה קצת זמן להתרגל עקומה למידה

80
00:04:22,000 --> 00:04:24,000
מה לעזאזל זה אומר?

81
00:04:24,000 --> 00:04:27,000
אבל ברגע שאתה מצליח לעבור כי עקומת למידה ראשונית זה ממש, ממש חלק

82
00:04:27,000 --> 00:04:29,000
להתחיל לכתוב יישומים.

83
00:04:29,000 --> 00:04:33,000
>> להכריז כיתה, לומר כאן היא הכיתה שלי, היא קיימת,

84
00:04:33,000 --> 00:04:35,000
ואולי כאן כמה דברים שאני הולך להגדיר מאוחר יותר,

85
00:04:35,000 --> 00:04:38,000
אני הולך לומר @ ממשק.

86
00:04:38,000 --> 00:04:41,000
אני הולך לומר @ ממשק. אני הולך לתת לכיתה שלי שם.

87
00:04:41,000 --> 00:04:43,000
ואז מאוחר יותר במקום אחר אני הולך לומר @ סוף,

88
00:04:43,000 --> 00:04:46,000
וכל מה שבין הממשק @ והסוף @

89
00:04:46,000 --> 00:04:48,000
הוא הולך להיות בכיתה שלי.

90
00:04:48,000 --> 00:04:51,000
זה הולך להיות מה שבפנים. של קבצי h שלנו.

91
00:04:51,000 --> 00:04:55,000
בדיוק כמו ב-C. קבצי h בעצם אמרו כאן כמה דברים שיהיו קיימים.

92
00:04:55,000 --> 00:04:57,000
אני לא בהכרח אומר לך מה שהם עושים זאת,

93
00:04:57,000 --> 00:04:59,000
אבל המהדר צריך לדעת שהם קיימים.

94
00:04:59,000 --> 00:05:04,000
מאוחר יותר בתוך. מ 'שלנו קבצים, כי מ' ל- Objective-C

95
00:05:04,000 --> 00:05:08,000
זה מקום בו אנחנו בעצם הולכים להגדיר מה השיעורים האלה לעשות.

96
00:05:08,000 --> 00:05:11,000
כמו הרבה. קבצי C שלנו, ספק לנו יישום לפונקציות.

97
00:05:11,000 --> 00:05:15,000
בתוך הקובץ. מ 'שלנו שאנחנו הולכים לומר כאן הוא מה שכל הפונקציות

98
00:05:15,000 --> 00:05:18,000
בתוך הכיתה שלי מה לעשות כולם.

99
00:05:18,000 --> 00:05:22,000
ולבסוף, בתוך struct נוכל לומר בתוך הסוגריים המסולסלים האלה

100
00:05:22,000 --> 00:05:25,000
int n * או צומת הבאה,

101
00:05:25,000 --> 00:05:28,000
ובObjective-C שאנחנו הולכים להשתמש במילת מפתח @ רכוש,

102
00:05:28,000 --> 00:05:31,000
וזה מה שהולך להגדיר את התכונות,

103
00:05:31,000 --> 00:05:36,000
או הפונקציות שאינן, כי הם חלק מהשיעורים שלי.

104
00:05:36,000 --> 00:05:40,000
>> קוראים פונקציות בObjective-C הוא גם בננות.

105
00:05:40,000 --> 00:05:43,000
כשהכרזנו פונקציות ב-C אמר משהו כמו int foo

106
00:05:43,000 --> 00:05:46,000
ופתוח סוגריים ולאחר מכן נתן לו רשימה של טיעונים.

107
00:05:46,000 --> 00:05:51,000
זה מה שהצהיר שיטות או פונקציות נראה כמו בObjective-C.

108
00:05:51,000 --> 00:05:54,000
אם אני רוצה להכריז על פונקציה או שיטה

109
00:05:54,000 --> 00:05:58,000
איפה שאני אומר שיטה היא באמת רק פונקציה שהוא חבר של כיתה,

110
00:05:58,000 --> 00:06:01,000
כך סוג של החלפה, אבל לא ממש,

111
00:06:01,000 --> 00:06:03,000
כך בתוך השיטה שלי אני רוצה ליצור שיטה חדשה.

112
00:06:03,000 --> 00:06:06,000
זה הולך לחזור כלום, אז זה הולך להיות סוג של חלל.

113
00:06:06,000 --> 00:06:08,000
זה סוג ההחזרה של הפונקציה שלי.

114
00:06:08,000 --> 00:06:11,000
עכשיו יש לנו parens כאן כי, אני לא יודע.

115
00:06:11,000 --> 00:06:14,000
הבא הולך להיות השם של הפונקציה שלי,

116
00:06:14,000 --> 00:06:17,000
ואז סוף סוף יש לנו פסיק בדיוק כמו שהיינו לנו בג

117
00:06:17,000 --> 00:06:19,000
מה חדש כאן הוא הבחור הזה כאן.

118
00:06:19,000 --> 00:06:22,000
המקף הזה הוא בעצם צורך, ומה שזה אומר הוא ש

119
00:06:22,000 --> 00:06:26,000
שיטה זו כאן צריכה להיקרא על מופע של מחלקה.

120
00:06:26,000 --> 00:06:29,000
>> אחרי שהכרזנו structs אנחנו כנראה אמרנו משהו כמו

121
00:06:29,000 --> 00:06:32,000
struct n צמתים, ושיצר בפועל

122
00:06:32,000 --> 00:06:35,000
או אחד ממופעי structs הללו, כך שאני יכול פשוט להתחיל לעבוד

123
00:06:35,000 --> 00:06:38,000
עם מה שיש בתוכו, כך שמקף זה אומר שאנחנו צריכים

124
00:06:38,000 --> 00:06:41,000
מופע הכיתה בדיוק כמו שאנחנו מופעים שstruct

125
00:06:41,000 --> 00:06:43,000
לפני שאנחנו יכולים לקרוא לשיטה זו על זה.

126
00:06:43,000 --> 00:06:46,000
אם אני רוצה להתחיל להוסיף טיעונים לשיטות שלי

127
00:06:46,000 --> 00:06:48,000
זה נהיה אפילו יותר בננות.

128
00:06:48,000 --> 00:06:50,000
הנה שם בשיטה שלי.

129
00:06:50,000 --> 00:06:53,000
אז אני הולך לי מעי גס, מעי גס ואחרי זה הוא אומר הנה מגיע כמה טיעונים.

130
00:06:53,000 --> 00:06:56,000
שיטה זו לוקחת טיעון אחד.

131
00:06:56,000 --> 00:06:59,000
הסוג של הטיעון שלו הוא int, ושמו של שהטיעון

132
00:06:59,000 --> 00:07:03,000
או משתנה שאני הולך להתחיל להשתמש בחלק פנימי של השיטה נקראת i.

133
00:07:03,000 --> 00:07:05,000
שוב, זה שיטה. זה לוקח טיעון אחד.

134
00:07:05,000 --> 00:07:10,000
>> אם ברצונך להתחיל להוסיף עוד טענות שהוא מקבל יותר בננות

135
00:07:10,000 --> 00:07:13,000
שביש לנו נקודות זה אומר שהנה מגיעה רשימת הטיעונים שלי.

136
00:07:13,000 --> 00:07:15,000
הטיעון הראשון הוא מספר שלם.

137
00:07:15,000 --> 00:07:17,000
עכשיו, הטענה השנייה היא מעניינת.

138
00:07:17,000 --> 00:07:20,000
משתנה שאני הולך להיות באמצעות הפונקציה פנימית שלי

139
00:07:20,000 --> 00:07:23,000
נקרא f, ולכן בתוך הפונקציה שלי אני יכול לומר

140
00:07:23,000 --> 00:07:25,000
f + = 1 או משהו.

141
00:07:25,000 --> 00:07:30,000
הדבר הזה כאן הוא בעצם מפתח שלטענה או פרמטר.

142
00:07:30,000 --> 00:07:34,000
בדיוק כמו שהיינו לנו זוגות ערך מפתח ומשהו כמו JSON או מערכים אסוציאטיביים

143
00:07:34,000 --> 00:07:37,000
Objective-C את ההחלטה להגיד, בסדר, רק כדי שזה ממש ברור

144
00:07:37,000 --> 00:07:39,000
כשאתה קורא לשיטה מה כל הפרמטרים הללו הם

145
00:07:39,000 --> 00:07:41,000
בעצם אני מתכוון לקרוא את כולם.

146
00:07:41,000 --> 00:07:45,000
כשאתה מתקשר לשיטה, אתה למעשה אומר andFloat,

147
00:07:45,000 --> 00:07:47,000
ואז אתה עובר אותו פנימה

148
00:07:47,000 --> 00:07:50,000
>> מעניין לציין, שזו לא בשם, אבל בכל פרמטרים האחרים,

149
00:07:50,000 --> 00:07:53,000
כך שאם היו לנו ויכוח 3 אני יכול להגיד andFloat

150
00:07:53,000 --> 00:07:56,000
ולצוף אחרים וכן הלאה.

151
00:07:56,000 --> 00:08:01,000
כשאני קורא בשיטות אלה הוא כמובן של בננות,

152
00:08:01,000 --> 00:08:04,000
כך שאם יש לי אובייקט, ואני הגדרתי שיטה הנקראת foo,

153
00:08:04,000 --> 00:08:09,000
ואני רוצה לקרוא לזה, ולא אומר foo פתוח / parens הקרוב

154
00:08:09,000 --> 00:08:11,000
אני הולך לפתוח סוגר.

155
00:08:11,000 --> 00:08:13,000
הנה שמו של השיטה שלי.

156
00:08:13,000 --> 00:08:17,000
אני הולך לסגור את הסוגר, וזה האובייקט שאני קורא את זה הלאה.

157
00:08:17,000 --> 00:08:20,000
זכור, כל השיטות האלה קיימות בתוך כיתות

158
00:08:20,000 --> 00:08:23,000
בגלל שיעורים יכולים להיות שיטות המוגדרות בתוכם.

159
00:08:23,000 --> 00:08:26,000
>> כאן יצרתי אובייקט של מחלקה מסוימת באופן שרירותי,

160
00:08:26,000 --> 00:08:28,000
וזה התחביר שעשה את זה.

161
00:08:28,000 --> 00:08:31,000
יש 2 שלבים ליצירת אובייקט.

162
00:08:31,000 --> 00:08:34,000
הצעד הראשון הוא אומר שאני רוצה להקצות שטח.

163
00:08:34,000 --> 00:08:37,000
זו מקבילה של malloc. אין לנו לומר malloc יותר.

164
00:08:37,000 --> 00:08:42,000
אנחנו ירדנו מ ', עשו את זה alloc, והוחלפנו. ג ב. מ'.

165
00:08:42,000 --> 00:08:47,000
אחרי משהו alloc אז אנחנו צריכים לאתחל אותו.

166
00:08:47,000 --> 00:08:49,000
בעיקרון בעת ​​יצירת אובייקטים שאולי תרצה לקבל קצת היגיון

167
00:08:49,000 --> 00:08:53,000
שמבצע כאשר הם יצרו, כך שתוכלו לעבור בכמה ערכי ברירת מחדל

168
00:08:53,000 --> 00:08:57,000
או משהו כזה, ולכן שיטת init זה מה שבעצם יוצר את האובייקט.

169
00:08:57,000 --> 00:08:59,000
אנו מקצים מקום הראשון, בדיוק כמו שעשינו ב-C,

170
00:08:59,000 --> 00:09:04,000
ואז לאתחל אותו, מה שיכול או לא יכול לעשות הרבה.

171
00:09:04,000 --> 00:09:07,000
ואז אנחנו חוזרים את הדבר הזה לאובייקט O.

172
00:09:07,000 --> 00:09:09,000
יש כוכב לכאן כי זו היא טכנית מצביע,

173
00:09:09,000 --> 00:09:12,000
אבל אל תדאגו, מצביעים הם לא כזה עניין גדול בObjective-C יותר.

174
00:09:12,000 --> 00:09:15,000
>> עכשיו אנחנו כבר מופעי המעמד הזה שנקרא NSObject,

175
00:09:15,000 --> 00:09:19,000
וזה רק בכיתה אקראית שאפל.

176
00:09:19,000 --> 00:09:22,000
יש לנו מופעים זה, ועכשיו יש לי מופע של מחלקה זו

177
00:09:22,000 --> 00:09:25,000
באובייקט o זה, אז זה אומר שאם אני מוגדר

178
00:09:25,000 --> 00:09:29,000
שיטות אלה הייתי יכול לקרוא להם ככה.

179
00:09:29,000 --> 00:09:31,000
בדומה לכך, אם אני רוצה לקרוא לשיטה בטיעון אחד,

180
00:09:31,000 --> 00:09:34,000
אז זה שיטת הבר, שלוקח את טיעון אחד,

181
00:09:34,000 --> 00:09:38,000
וכאן הוא באז: שיטת qux, אז זה לוקח 2 טענות.

182
00:09:38,000 --> 00:09:44,000
זו קריאה לפונקציה אחת על האובייקט o זה.

183
00:09:44,000 --> 00:09:46,000
הגיוני?

184
00:09:46,000 --> 00:09:50,000
התחביר צריך להיות הגיוני, אבל אתה סוג של להתרגל לזה.

185
00:09:50,000 --> 00:09:54,000
>> אוקיי, בואו נדבר על כמה דברים שבנויים לתוך Objective-C

186
00:09:54,000 --> 00:09:56,000
שלא נבנו בהכרח לג

187
00:09:56,000 --> 00:09:59,000
ב C אנחנו סוג של נאלצו להתמודד עם מחרוזות כמערכי אופי המטומטמים האלה,

188
00:09:59,000 --> 00:10:01,000
וזה נהיה ממש מעצבן.

189
00:10:01,000 --> 00:10:04,000
Objective-C יש אלה שנבנו בכל בשבילנו, והוא בנוי ב

190
00:10:04,000 --> 00:10:06,000
באמצעות מחלקה זו נקראת NSString.

191
00:10:06,000 --> 00:10:10,000
כשאני רוצה ליצור NSString יש לנו תחביר מסתורי יותר.

192
00:10:10,000 --> 00:10:15,000
במקום לומר "cs50" אנחנו אומרים @ "cs50"

193
00:10:15,000 --> 00:10:17,000
וזו רק התחביר להכרזה על מייתרים בObjective-C.

194
00:10:17,000 --> 00:10:21,000
זה מאוד קל לשכוח, כל כך לא.

195
00:10:21,000 --> 00:10:24,000
עכשיו, ברגע שיש לי את זה, זה הוא מחרוזת, אבל שם לב

196
00:10:24,000 --> 00:10:26,000
זה באמת רק אובייקט.

197
00:10:26,000 --> 00:10:30,000
אמרתי NSString, מה שאומר שמופעים בכיתה

198
00:10:30,000 --> 00:10:32,000
קרא NSString, שמישהו אחר כתב בשבילי,

199
00:10:32,000 --> 00:10:35,000
והם היו נחמדים מאוד על זה, ואז עכשיו

200
00:10:35,000 --> 00:10:37,000
אני יכול להתחיל לקרוא על שיטותיו.

201
00:10:37,000 --> 00:10:40,000
אם אני קורא את אורך השיטה על אובייקט של זה

202
00:10:40,000 --> 00:10:43,000
זה הולך לחזור אליי לאורכו של החוט.

203
00:10:43,000 --> 00:10:45,000
זה בדיוק כמו strlen ב C.

204
00:10:45,000 --> 00:10:47,000
זה יחזיר 4.

205
00:10:47,000 --> 00:10:51,000
>> בדומה לכך, בשיטה אחרת שאולי ירצה אכפת לי היא זו characterAtIndex.

206
00:10:51,000 --> 00:10:54,000
זוהי שיטה שאומרת על מחרוזת של זה

207
00:10:54,000 --> 00:10:57,000
אני רוצה שתקבל את התו 0,

208
00:10:57,000 --> 00:10:59,000
וכך זה היה חוזר אליי ג האופי,

209
00:10:59,000 --> 00:11:02,000
ויש חבורה שלמה יותר מהשיטות הללו שאתה יכול לגגל ממש בקלות.

210
00:11:02,000 --> 00:11:07,000
התיעוד של אפל הוא גדול, ואנחנו נסתכל על זה קצת.

211
00:11:07,000 --> 00:11:09,000
אלה הם מייתרים.

212
00:11:09,000 --> 00:11:11,000
יש לנו גם מערכים בגודל משתנים בנויים פנימה

213
00:11:11,000 --> 00:11:13,000
זכור ב-C כאשר הכריזו מערך

214
00:11:13,000 --> 00:11:16,000
היו לנו לומר שיש לך 5 אלמנטים, סוף הסיפור.

215
00:11:16,000 --> 00:11:18,000
כשהגענו לJavaScript ו-PHP שאנחנו יכולים להתחיל

216
00:11:18,000 --> 00:11:20,000
לעשות דברים כמו הוספת אלמנטים או הזזת אלמנטים.

217
00:11:20,000 --> 00:11:22,000
אנחנו יכולים לעשות את אותו הדבר בObjective-C.

218
00:11:22,000 --> 00:11:26,000
במקום ליצור מערך בצורת C הרגילה

219
00:11:26,000 --> 00:11:30,000
יש לנו שוב כיתה נוספת הנקראת NSMutableArray.

220
00:11:30,000 --> 00:11:33,000
יש גם NSArray,

221
00:11:33,000 --> 00:11:35,000
וזה הולך בעצם לתמצת חלק המערך.

222
00:11:35,000 --> 00:11:38,000
זה אומר שהדבר הראשון שאני רוצה לעשות הוא שאני רוצה להקצות

223
00:11:38,000 --> 00:11:41,000
מקום למערך חדש, ולאחר שאקצה אותו

224
00:11:41,000 --> 00:11:43,000
ואז אני צריך לאתחל אותו.

225
00:11:43,000 --> 00:11:45,000
שוב, רק להתקשר ל2 שיטות אלה.

226
00:11:45,000 --> 00:11:48,000
עכשיו זה אומר שבתוכו של אובייקט זה

227
00:11:48,000 --> 00:11:50,000
יש לי מערך ריק שישב שם.

228
00:11:50,000 --> 00:11:54,000
אם אני רוצה להוסיף משהו למערך הזה, אני יכול לקרוא לשיטת addObject.

229
00:11:54,000 --> 00:11:59,000
אני רוצה להוסיף אובייקט למערך, ואני רוצה להוסיף את מחרוזת CS50.

230
00:11:59,000 --> 00:12:02,000
אם אני רוצה לחלופין להסיר שאני יכול להגיד שאני רוצה

231
00:12:02,000 --> 00:12:09,000
להסיר את האובייקט במקום הראשון במערך או להתנגד.

232
00:12:09,000 --> 00:12:11,000
>> הגיוני?

233
00:12:11,000 --> 00:12:14,000
אוקיי, אתה סוג של להתרגל לדבר סוגר המרובע הזה.

234
00:12:14,000 --> 00:12:18,000
אגב, בתוך המון הספריות של אפל תראה NS זה.

235
00:12:18,000 --> 00:12:21,000
NS למעשה עומד לצעד הבא, שהיה אחד מחברות סטיב ג'ובס 1,

236
00:12:21,000 --> 00:12:24,000
וזה המקום שבו באמת התחיל לכתוב הרבה קוד

237
00:12:24,000 --> 00:12:27,000
כסוג של בסיס ל- Mac OS X וכל מיני דברים האחרים,

238
00:12:27,000 --> 00:12:32,000
וכך NS זה סוג של מורשת זה נחמד לצעוק לאחת מהחברות הקודמות

239
00:12:32,000 --> 00:12:34,000
בחזרה כאשר אפל היה בתחילת קריירה.

240
00:12:34,000 --> 00:12:36,000
זה בכל מקום.

241
00:12:36,000 --> 00:12:41,000
בואו נסתכל על דוגמה הוליסטית יותר Objective-C.

242
00:12:41,000 --> 00:12:44,000
הנה אני בתוך Xcode.

243
00:12:44,000 --> 00:12:47,000
כדי להגיע לכאן, אני הורדתי Xcode 1 מ-App Store,

244
00:12:47,000 --> 00:12:50,000
פתח אותו, ואז הייתי עולה כאן לקובץ,

245
00:12:50,000 --> 00:12:54,000
כאן לפרויקט חדש, ולאחר מכן.

246
00:12:54,000 --> 00:12:57,000
אחרי שאני עושה כי יש לי את כל האפשרויות האלה של מה שאני רוצה ליצור,

247
00:12:57,000 --> 00:12:59,000
ואז אנחנו נסתכל על אפשרויות אלה מאוחר יותר,

248
00:12:59,000 --> 00:13:03,000
אבל רק לדוגמה זו, כי אנחנו לא ממש הולכים לי אפליקציה עדיין,

249
00:13:03,000 --> 00:13:06,000
כשהגעתי לכאן, ואמרתי כלי שורת פקודה,

250
00:13:06,000 --> 00:13:09,000
וזו אפליקציה שאני יכול לרוץ בשורת הפקודה

251
00:13:09,000 --> 00:13:12,000
בדיוק כמו שאנחנו כבר מפעילים מג

252
00:13:12,000 --> 00:13:16,000
ככה אני יצרתי את הפרויקט הזה, ואז עכשיו אני כאן,

253
00:13:16,000 --> 00:13:20,000
אז תן מבט הראשון בקובץ זה, וזה צריך להיראות די מוכר.

254
00:13:20,000 --> 00:13:24,000
יש לי שם int. יש argc החבר שלי, החבר האחר argv שלי.

255
00:13:24,000 --> 00:13:30,000
וכך אנו יכולים לראות שזה הוא נקודת הכניסה ליישום הראשון שלי Objective-C.

256
00:13:30,000 --> 00:13:32,000
כאן אנו יכולים להתעלם מזה לעת עתה.

257
00:13:32,000 --> 00:13:35,000
זה בעצם כמה דברי ניהול זיכרון שאתה לא באמת

258
00:13:35,000 --> 00:13:37,000
אף פעם לא צריכים לדאוג.

259
00:13:37,000 --> 00:13:39,000
>> בואו נסתכל על הבלוק הראשון זה כאן.

260
00:13:39,000 --> 00:13:46,000
השורה הראשונה זו, אם אני אומר לסטודנטים * אליס = [[alloc סטודנטים] init] מה זה עושה?

261
00:13:46,000 --> 00:13:50,000
תלמיד ראשון זה כאן, זה כנראה כיתה.

262
00:13:50,000 --> 00:13:54,000
זה לא מעמד שאפל כתב, אבל זה ברמה שאני כתבתי.

263
00:13:54,000 --> 00:13:57,000
הדבר הראשון שאני רוצה לעשות הוא שאני רוצה להקצות שטח לתלמיד חדש,

264
00:13:57,000 --> 00:14:00,000
ולאחר מכן אני רוצה לאתחל אותו, אז זה נותן לי גב

265
00:14:00,000 --> 00:14:05,000
אובייקט התלמיד החדש הזה, ואני זה אחסון במשתנה בשם אליס.

266
00:14:05,000 --> 00:14:07,000
איפה הכיתה שבאה?

267
00:14:07,000 --> 00:14:12,000
ובכן, כאן בצד השמאל אלה את כל קבצים השונים בתוך הפרויקט שלי.

268
00:14:12,000 --> 00:14:16,000
אנחנו יכולים לראות כאן יש לי Student.h וStudent.m.

269
00:14:16,000 --> 00:14:20,000
. קובץ h, זוכר, מקום שבו אני מצהיר שכל הדברים

270
00:14:20,000 --> 00:14:22,000
שיתקיים במסגרת הכיתה.

271
00:14:22,000 --> 00:14:25,000
>> בואו נסתכל על זה.

272
00:14:25,000 --> 00:14:29,000
בסדר, הנה יש לנו ממשק @ זה, וזה אומר שמגיע לכאן

273
00:14:29,000 --> 00:14:33,000
הצהרותיו של כל מה שיהיה קיימים בתוך הכיתה שלי.

274
00:14:33,000 --> 00:14:36,000
אז יש לי סרטן מעי גס. אז יש לי דבר NSObject זה.

275
00:14:36,000 --> 00:14:40,000
מעי גס זה מסמל שקצת ירושה אנו דנים מעט מוקדם יותר.

276
00:14:40,000 --> 00:14:43,000
זה אומר הכל NSObject יכול לעשות

277
00:14:43,000 --> 00:14:46,000
בי NSObject היא זו כיתה שנכתבה על ידי מישהו אחר,

278
00:14:46,000 --> 00:14:50,000
הכל NSObject זה יכול לעשות אני רוצה להיות מסוגל לעשות את זה.

279
00:14:50,000 --> 00:14:54,000
באומרו: NSObject זה אומר שאני בעצם

280
00:14:54,000 --> 00:14:58,000
ירש את כל הפונקציונליות של כיתה אחרת.

281
00:14:58,000 --> 00:15:02,000
זה באמת נתן לי חבורה שלמה של שיטות שונות ומאפיינים שאני יכול להשתמש.

282
00:15:02,000 --> 00:15:05,000
כאן אני יוצר 2 נכסים.

283
00:15:05,000 --> 00:15:08,000
כלומר, התלמיד שלי, אם זה היה struct, אלה יהיו 2 הדברים

284
00:15:08,000 --> 00:15:11,000
בתוך struct שלי, כך שכל תלמיד יש שם

285
00:15:11,000 --> 00:15:14,000
שהיא מחרוזת, וסטודנט יש גם כיתה,

286
00:15:14,000 --> 00:15:17,000
שהוא int.

287
00:15:17,000 --> 00:15:23,000
>> לבסוף, כאן אני הולך ליצור שיטת התלמיד שלי.

288
00:15:23,000 --> 00:15:26,000
התקשרתי בשיטה שלי, initWithName, וזה לוקח טיעון אחד,

289
00:15:26,000 --> 00:15:31,000
והטענה שהוא חוט, ואני קראתי לזה שם.

290
00:15:31,000 --> 00:15:35,000
עכשיו בואו נסתכל על איך אנחנו מיושמים המעמד הזה דווקא.

291
00:15:35,000 --> 00:15:38,000
הנה, עכשיו אני פנימי של הקובץ. מ 'שלי,

292
00:15:38,000 --> 00:15:40,000
מ 'ליישום, אני מניח.

293
00:15:40,000 --> 00:15:44,000
יש לי ביצוע שלי, המטרה שלי, וכאן אני בעצם הגדרה

294
00:15:44,000 --> 00:15:47,000
מה initWithName עושה.

295
00:15:47,000 --> 00:15:50,000
יש לי initWithName, שמו של הפרמטר שלי, ואז זה

296
00:15:50,000 --> 00:15:53,000
מקום בו אני למעשה יצירת תלמיד,

297
00:15:53,000 --> 00:15:56,000
ואז זה קצת מסתורי, אבל זה סוג של טקסט סטנדרטי

298
00:15:56,000 --> 00:15:58,000
שברצונך לכלול בבנאים שלך.

299
00:15:58,000 --> 00:16:02,000
פונקציה זו אתחול כאן, initWithName, היא סוג של בנאי.

300
00:16:02,000 --> 00:16:05,000
אתה בעצם בונה אובייקט תלמיד חדש

301
00:16:05,000 --> 00:16:07,000
ואולי לשלוח כמה מידע שבתוכה.

302
00:16:07,000 --> 00:16:11,000
הדבר הראשון שאני רוצה לעשות זה אני רוצה להתקשר לinit על דבר הסופר הזה.

303
00:16:11,000 --> 00:16:15,000
>> זכור שכאשר אמרתי יחזרו לכאן ב. קובץ h

304
00:16:15,000 --> 00:16:21,000
שכל מה שיש NSObject סטודנט גם.

305
00:16:21,000 --> 00:16:24,000
זה אומר שכשאני יוצר תלמיד מה אני גם צריך לעשות הוא

306
00:16:24,000 --> 00:16:28,000
לוודא כי NSObject שאני יורש את כל נתונים מ

307
00:16:28,000 --> 00:16:32,000
גם הוא אותחל כראוי.

308
00:16:32,000 --> 00:16:36,000
מה שאני צריך לומר הוא סופר היא בעצם הולך להתייחס למעמד ההורה

309
00:16:36,000 --> 00:16:39,000
שאני יורש מ, אז אני רוצה לוודא שאני לאתחל

310
00:16:39,000 --> 00:16:43,000
כל מה שאני בהתאם לפני שאני מתחיל לנסות להשתמש בו.

311
00:16:43,000 --> 00:16:46,000
אז אם שאותחל כהלכה זה בדיוק כמו שיגיד אם malloc

312
00:16:46,000 --> 00:16:50,000
לא תחזיר null אז אני יכול להתחיל בהגדרת מספר מאפיינים.

313
00:16:50,000 --> 00:16:54,000
>> ב-JavaScript ו-PHP שמילה מפתח זו קראה לזה,

314
00:16:54,000 --> 00:16:58,000
וזה התייחס למופע הנוכחי של כיתה.

315
00:16:58,000 --> 00:17:00,000
בObjective-C שאנו מכנים עצמיים.

316
00:17:00,000 --> 00:17:04,000
כשאני אומר self.name, זה אומר שהאובייקט

317
00:17:04,000 --> 00:17:07,000
אני פשוט יצרתי כשאמרתי alloc התלמיד init,

318
00:17:07,000 --> 00:17:09,000
זה הולך להחזיר לי את אובייקט.

319
00:17:09,000 --> 00:17:12,000
זה אומר שאני רוצה להגדיר את שמו של אותו האובייקט

320
00:17:12,000 --> 00:17:15,000
לכל מה שאני רק עברתי פנימה

321
00:17:15,000 --> 00:17:18,000
בדיוק כמו ב-C, אנחנו חברים לגשת עם נקודה זו,

322
00:17:18,000 --> 00:17:21,000
כך self.name אומר את השם של אובייקט התלמיד

323
00:17:21,000 --> 00:17:24,000
עכשיו הוא הולך להיות כל מה שאתה רק עברת פנימה

324
00:17:24,000 --> 00:17:28,000
ואז בסוף, אני לא יכול להחזיר את זה אז אני ממש מקבל משהו בחזרה.

325
00:17:28,000 --> 00:17:30,000
>> שאלות?

326
00:17:30,000 --> 00:17:34,000
אוקיי, אז זה עצמי = סופר init,

327
00:17:34,000 --> 00:17:37,000
אם אתה לא לגמרי מבין את חומר התורשה אל תדאגו.

328
00:17:37,000 --> 00:17:40,000
רק יודע שאם אי פעם תרצה לעשות שיטת init שלך פשוט

329
00:17:40,000 --> 00:17:42,000
לעשות את זה, ואתה תהיה טוב ללכת.

330
00:17:42,000 --> 00:17:44,000
כן. >> [סטודנטים] מה עושה אם אומר עצמי?

331
00:17:44,000 --> 00:17:49,000
פירושו של הדבר כאשר אנו malloc משהו שתמיד בדק אם זה היה שווה לריק,

332
00:17:49,000 --> 00:17:51,000
ואם זה היה ריק, אז יצא.

333
00:17:51,000 --> 00:17:55,000
זה אותו הדבר, כי אם null חוזר הזה, אז אנחנו כנראה הולכים אשמת seg

334
00:17:55,000 --> 00:17:57,000
אם תתחילו מנסה לתמרן אותו.

335
00:17:57,000 --> 00:18:01,000
זה התלמיד בכיתה שלנו.

336
00:18:01,000 --> 00:18:03,000
זה אומר שאנחנו יכולים לאתחל את התלמידים שלנו באחת משתי דרכים.

337
00:18:03,000 --> 00:18:08,000
אם אני אומר alloc התלמיד init אני לא משתמש בשיטה שאני פשוט כתבתי,

338
00:18:08,000 --> 00:18:11,000
ובמקום שאני יכול להגיד פשוט alice.name,

339
00:18:11,000 --> 00:18:14,000
ועכשיו אני הולך להגדיר ששם המאפיין.

340
00:18:14,000 --> 00:18:17,000
>> בדומה לכך, אם אני רוצה להשתמש בשיטת שinitWithName

341
00:18:17,000 --> 00:18:20,000
אני פשוט יכול להגיד alloc, ואז במקום לומר init

342
00:18:20,000 --> 00:18:24,000
אני הולך לקרוא לשיטה שזה עתה יצר, ואני הולך לעבור בבוב.

343
00:18:24,000 --> 00:18:30,000
בשלב זה, האובייקט בוב הזה יש שם שווה לבוב.

344
00:18:30,000 --> 00:18:35,000
אוקיי, כאן אני משתמש NSMutableArray שהסתכלנו קודם לכן.

345
00:18:35,000 --> 00:18:38,000
אני הקצאת space.Then אני מאתחל את מערך חדש.

346
00:18:38,000 --> 00:18:40,000
אני הולך להוסיף 2 דברים אליו.

347
00:18:40,000 --> 00:18:43,000
מערך זה מחזיק כעת אובייקטי סטודנטים.

348
00:18:43,000 --> 00:18:46,000
שים לב שבשום מקום לא הייתי צריך להגיד את זה הוא מערך של תלמידים.

349
00:18:46,000 --> 00:18:48,000
אני אמרתי שזה מערך, נקודה.

350
00:18:48,000 --> 00:18:50,000
אז אני יכול לשים את מה שבתוכו שאני רוצה.

351
00:18:50,000 --> 00:18:52,000
כאן יש לי 2 אובייקטים.

352
00:18:52,000 --> 00:18:56,000
>> לבסוף, יש לי אובייקט אחר כאן, TF זה.

353
00:18:56,000 --> 00:18:59,000
כאן בTF.h בעצם את אותו הדבר.

354
00:18:59,000 --> 00:19:01,000
אני יורש מNSObject, ודרך אגב,

355
00:19:01,000 --> 00:19:03,000
בעת יצירת מעמדות זה נעשה הכל בשבילך,

356
00:19:03,000 --> 00:19:06,000
סוג זה של ממשק מוכן מראש.

357
00:19:06,000 --> 00:19:08,000
יש לו רכוש של תלמידים.

358
00:19:08,000 --> 00:19:15,000
יש לי כמה שיטות פה שלא ממש עושים הרבה,

359
00:19:15,000 --> 00:19:18,000
ואז זה אומר שאחרי שאני יוצר אובייקט TF זה

360
00:19:18,000 --> 00:19:23,000
אני יכול לקרוא לכיתה בשיטה זו על זה ככה.

361
00:19:23,000 --> 00:19:26,000
כל שאלות בתחביר Objective-C לפני שאנחנו מתחילים לנוע ליותר חלק

362
00:19:26,000 --> 00:19:30,000
יישומי חומר התפתחות מעניין?

363
00:19:30,000 --> 00:19:34,000
>> אוקיי, אז בואו בעצם לעשות אפליקציית אייפון.

364
00:19:34,000 --> 00:19:39,000
שיעורי הליבה, כי אתה תהיה באמצעות בפנים של אפליקציית אייפון שלך נקראים בקרי נוף,

365
00:19:39,000 --> 00:19:42,000
ובקר נוף בעצם מייצג מסך יחיד

366
00:19:42,000 --> 00:19:46,000
בתוך היישום שלך, כך שאם אני באפליקצית המוזיקה, למשל,

367
00:19:46,000 --> 00:19:50,000
בקר תצוגה אחת יכול לייצג את הנוף שבאני רואה את כל השירים באייפון שלי.

368
00:19:50,000 --> 00:19:53,000
בקר תצוגה אחרת יכול להיות כאשר אני לוחץ על שיר ולהתחיל לשחק אותו

369
00:19:53,000 --> 00:19:55,000
או כפי שאני קודח לתוך אמנים.

370
00:19:55,000 --> 00:19:59,000
כל אחד מהמסכים האלה שונים יכול להיות מיוצגים כבקר מבט שונה,

371
00:19:59,000 --> 00:20:04,000
ובקר נוף הוא באמת רק בכיתה שאומרת איך המסך הזה עובד.

372
00:20:04,000 --> 00:20:07,000
דברים בתוך נוף של בקר, אנחנו הולכים ליש תכונות,

373
00:20:07,000 --> 00:20:10,000
כך הדברים כמו כפתור הולכים להיות רכושו של בקר הנוף שלנו.

374
00:20:10,000 --> 00:20:13,000
>> אנחנו גם הולכים להיות לי שיטות, ואלה הם בעצם מטפלי אירועים.

375
00:20:13,000 --> 00:20:16,000
שיטה זו אומרת כאשר אתה לוחץ על כפתור זה

376
00:20:16,000 --> 00:20:19,000
אני רוצה לעשות משהו, ולבסוף, שוב,

377
00:20:19,000 --> 00:20:24,000
אנחנו הולכים להיות באמצעות מילות מפתח עצמית לכניסה למופע הנוכחי.

378
00:20:24,000 --> 00:20:29,000
כדי לבנות ממשקים בiOS הוא בעצם ממש ממש קל.

379
00:20:29,000 --> 00:20:32,000
יש להם לגרור זה נחמד ושחרר ממשק נקרא Interface Builder,

380
00:20:32,000 --> 00:20:37,000
ואת 2 מושגי הליבה שתיל את Objective-C שלך לממשק Builder

381
00:20:37,000 --> 00:20:40,000
הם IBOutlet וIBAction.

382
00:20:40,000 --> 00:20:44,000
IBOutlet פשוט אומר שאם אתה מצהיר על רכוש זה כפתור,

383
00:20:44,000 --> 00:20:47,000
ואתה רוצה לחבר את זה למשהו בממשק המשתמש שלך בפועל,

384
00:20:47,000 --> 00:20:49,000
אתה הולך להגיד שזה שקע.

385
00:20:49,000 --> 00:20:51,000
בדומה לכך, אם אתה רוצה לייצג מטפל באירועים

386
00:20:51,000 --> 00:20:54,000
ואז אתה הולך להגיד שזה פעולה.

387
00:20:54,000 --> 00:20:57,000
>> למעשה תמלכד את הייצוג גרפי זה

388
00:20:57,000 --> 00:21:00,000
והקוד שלך שזה ממש ממש פשוט.

389
00:21:00,000 --> 00:21:03,000
אם ברצונך לצרף IBOutlet, כל מה שאתה צריך לעשות הוא לשלוט קליק,

390
00:21:03,000 --> 00:21:05,000
ואנו רואים דוגמה לכך זה ממש מהר.

391
00:21:05,000 --> 00:21:07,000
אתה שולט על איפה זה אומר בקר תצוגה.

392
00:21:07,000 --> 00:21:09,000
אתה הולך לגרור לתוך הממשק, או לחלופין,

393
00:21:09,000 --> 00:21:13,000
אם אתה רוצה לחבר את מטפל באירועים שאתה הולך לגרור מתוך הממשק

394
00:21:13,000 --> 00:21:15,000
בכיוון השני.

395
00:21:15,000 --> 00:21:20,000
בואו נסתכל על דוגמא iOS ממש פשוט.

396
00:21:20,000 --> 00:21:23,000
>> בואו ליצור פרויקט חדש.

397
00:21:23,000 --> 00:21:25,000
אני לא מגיע לכאן לבקשה,

398
00:21:25,000 --> 00:21:28,000
ואני הולך לחץ על יישום צפייה בהודעה בודד.

399
00:21:28,000 --> 00:21:31,000
אני הולך ללחוץ על בא. אני אתן לי הפרויקט שלי שם.

400
00:21:31,000 --> 00:21:33,000
אני אקרא לו שלום.

401
00:21:33,000 --> 00:21:36,000
מעניין, אפל מניח שאתה יוצר מוצר

402
00:21:36,000 --> 00:21:38,000
כך שאתה יכול למכור אותו והם יכולים להרוויח כסף.

403
00:21:38,000 --> 00:21:41,000
כאן אני הולך להגיד שזה אפליקציית אייפון.

404
00:21:41,000 --> 00:21:44,000
באפשרותך ליצור יישום ל-iPad, או אם ברצונך ליצור אחד מאלה Apps

405
00:21:44,000 --> 00:21:47,000
שתומך בשני ההתקנים שאתה יכול לעשות גם את זה.

406
00:21:47,000 --> 00:21:49,000
אלה הם מה שאתה רוצה checkmarks להיראות.

407
00:21:49,000 --> 00:21:51,000
>> ברצונך להשתמש storyboards, שנראים בהמשך,

408
00:21:51,000 --> 00:21:54,000
ואתה בהחלט רוצה להשתמש ספירה מכוונת אוטומטית,

409
00:21:54,000 --> 00:21:58,000
בו היא תכונה נחמדה שמונעת ממך את הצורך לומר malloc וחופשי.

410
00:21:58,000 --> 00:22:03,000
אלא אם כן אתה רוצה לקרוא לmalloc וחופשי, הייתי משאיר את בדק את זה.

411
00:22:03,000 --> 00:22:07,000
אני לוחץ על בא, ולבסוף, זה הולך לשאול אותי איפה אני רוצה לשמור אותו.

412
00:22:07,000 --> 00:22:14,000
אני אכה ליצור, והנה זה בא.

413
00:22:14,000 --> 00:22:16,000
אני יצרתי את פרויקט חדש.

414
00:22:16,000 --> 00:22:19,000
כאן בצד השמאל נמצאים כל הקבצים הנמצאים בתוכו של הפרויקט שלי,

415
00:22:19,000 --> 00:22:22,000
ושים לב שיש לי חבורה שלמה, ואני אפילו לא עשיתי שום דבר.

416
00:22:22,000 --> 00:22:24,000
IOS הוא גדול.

417
00:22:24,000 --> 00:22:27,000
>> לדוגמה, הנה זה ViewController.h,

418
00:22:27,000 --> 00:22:30,000
זה הולך לייצג בקר הפעם הראשונה שלי,

419
00:22:30,000 --> 00:22:32,000
כך במסך הראשון בתוך האפליקציה שלי.

420
00:22:32,000 --> 00:22:34,000
עכשיו אנחנו יודעים מה שזה אומר.

421
00:22:34,000 --> 00:22:36,000
אנחנו אומרים אני מתקשר ViewController המעמד הזה,

422
00:22:36,000 --> 00:22:40,000
וViewController עושה כל מה שעושה UIViewController,

423
00:22:40,000 --> 00:22:43,000
וזה, שוב, הוא חלק הכיתה שאפל כתב שעושה המון דברים שימושיים עבורנו

424
00:22:43,000 --> 00:22:46,000
רוצים להציג את המסך.

425
00:22:46,000 --> 00:22:50,000
כאן מקום שבו אני יכול באמת להתחיל להגדיר מה בקר דעתי עושה,

426
00:22:50,000 --> 00:22:52,000
ומתברר שאני באמת לא צריך את כל זה.

427
00:22:52,000 --> 00:22:55,000
זה קוד מוכן מראש כי אפל נותן לי בחינם.

428
00:22:55,000 --> 00:22:59,000
אני באמת זקוק שהשורה ראשונה, או שאין לי מעמד,

429
00:22:59,000 --> 00:23:02,000
כדי שנוכל להיפטר מזה ולהיפטר מזה.

430
00:23:02,000 --> 00:23:05,000
אוקיי, אז זה המסך הריק שלי.

431
00:23:05,000 --> 00:23:08,000
>> עכשיו בואו לחצו על MainStoryboard.storyboard זה,

432
00:23:08,000 --> 00:23:11,000
וזה המקום שבו מתחיל להיות מעניין.

433
00:23:11,000 --> 00:23:14,000
זה מייצג את המסך הראשון על האפליקציה שלי.

434
00:23:14,000 --> 00:23:17,000
אם אני רוצה להוסיף כפתור, ב-HTML הייתי צריך ליצור תג כפתור.

435
00:23:17,000 --> 00:23:20,000
באנדרואיד אתה צריך ליצור תג כפתור,

436
00:23:20,000 --> 00:23:23,000
אבל בiOS אם אני רק באתי לכאן כדי ימני התחתון

437
00:23:23,000 --> 00:23:27,000
ואם אני לוחץ על אחד 3 זה כאן איפה זה אומר אובייקטים,

438
00:23:27,000 --> 00:23:31,000
ואני יכול לגלול למטה, או שאני יכול להתחיל לחפש כפתור.

439
00:23:31,000 --> 00:23:35,000
ותראה, כפתור, כך שאם אני ממש לגרור ולשחרר זכות זו קיימת,

440
00:23:35,000 --> 00:23:38,000
רק אני הוספתי כפתור למסך הזה באפליקציה שלי.

441
00:23:38,000 --> 00:23:41,000
אם אני רוצה לשנות את הטקסט, אני יכול ללחוץ לחיצה כפולה עליו,

442
00:23:41,000 --> 00:23:47,000
לומר משהו מפתה כמו "לחץ עליי."

443
00:23:47,000 --> 00:23:51,000
אוקיי, עכשיו אם אני מפעיל את היישום הזה, כדי שנהדר אותו,

444
00:23:51,000 --> 00:23:54,000
כך כדי להפעיל אותו אני לוחץ על כפתור ההפעלה בצד השמאל למעלה, ויש האפליקציה שלי.

445
00:23:54,000 --> 00:23:58,000
אני לא עשיתי שום דבר, ויש לי אפליקציית אייפון מחפש מתוקה.

446
00:23:58,000 --> 00:24:01,000
אם אני רוצה להפסיק את זה, אתה יכול ללחוץ על כפתור העצירה

447
00:24:01,000 --> 00:24:03,000
כי זה יותר כיף.

448
00:24:03,000 --> 00:24:07,000
>> בואו נגיד שאני ממש רוצה שמשהו יקר, כאשר אני לוחץ על כפתור זה.

449
00:24:07,000 --> 00:24:09,000
כדי לעשות את זה מה שאני צריך לעשות זה אני צריך ליצור

450
00:24:09,000 --> 00:24:13,000
מטפל חדש אירוע או פעולה.

451
00:24:13,000 --> 00:24:16,000
זה אומר שאני צריך ליצור כמה שיטה שאני רוצה שייקרא

452
00:24:16,000 --> 00:24:18,000
כשאני לוחץ על הכפתור, אז בואו ליצור שיטה חדשה.

453
00:24:18,000 --> 00:24:20,000
אני פנימי של ViewController.h.

454
00:24:20,000 --> 00:24:22,000
אני צריך לומר ששיטה קיימת.

455
00:24:22,000 --> 00:24:26,000
אני צריך מקף ראשון, כי אני הולך להתקשר אל זה בבקר התצוגה.

456
00:24:26,000 --> 00:24:28,000
אני צריך לתת לזה סוג.

457
00:24:28,000 --> 00:24:31,000
הסוג זה הולך להיות דבר IBAction שראו קודם לכן.

458
00:24:31,000 --> 00:24:35,000
זה מטפל באירוע, כך שזה הולך לחזור IBAction,

459
00:24:35,000 --> 00:24:38,000
וזה רמז כדי Xcode לומר כי

460
00:24:38,000 --> 00:24:40,000
זה משהו שאני רוצה להעביר משהו.

461
00:24:40,000 --> 00:24:45,000
אני יכול לתת לו שם, כמו, פסיק buttonPressed.

462
00:24:45,000 --> 00:24:48,000
>> עכשיו אני כבר הכרזתי על שיטה חדשה בתוך הכיתה שלי.

463
00:24:48,000 --> 00:24:50,000
אני כבר אמרתי בשיטה זו צריכה להתקיים.

464
00:24:50,000 --> 00:24:53,000
עכשיו בואו ניכנס לViewController.m,

465
00:24:53,000 --> 00:24:56,000
ובואו נגיד את מה ששיטה זו יכולה לעשות.

466
00:24:56,000 --> 00:25:03,000
אם אני מתחיל להקליד, למשל, (void) buttonPressed

467
00:25:03,000 --> 00:25:06,000
ההודעה Xcode הוא ממש נחמד וautocompletes בשבילי.

468
00:25:06,000 --> 00:25:09,000
זה ממש נפלא.

469
00:25:09,000 --> 00:25:12,000
שים לב כאן שבתוך הקובץ. אני יכול גם לומר הריק,

470
00:25:12,000 --> 00:25:15,000
וזה בגלל שIBAction לא ממש סוג.

471
00:25:15,000 --> 00:25:19,000
זה בעצם hashtag מוגדר איפשהו להיות מבוטל,

472
00:25:19,000 --> 00:25:22,000
ושוב, זה רק ברמז כדי Xcode שאומר

473
00:25:22,000 --> 00:25:25,000
אני רוצה שזה יהיה מטפל באירועים, ואנו רואים במה רק לשנייה.

474
00:25:25,000 --> 00:25:28,000
כאשר לחצן זה נלחץ שאני הולך לעשות משהו מעצבן

475
00:25:28,000 --> 00:25:30,000
רוצים להציג חלונות קופצים.

476
00:25:30,000 --> 00:25:35,000
>> כדי לעשות את זה אני יכול ליצור מופע חדש של מחלקה זו נקראת UIAlertView,

477
00:25:35,000 --> 00:25:39,000
וזו כיתה שאפל כתב שהולך להצגת חלונות קופצים מעצבנים.

478
00:25:39,000 --> 00:25:43,000
אנחנו נתקשר התראת צץ זה, ויש לי 2 צעדים, זוכרים, ליצירת אובייקט זה.

479
00:25:43,000 --> 00:25:46,000
הדבר הראשון שצריך לעשות הוא להקצות שטח.

480
00:25:46,000 --> 00:25:48,000
אני רוצה UIAlertView.

481
00:25:48,000 --> 00:25:51,000
אני רוצה להקצות שטח. זאת השיטה הראשונה שלי.

482
00:25:51,000 --> 00:25:53,000
השיטה הבאה שלי היא שאני רוצה לאתחל אותו,

483
00:25:53,000 --> 00:25:58,000
ואז יש לי זמן רבה בשיטה זו גדולה, הנקראת initWithTitle.

484
00:25:58,000 --> 00:26:01,000
זה בעצם הולך לשלוט במה צץ זה אומר.

485
00:26:01,000 --> 00:26:04,000
הכותרת שלי קופץ יכולה להיות שלום.

486
00:26:04,000 --> 00:26:08,000
המסר של זה קופץ יכול להיות "זה iOS."

487
00:26:08,000 --> 00:26:10,000
דבר נציג, אני לא יודע מה זה.

488
00:26:10,000 --> 00:26:13,000
בואו נגיד שזה כלום.

489
00:26:13,000 --> 00:26:18,000
עכשיו כפתור שהולך להופיע יכול לומר משהו כמו "זה בטוח",

490
00:26:18,000 --> 00:26:24,000
ואני לא באמת רוצה את כל כפתורים אחרים, אז בואו נמחק את זה ולסגור את הסוגר.

491
00:26:24,000 --> 00:26:27,000
>> אוקיי, אני יצרתי אחד נוסף. הנה.

492
00:26:27,000 --> 00:26:30,000
זה איך אני יכול ליצור קופץ חדש.

493
00:26:30,000 --> 00:26:35,000
אם אני רוצה באמת להראות קופץ אני רוצה להתקשר לשיטת ההצגה.

494
00:26:35,000 --> 00:26:38,000
כדי לעשות את זה אני יכול לומר ערני ותכנית,

495
00:26:38,000 --> 00:26:40,000
ושוב, השלמה האוטומטית הייתה סופר נחמד.

496
00:26:40,000 --> 00:26:42,000
אם שכחתי מה זה היה, אם אני פשוט הקלדתי בים,

497
00:26:42,000 --> 00:26:45,000
אני יכול לגלול לכאן כדי להבין מה זה היה,

498
00:26:45,000 --> 00:26:48,000
והוא מסנן בצורה נאה.

499
00:26:48,000 --> 00:26:52,000
עכשיו אני יצרתי קופץ החדש הזה.

500
00:26:52,000 --> 00:26:55,000
אנחנו נחזור למה שאומר נציג מאוחר יותר,

501
00:26:55,000 --> 00:26:58,000
ועכשיו אני רוצה לומר שאני רוצה בשיטה זו כדי להיות מפוטרת

502
00:26:58,000 --> 00:27:01,000
כשאני לוחץ על הכפתור, ולכן אני מתכוון לחזור ללוח התכנון שלי,

503
00:27:01,000 --> 00:27:04,000
ועכשיו אני רוצה לצרף IBAction זה.

504
00:27:04,000 --> 00:27:06,000
הדבר הראשון שאתה רוצה לעשות הוא ללחוץ על הכפתור.

505
00:27:06,000 --> 00:27:08,000
כאשר אני לוחץ על כפתור זה אני רוצה שמשהו יקר.

506
00:27:08,000 --> 00:27:10,000
אני לא מתכוון להחזיק את השליטה.

507
00:27:10,000 --> 00:27:13,000
אני הולך ללחוץ ולגרור מהכפתור

508
00:27:13,000 --> 00:27:15,000
לכאן איפה זה אומר בקר תצוגה.

509
00:27:15,000 --> 00:27:17,000
אנחנו יכולים לראות שזה יפה מצית.

510
00:27:17,000 --> 00:27:22,000
>> אם אני עוזב עם העכבר שלי עכשיו יש לי זה קופץ לכאן שם יש לי כמה אפשרויות.

511
00:27:22,000 --> 00:27:24,000
אחד מאלה הם האירועים שאני יכול להירשם.

512
00:27:24,000 --> 00:27:28,000
כל אלה הם השיטות האלה אני מוצהר בתיק שלי כשעתי IBActions.

513
00:27:28,000 --> 00:27:31,000
כך Xcode יודע מה צריך להופיע ברשימה הקטנה הזה,

514
00:27:31,000 --> 00:27:33,000
אז זה רק רמז.

515
00:27:33,000 --> 00:27:37,000
אם אני לוחץ על כפתור לחוץ, אני כבר עכשיו נרשמתי המטפל באירועים.

516
00:27:37,000 --> 00:27:41,000
ב-JavaScript יש לנו לומר שיש לי קצת קוד שנרשם המטפל באירועים.

517
00:27:41,000 --> 00:27:43,000
בObjective-C שזה באמת כל כך קל.

518
00:27:43,000 --> 00:27:46,000
אם אני מפעיל את זה שוב

519
00:27:46,000 --> 00:27:49,000
עכשיו כשאני לוחץ על כפתור המטפל באירועים שלי הולך לירות,

520
00:27:49,000 --> 00:27:51,000
ואני הולך לקבל את זה קופץ.

521
00:27:51,000 --> 00:27:54,000
סופר, סופר פשוט שם.

522
00:27:54,000 --> 00:27:57,000
>> אם אתה רוצה לראות את כל האירועים שקורים לי להיות רשומים

523
00:27:57,000 --> 00:28:00,000
ברכיב אם אני לוחץ על הכפתור הזה

524
00:28:00,000 --> 00:28:02,000
ואני בא לכאן לצד ימין

525
00:28:02,000 --> 00:28:05,000
ראשון שאתה יכול לראות כאן שאני יכול לעשות דברים כמו הסוג של הכפתור,

526
00:28:05,000 --> 00:28:08,000
כך שאם אתה רוצה אחד שלי כפתור מגע התוספת של או אלה

527
00:28:08,000 --> 00:28:10,000
או משהו כזה.

528
00:28:10,000 --> 00:28:13,000
אם אני רוצה לראות את כל אירועים שעל הכפתור הזה

529
00:28:13,000 --> 00:28:16,000
אם אני עושה את כל הדרך לכאן לצד ימין

530
00:28:16,000 --> 00:28:19,000
אנחנו יכולים לראות כאן באירועים שיש לי את כל האירועים הללו.

531
00:28:19,000 --> 00:28:23,000
אני יכול ללחוץ על הכפתור, כשאני משתחרר מלחץ, כשלהכפיל רז או משהו כזה,

532
00:28:23,000 --> 00:28:26,000
והאחד אני פשוט נרשמתי הוא האירוע הזה שנקרא ריטוש בפנים

533
00:28:26,000 --> 00:28:29,000
וזה אומר שברגע שהאצבע שלי מגיעה מהכפתור

534
00:28:29,000 --> 00:28:32,000
אירוע שהוא הולך לאש, וזה בדיוק מה שקרה.

535
00:28:32,000 --> 00:28:36,000
זה סוג של אירוע לחץ על כפתור ברירת המחדל.

536
00:28:36,000 --> 00:28:39,000
>> כל שאלות עד כה?

537
00:28:39,000 --> 00:28:43,000
אוקיי, זה איך אנחנו יכולים להתחיל נמלכד את הדברים בקוד שלנו

538
00:28:43,000 --> 00:28:46,000
לדברים בתוך הממשק שלנו.

539
00:28:46,000 --> 00:28:49,000
זכור הדבר הראשון שהיה צריך לעשות זה למצוא את הקוד,

540
00:28:49,000 --> 00:28:54,000
ואז אנחנו חוטית את הממשק לקוד,

541
00:28:54,000 --> 00:28:57,000
ויש האפליקציה הראשונה שלנו.

542
00:28:57,000 --> 00:29:00,000
אוקיי, זה היה ממש מגניב, ויצרנו לחצן זה.

543
00:29:00,000 --> 00:29:03,000
מה אם אנחנו לא רוצים שנהיה לי ליצור חבורה של נכסים

544
00:29:03,000 --> 00:29:05,000
מייצג את הכפתורים האלה?

545
00:29:05,000 --> 00:29:08,000
לדוגמה, בבוהן טיק טק, יש לי 9 לחצנים,

546
00:29:08,000 --> 00:29:11,000
וזה יהיה סופר, סופר מעצבן צריך לגרור ולשחרר 9 פעמים

547
00:29:11,000 --> 00:29:14,000
או שאם הייתי צריך לעשות בוהן טיק טק, עם 81 במקום 9

548
00:29:14,000 --> 00:29:17,000
והייתי צריך לגרור ולשחרר 81 פעמים, וזה צולע.

549
00:29:17,000 --> 00:29:20,000
מה אנחנו יכולים לעשות במקום זה הוא הרבה יותר כמו HTML

550
00:29:20,000 --> 00:29:23,000
כאשר היו לנו דברים כמו תעודות זהות ושמות ואנחנו יכולים לחפש דברים

551
00:29:23,000 --> 00:29:27,000
לפי תעודת הזהות שלהם, יש רעיון דומה בשם iOS תגים.

552
00:29:27,000 --> 00:29:31,000
>> תג הוא פשוט מזהה מספרי ייחודית לרכיב.

553
00:29:31,000 --> 00:29:34,000
אם אני אומר את זה יש לו תג של 0, למשל,

554
00:29:34,000 --> 00:29:38,000
אם אני יוצר כפתור ונותן לו תג של 0, ואנחנו נראה איך לעשות את זה ברגע,

555
00:29:38,000 --> 00:29:41,000
אם אני רוצה לקבל את הכפתור שאני פשוט יכול להגיד שאני רוצה לקרוא

556
00:29:41,000 --> 00:29:45,000
viewWithTag שיטה על האובייקט כאן,

557
00:29:45,000 --> 00:29:48,000
self.view, המייצג את המסך הנוכחי, למשל.

558
00:29:48,000 --> 00:29:53,000
אם אני קורא לזה שיטת viewWithTag, אני הולך למשוך חזרה את הכפתור עם תג 0.

559
00:29:53,000 --> 00:29:58,000
בואו נסתכל על זה על ידי בניין בוהן טיק טק.

560
00:29:58,000 --> 00:30:01,000
ראשית, זה התכנון שלי.

561
00:30:01,000 --> 00:30:05,000
יצרתי 10 כפתורי UI אלה.

562
00:30:05,000 --> 00:30:07,000
שים לב שכולם באותו הגודל.

563
00:30:07,000 --> 00:30:11,000
אם אני לוחץ על אחד מאלה ואני חוזר לכאן בצד זכות זו

564
00:30:11,000 --> 00:30:15,000
תראה אני מותאם גופן ממש כאן, אז עשיתי את הגופן קצת יותר גדול,

565
00:30:15,000 --> 00:30:19,000
אבל מה שגם אני עשיתי הייתה לי להגדיר את התג הזה.

566
00:30:19,000 --> 00:30:23,000
אמרתי שיש לזה תג של 1, וזה למעלה משמאל.

567
00:30:23,000 --> 00:30:26,000
>> עכשיו, אם אני לוחץ על כפתור אחר, כמו שנייה אחת זה כאן,

568
00:30:26,000 --> 00:30:29,000
עכשיו תראה שהתג שלי הוא 2.

569
00:30:29,000 --> 00:30:32,000
כל אחד מהכפתורים האלה פשוט יש תג ייחודי,

570
00:30:32,000 --> 00:30:35,000
ואז זה מאוחר איך אני הולך להתחיל אינטראקציה

571
00:30:35,000 --> 00:30:38,000
עם האפליקציה שלי.

572
00:30:38,000 --> 00:30:40,000
כל זה הוא החלק פנימי של בקר תצוגה אחת,

573
00:30:40,000 --> 00:30:42,000
אבל הנה מה שיש לנו.

574
00:30:42,000 --> 00:30:44,000
יש לנו 3 נכסים כאן.

575
00:30:44,000 --> 00:30:49,000
הראשון והאחרון הולכים לייצג את המדינה של הלוח שלי.

576
00:30:49,000 --> 00:30:53,000
העיקרון ראשון זה הוא מערך שבו מייצג X ו הם.

577
00:30:53,000 --> 00:30:57,000
אחד האחר כאן אומר לנו התור של מי.

578
00:30:57,000 --> 00:31:01,000
תוכל להבחין כי יש לי גם את הדברים האלה כאן.

579
00:31:01,000 --> 00:31:05,000
לפני כשהכרזנו מאפיינים שנתנו להם שם וסוג.

580
00:31:05,000 --> 00:31:08,000
אנחנו גם יכולים לתת להם קצת מידע נוסף כאן.

581
00:31:08,000 --> 00:31:11,000
זה ראשון אומר nonatomic, ומה זה אומר

582
00:31:11,000 --> 00:31:16,000
הוא בעצם רק דבר אחד לא שאתה מנסה לגשת משתנה זה בכל פעם.

583
00:31:16,000 --> 00:31:19,000
אתה יכול לעשות יישומים מורכבים יותר, כי הם ריבוי הליכים,

584
00:31:19,000 --> 00:31:22,000
וזאת שוב בשריטה שהיינו לנו נושאים שונים,

585
00:31:22,000 --> 00:31:25,000
ושדונים שונים יכולים לעשות דברים שונים באותו הזמן.

586
00:31:25,000 --> 00:31:29,000
>> אם זה לא מקרה, שזה לא בכל דבר שאנחנו יהיו מסתכלים,

587
00:31:29,000 --> 00:31:33,000
אם אנחנו אומרים nonatomic זה באמת הולך לעשות את הדברים בצורה קצת יותר מהר.

588
00:31:33,000 --> 00:31:37,000
יש לנו גם הדבר הזה שנקרא הקצאה, חזק, או חלש.

589
00:31:37,000 --> 00:31:40,000
זה להקצות רק אומר שזה סוג סטנדרטי.

590
00:31:40,000 --> 00:31:43,000
זה לא אובייקט או מצביע כי זה פשוט bool,

591
00:31:43,000 --> 00:31:46,000
כך bool בנוי לתוך Objective-C.

592
00:31:46,000 --> 00:31:49,000
זה אומר אל תנסה לעשות משהו מפואר עם מצביעים כאן.

593
00:31:49,000 --> 00:31:51,000
זה Scaler ישן רגיל.

594
00:31:51,000 --> 00:31:54,000
חזק וחלש, זה אומר שבעצם חלש

595
00:31:54,000 --> 00:31:57,000
אני רוצה שזה יהיה הצבעה על משהו בבקר התצוגה.

596
00:31:57,000 --> 00:32:00,000
אני לא מתכוון דווקא להקצאה או init את זה בעצמי.

597
00:32:00,000 --> 00:32:04,000
ממשק הקבלן, כאשר אני מפעיל את היישום, הוא הולך להתמודד עם כל אתחול זה.

598
00:32:04,000 --> 00:32:07,000
אם אני אומר חלש, שאומר שמישהו אחר הולך להיות יצירה זו.

599
00:32:07,000 --> 00:32:09,000
אם אני אומר חזק, זה אומר שאני הולך להיות זה

600
00:32:09,000 --> 00:32:12,000
זה יוצר אובייקט הלוח הזה,

601
00:32:12,000 --> 00:32:14,000
אז הנה יש לי עוד כמה שיטות כאן,

602
00:32:14,000 --> 00:32:18,000
לדוגמה, פעולה לכאשר כפתור המשחק החדש כלשהו,

603
00:32:18,000 --> 00:32:20,000
פעולה לכאשר כל כפתורים האחרים נלחצים,

604
00:32:20,000 --> 00:32:23,000
וכדומה.

605
00:32:23,000 --> 00:32:26,000
>> אנו לא נכנסנו ליותר מדי ההיגיון של בוהן טיק טק,

606
00:32:26,000 --> 00:32:30,000
למרות שזה מאוד מרגש, אבל בואו נסתכל על

607
00:32:30,000 --> 00:32:33,000
כמה מהדברים שאנחנו יכולים לעשות בתוך iOS.

608
00:32:33,000 --> 00:32:35,000
שיטת משחק חדש זה הולכת להיות מפוטר

609
00:32:35,000 --> 00:32:37,000
בכל פעם שאני לוחץ על כפתור המשחק החדש.

610
00:32:37,000 --> 00:32:41,000
כדי לחבר את זה פשוט לבוא אל לוח התכנון שלי.

611
00:32:41,000 --> 00:32:43,000
אני לוחץ על משחק חדש.

612
00:32:43,000 --> 00:32:47,000
אם אני בא לכאן, מצד הימין, ניתן לראות כי

613
00:32:47,000 --> 00:32:50,000
לגעת בתוך מחווט לשיטת newGame.

614
00:32:50,000 --> 00:32:53,000
זו הסיבה שזה הולך להיות מפוטר.

615
00:32:53,000 --> 00:32:56,000
שיטת newGame הוא הולך לעשות קצת סט.

616
00:32:56,000 --> 00:32:59,000
זה הולך להגיד שאני רוצה אותך כדי לנקות את המדינה של הלוח.

617
00:32:59,000 --> 00:33:01,000
זוהי שיטה נחמדה במערכים משתנים.

618
00:33:01,000 --> 00:33:03,000
זה הולך לומר עכשיו זה תורו של X,

619
00:33:03,000 --> 00:33:07,000
ועכשיו אני הולך לקחת את היתרון של דבר viewWithTag זה.

620
00:33:07,000 --> 00:33:11,000
>> אני יודע שיש לי כפתורי התגים 1-9,

621
00:33:11,000 --> 00:33:13,000
וזה משהו שאני באופן שרירותי בחרתי.

622
00:33:13,000 --> 00:33:15,000
אם אני רוצה להגדיר את הטקסט של כל כפתור כדי להיות ריק

623
00:33:15,000 --> 00:33:17,000
כי אני פשוט התחלתי משחק חדש ואני לא רוצה שכל

624
00:33:17,000 --> 00:33:20,000
Xs או OS להיות שנשאר אני יכול לעשות את זה.

625
00:33:20,000 --> 00:33:24,000
אני יכול להגיד שאני רוצה את התצוגה עם התג, 1, 2, 3, 4 וכולי '.

626
00:33:24,000 --> 00:33:27,000
זה ימשוך כפתור אחר בכל פעם.

627
00:33:27,000 --> 00:33:30,000
הנה אני הולך להפיל אותו לUIButton.

628
00:33:30,000 --> 00:33:33,000
בדיוק כמו שאנחנו יכולים להטיל ints לצף ולהיפך

629
00:33:33,000 --> 00:33:37,000
זה אומר שאני רוצה להטיל את זה לUIButton.

630
00:33:37,000 --> 00:33:40,000
כלומר, הסוג של זה יהיה * UIButton

631
00:33:40,000 --> 00:33:43,000
בגלל מצביעים, אבל אל תדאגו, הם לא מפחידים יותר.

632
00:33:43,000 --> 00:33:47,000
>> ברגע שיש לי לחצן זה אני הולך לקרוא לשיטה על זה.

633
00:33:47,000 --> 00:33:50,000
שיטה זו נקראת setTitle forState, ואז זה אומר

634
00:33:50,000 --> 00:33:53,000
אני רוצה להגדיר את הטקסט של הכפתור להיות המחרוזת הריקה,

635
00:33:53,000 --> 00:33:57,000
ואני רוצה שזה יהיה המחרוזת הריקה כאשר זה לא נלחץ.

636
00:33:57,000 --> 00:34:01,000
אם אני משתמש בשיטה זו, אני יכול לשנות את הטקסט של הכפתור

637
00:34:01,000 --> 00:34:04,000
ברגע שמישהו פוגע בו, אבל אנחנו רוצים לומר כאשר הכפתור פשוט יושב שם

638
00:34:04,000 --> 00:34:07,000
אני רוצה שהטקסט יהיה ריק.

639
00:34:07,000 --> 00:34:10,000
לבסוף, אנחנו הולכים לאתחל הלוח שלי,

640
00:34:10,000 --> 00:34:12,000
ואני הולך לומר שהכל נמצא כרגע ב 0,

641
00:34:12,000 --> 00:34:15,000
אז זה לחברי הנהלה הוא בלתי ניתן לשינוי משתנה מערך,

642
00:34:15,000 --> 00:34:21,000
מה שאומר שאני יכול לקרוא את שיטת addObject ורק 0 בתוכו.

643
00:34:21,000 --> 00:34:23,000
זה מה שקורה כשאני יוצר משחק חדש.

644
00:34:23,000 --> 00:34:25,000
>> בואו נסתכל על זה.

645
00:34:25,000 --> 00:34:28,000
שיטה זו הנה IBAction זה הולך להיות לחוץ

646
00:34:28,000 --> 00:34:31,000
בכל פעם שאחד מהריבועים האלה נלחצה.

647
00:34:31,000 --> 00:34:33,000
עכשיו יש לנו קצת היגיון טיק טק טו כאן.

648
00:34:33,000 --> 00:34:36,000
אנו להבין תורו של מי,

649
00:34:36,000 --> 00:34:39,000
ועל סמך זה אנו גם להגדיר X או O,

650
00:34:39,000 --> 00:34:43,000
אבל אנחנו שמים לב שאנחנו שימוש חוזרים באותו מטפל אירוע זה

651
00:34:43,000 --> 00:34:45,000
לכל אחד ואחת מהכפתורים האלה.

652
00:34:45,000 --> 00:34:49,000
זה אומר שאין לי שיטה לכפתור השמאלי העליון,

653
00:34:49,000 --> 00:34:52,000
שיטה שונה לכפתור הימני התחתון, למרות שהייתי יכול לעשות את זה.

654
00:34:52,000 --> 00:34:54,000
זה אפילו לא יהיה עיצוב טוב.

655
00:34:54,000 --> 00:34:57,000
מה שאני עושה כאן הוא בעצם אני הולך לקבוע

656
00:34:57,000 --> 00:35:00,000
מה התג של הכפתור שנלחץ הוא.

657
00:35:00,000 --> 00:35:04,000
אתה שם לב ששיטת המחזה הזה לוקח טיעון אחד.

658
00:35:04,000 --> 00:35:07,000
זה נקרא שולח, ומה ששולח הוא השולח הולך

659
00:35:07,000 --> 00:35:10,000
מייצג בדיוק את מה שנלקח על פעולה.

660
00:35:10,000 --> 00:35:15,000
אם אני לוחץ על כפתור, שולח זה הולך להיות שUIButton

661
00:35:15,000 --> 00:35:18,000
שלחצתי ממש, אז זה אומר שUIButton

662
00:35:18,000 --> 00:35:20,000
יש תג משום שאני יצרתי תג.

663
00:35:20,000 --> 00:35:23,000
>> אם אני רוצה להגיע אליו התג אני יכול פשוט לומר

664
00:35:23,000 --> 00:35:26,000
אני רוצה תג של השולח,

665
00:35:26,000 --> 00:35:28,000
ושוב, אני פשוט casted לUIButton.

666
00:35:28,000 --> 00:35:32,000
אני במקרה יודע שהשולח יהיה UIButton.

667
00:35:32,000 --> 00:35:34,000
זה לא תמיד חייב להיות UIButton.

668
00:35:34,000 --> 00:35:36,000
אני יכול, למשל, לרשום אותו המטפל באירועים

669
00:35:36,000 --> 00:35:38,000
 לאחד לכפתור, אחד למחוון.

670
00:35:38,000 --> 00:35:40,000
במקרה זה, אני יודע שהם כל הכפתורים, אז אני הולך להגיד

671
00:35:40,000 --> 00:35:43,000
אני רוצה שזה יהיה כפתור, ואז אני יכול לקבל את התג,

672
00:35:43,000 --> 00:35:48,000
ומהתג שאני יודע עכשיו איפה אני פנימי של הלוח.

673
00:35:48,000 --> 00:35:51,000
ואז אני יכול פשוט להגדיר X או O, יכול להעיף את התור,

674
00:35:51,000 --> 00:35:54,000
לבדוק מי נצח, וכולי.

675
00:35:54,000 --> 00:35:59,000
>> כל שאלות על זה עד כה?

676
00:35:59,000 --> 00:36:02,000
אוקיי, את כל הקוד שפורסמנו באינטרנט, אנחנו לא רוצים להיכנס ליותר מדי

677
00:36:02,000 --> 00:36:06,000
של היגיון טו טיק טק, אבל עכשיו אתה יכול לראות שבאמת

678
00:36:06,000 --> 00:36:09,000
כל מה שאנחנו עושים הוא שאנחנו מלפפים על מערך זה,

679
00:36:09,000 --> 00:36:13,000
אז יש לנו כמה לולאות לכאן, ואנחנו רק משווים לראות

680
00:36:13,000 --> 00:36:18,000
יש לנו משחק בכל השורות, התאמה בעמודה או משהו כזה.

681
00:36:18,000 --> 00:36:21,000
בפועל כדי להפעיל את היישום הזה, אם אני מקיש על אחד מהכפתורים האלה

682
00:36:21,000 --> 00:36:24,000
כי שיטת המשחק פוטרה, אז זה אומר שאני פשוט להגדיר

683
00:36:24,000 --> 00:36:31,000
הכפתור כדי להיות X, אז עכשיו על כפתור זה יהיה O, וכן הלאה,

684
00:36:31,000 --> 00:36:35,000
ואז ככה אנחנו מתחילים אינטראקציה עם יישום הדף הבודד הזה.

685
00:36:35,000 --> 00:36:38,000
>> אנחנו מתכוונים לכתוב קוד, אז אתה מוזמן לעיין כי,

686
00:36:38,000 --> 00:36:43,000
אבל בואו עכשיו מדברים על יישומים מסוימים, כי הם יותר מאשר רק דף אחד.

687
00:36:43,000 --> 00:36:47,000
מרגש כמו בוהן טיק טק, היה, הרבה יישומים הפנימיים של iOS

688
00:36:47,000 --> 00:36:50,000
הוא סוג של תרגיל אלה את הדברים עם מסכים מרובה.

689
00:36:50,000 --> 00:36:54,000
המושג הראשון שאנחנו צריכים לדבר עליהם פרוטוקולים,

690
00:36:54,000 --> 00:36:57,000
ופרוטוקול הוא פשוט קבוצה של שיטות

691
00:36:57,000 --> 00:36:59,000
כי אתה יכול להבטיח להגדרה.

692
00:36:59,000 --> 00:37:02,000
אם אני יוצר בפרוטוקול זה חדש עם 2 שיטות, אחת ראשונה זו,

693
00:37:02,000 --> 00:37:05,000
אם סוג החזרה הוא חסר תוקף, אני קראתי לזה foo.

694
00:37:05,000 --> 00:37:07,000
זה לוקח אין ויכוחים. יש לי שיטה אחרת.

695
00:37:07,000 --> 00:37:11,000
זה מחזיר int. אני קראתי לזה בר, וזה לוקח טיעון אחד.

696
00:37:11,000 --> 00:37:14,000
כל פרוטוקול זה הוא שנקרא SomeProtocol עד כאן,

697
00:37:14,000 --> 00:37:19,000
זו היא קבוצה של דברים שמישהו יכול ליישם.

698
00:37:19,000 --> 00:37:22,000
אני לא בתוך של פרוטוקול זה שאמרתי את מה foo עושה.

699
00:37:22,000 --> 00:37:26,000
במקום זאת, אני רק אומר שאתה יכול להגדיר את foo אם אתה רוצה.

700
00:37:26,000 --> 00:37:30,000
אם אני יוצר בקר תצוגה או יצירת מעמד

701
00:37:30,000 --> 00:37:33,000
אני יכול בתוך מהבטחת המעמד ליישם

702
00:37:33,000 --> 00:37:40,000
חלק מהשיטות הללו, כך לדוגמה, אם אומר <SomeProtocol>

703
00:37:40,000 --> 00:37:43,000
זה אומר עכשיו אני עושה ההבטחה שבתוך

704
00:37:43,000 --> 00:37:50,000
כיתה של בקר תצוגה זו תהיה לי הגדרות לשניהם foo ובר.

705
00:37:50,000 --> 00:37:52,000
>> למה זה שימושי?

706
00:37:52,000 --> 00:37:55,000
הרבה רכיבים בתוך של iOS לנצל את זה

707
00:37:55,000 --> 00:37:58,000
תבנית עיצוב בשם משלחת, ומה אומרת משלחת

708
00:37:58,000 --> 00:38:01,000
הוא כי, למשל, אם יש לי תיבת טקסט

709
00:38:01,000 --> 00:38:04,000
ויש כמה אירועים שיכולים להיות רשום בתוך תיבת הטקסט שלי,

710
00:38:04,000 --> 00:38:07,000
ולא יצירת אירועים נפרדים מה שאני יכול לעשות הוא שאני יכול לומר

711
00:38:07,000 --> 00:38:10,000
הנציג של תיבת טקסט זו יהיה חפץ כלשהו.

712
00:38:10,000 --> 00:38:13,000
כשאני אומר שזה נציג עכשיו זה אומר ש

713
00:38:13,000 --> 00:38:16,000
בכל פעם שאירוע היה ירה בתיבת הטקסט

714
00:38:16,000 --> 00:38:18,000
במקום שתצטרך לרשום אותו או משהו כזה

715
00:38:18,000 --> 00:38:21,000
זה רק הולך לקרוא לשיטה בנציג.

716
00:38:21,000 --> 00:38:24,000
לדוגמה, בתוך תיבת הטקסט שלי יש לי שיטה לכאשר אני לוחץ

717
00:38:24,000 --> 00:38:27,000
שעשה כפתור בפינה הימנית התחתונה,

718
00:38:27,000 --> 00:38:30,000
וכך, במקום רישום מטפל באירועים מה שאני יכול לומר הוא

719
00:38:30,000 --> 00:38:34,000
תיבת טקסט, כאן היא אובייקט שאני רוצה שתקרא על שיטה

720
00:38:34,000 --> 00:38:37,000
בכל פעם שמישהו לוחצת על הכפתור, עשה

721
00:38:37,000 --> 00:38:40,000
וזה אומר שאובייקט שיש ליישם חלק הפרוטוקול

722
00:38:40,000 --> 00:38:45,000
שאומר אני מבטיח להגדיר שפעולת הכפתור עשתה,

723
00:38:45,000 --> 00:38:47,000
כי אם זה לא מגדיר את השיטה שאתה וללחוץ Done

724
00:38:47,000 --> 00:38:49,000
אז זה הולך להיות מבלבל.

725
00:38:49,000 --> 00:38:55,000
>> בואו נסתכל על דוגמה.

726
00:38:55,000 --> 00:38:58,000
כאן פשוט אין לי תיבת טקסט אחת,

727
00:38:58,000 --> 00:39:04,000
ואחד מהמאפיינים של תיבת הטקסט הזה כאן בצד זכות זו הוא הנציג.

728
00:39:04,000 --> 00:39:06,000
זהו מאפיין של המעמד.

729
00:39:06,000 --> 00:39:09,000
מה שעשיתי כאן הוא שאני שולט לחצתי, ואני נגרר מהמקום הזה כאן

730
00:39:09,000 --> 00:39:13,000
להשקפת בקר, ואומר שנציג של תיבת טקסט זה עכשיו

731
00:39:13,000 --> 00:39:18,000
הולך להיות בקר התצוגה.

732
00:39:18,000 --> 00:39:20,000
כלומר, כאשר כמה פעולות לקרות, ולא רישום

733
00:39:20,000 --> 00:39:25,000
מטפלי אירועים נפרדים שאני רוצה שתשלח אותם לנציג.

734
00:39:25,000 --> 00:39:28,000
עכשיו בואו נסתכל על בקר דעתי.

735
00:39:28,000 --> 00:39:32,000
בתוך. קובץ h שהבטחתי.

736
00:39:32,000 --> 00:39:36,000
אני הבטחתי ליישם כמה שיטות הפנימיות של פרוטוקול זה

737
00:39:36,000 --> 00:39:38,000
קרא UITextFieldDelegate, ושוב,

738
00:39:38,000 --> 00:39:42,000
זה רק חלק מהרשימה כמה דברים שאני יכול לבחור ליישום.

739
00:39:42,000 --> 00:39:46,000
>> אם אני מגיע לכאן בקובץ. מ 'שלי, אני יישמתי שיטה אחת כזאת.

740
00:39:46,000 --> 00:39:49,000
אני קראתי לזה textFieldShouldReturn

741
00:39:49,000 --> 00:39:52,000
כי זה מה שזה נקרא בתוך הפרוטוקול.

742
00:39:52,000 --> 00:39:57,000
ועכשיו בכל פעם שאני לוחץ על הכפתור בתוך עשה של שדה טקסט

743
00:39:57,000 --> 00:40:00,000
זה מה שהולך לקבל קרא, ואני לא רשמתי את מטפל באירועים.

744
00:40:00,000 --> 00:40:03,000
אני מחובר לנציג, וכל פעם שאירוע זה ירה

745
00:40:03,000 --> 00:40:08,000
זו השיטה שיקבל בשם, כך שאם אני בא לכאן כדי התכנון שלי ולהפעיל אותו,

746
00:40:08,000 --> 00:40:11,000
תוך שהוא טוען שאנחנו יכולים לראות מה זה עושה.

747
00:40:11,000 --> 00:40:13,000
על המסך שלי יש לי 2 דברים.

748
00:40:13,000 --> 00:40:16,000
יש לי שדה הטקסט הזה, ויש לי תווית זו.

749
00:40:16,000 --> 00:40:19,000
אני רק אומר שאני רוצה את הטקסט של תווית זו

750
00:40:19,000 --> 00:40:23,000
להיות שווה לכל מה שהקליד את המשתמש בצד פנימי של שדה הטקסט.

751
00:40:23,000 --> 00:40:26,000
השורה הבאה זה כאן, זה פשוט שיטה שאני מתקשר

752
00:40:26,000 --> 00:40:29,000
בשדה הטקסט שאומר שאני רוצה אותך כדי להסתיר את המקלדת.

753
00:40:29,000 --> 00:40:33,000
זה רק השיטה השרירותית שאפל בחרה.

754
00:40:33,000 --> 00:40:38,000
>> שוב, לפני שעשיתי משהו שהיה לי כדי לחבר את הכל, אז אני ראשון הגעתי לכאן.

755
00:40:38,000 --> 00:40:42,000
מן בקר הנוף אני גורר מעל לתיבת הטקסט.

756
00:40:42,000 --> 00:40:46,000
אני משתחרר, ואני יכול לראות כאן שאני יכול להפוך את נכס שדה טקסט זה

757
00:40:46,000 --> 00:40:49,000
מאז כאן בבקר הנוף שמוגדר רכוש

758
00:40:49,000 --> 00:40:52,000
כי הוא IBOutlet של שדה טקסט.

759
00:40:52,000 --> 00:40:55,000
זה אומר שאני יכול להעביר את הרכוש הזה

760
00:40:55,000 --> 00:40:59,000
לשדה טקסט בממשק המשתמש שלי.

761
00:40:59,000 --> 00:41:03,000
עכשיו כשאני לוחץ זה אני יכול להתחיל להקליד.

762
00:41:03,000 --> 00:41:06,000
עכשיו אם אני לוחץ על הכפתור עשה זה הולך לירות

763
00:41:06,000 --> 00:41:08,000
אירוע שכעת אני יכול להגיב.

764
00:41:08,000 --> 00:41:10,000
אין טפל באירועים.

765
00:41:10,000 --> 00:41:13,000
ככה אני רק הגבתי ללחצן זה נעשה.

766
00:41:13,000 --> 00:41:15,000
הגיוני?

767
00:41:15,000 --> 00:41:20,000
>> זה לא תבנית עיצוב ש- ייתכן שלא תמצאו את עצמך אי פעם

768
00:41:20,000 --> 00:41:23,000
יצירת פרוטוקול משלך, אבל שתדע כמה

769
00:41:23,000 --> 00:41:27,000
רכיבי iOS שונים לרשום אירועים בדרכים שונות.

770
00:41:27,000 --> 00:41:29,000
כפתורים, למשל, להשתמש בIBActions אלה.

771
00:41:29,000 --> 00:41:32,000
שדות טקסט, לעומת זאת, הולכים להשתמש בצירים.

772
00:41:32,000 --> 00:41:36,000
אנחנו יכולים לראות ואתה יכול להסתכל כל זה בתוך מהתיעוד.

773
00:41:36,000 --> 00:41:41,000
דרך אגב, יש בעצם טון של חומר UI הבנוי לתוך iOS בשבילך,

774
00:41:41,000 --> 00:41:46,000
כך לדוגמה, הדרך שעשיתי שאמרו כל כבוד בפינה הימנית התחתונה

775
00:41:46,000 --> 00:41:48,000
הוא בחרתי שדה הטקסט הזה.

776
00:41:48,000 --> 00:41:50,000
אני באתי לכאן.

777
00:41:50,000 --> 00:41:53,000
אני גללתי למטה קצת לחזור מפתח,

778
00:41:53,000 --> 00:41:56,000
ואני באמת יכול לעשות את זה חבורה שלמה של דברים, כמו שאם אני רוצה לומר

779
00:41:56,000 --> 00:42:00,000
חירום קורא במקום שאני יכול לעשות את זה, שהוא אקראי לחלוטין,

780
00:42:00,000 --> 00:42:02,000
ואני לא יודע למה יש כפתור שיחת חירום מובנה,

781
00:42:02,000 --> 00:42:06,000
אבל שם, זה אומרת שיחת חירום באותיות קטנות באמת.

782
00:42:06,000 --> 00:42:08,000
הנה לך.

783
00:42:08,000 --> 00:42:12,000
>> בהחלט לחקור את כל אלה אפשרויות השונות בiOS.

784
00:42:12,000 --> 00:42:14,000
כל שאלה על צירים?

785
00:42:14,000 --> 00:42:18,000
שוב, רק תבנית עיצוב מעניינת, כי אתה צריך להיות מודע.

786
00:42:18,000 --> 00:42:22,000
אוקיי, בואו הבא נסתכל על נוף בטבלה.

787
00:42:22,000 --> 00:42:26,000
תצוגת טבלה היא בעצם שהרשימה של פריטים הנמצאת בכל המקום בiOS.

788
00:42:26,000 --> 00:42:29,000
כשאתה מהרפרף דרך כל אנשי הקשר שלך, אתה מסתכל

789
00:42:29,000 --> 00:42:34,000
דף ההגדרה, וזה סוג של רשימה של דברים שנקרא תצוגת שולחן.

790
00:42:34,000 --> 00:42:37,000
יישום תצוגת שולחן בiOS הוא די פשוט.

791
00:42:37,000 --> 00:42:41,000
במקום לעשות בכיתה שיורדת מזה UIViewController

792
00:42:41,000 --> 00:42:44,000
כמו שעשינו לפני שאנחנו פשוט צריכים לומר ולא

793
00:42:44,000 --> 00:42:46,000
הכל UIViewController לא שאני רוצה לעשות,

794
00:42:46,000 --> 00:42:50,000
אני אומר הכול UITableViewController אין אני רוצה לעשות,

795
00:42:50,000 --> 00:42:54,000
כך שפשוט מוסיף כמה דברים נוספים שנעשים לחלוטין עבורנו.

796
00:42:54,000 --> 00:42:58,000
אנחנו צריכים לעשות מעט מאוד בעצם כדי למלא את החסר הפנימי של השולחן.

797
00:42:58,000 --> 00:43:02,000
>> כדי להציג טבלה שאני צריך לענות על כמה שאלות.

798
00:43:02,000 --> 00:43:06,000
השאלה הראשונה שצריך לענות עליה היא כמה חלקים הם בטבלה?

799
00:43:06,000 --> 00:43:08,000
כאשר אתה מדפדף ביישום אנשי הקשר שלך תוכל להבחין כי זה סוג של

800
00:43:08,000 --> 00:43:12,000
מאורגן על ידי כ, אז יש לך ארוחת בוקר, ויש לך שכותרת המשנה קטנה.

801
00:43:12,000 --> 00:43:14,000
כל אחד מאלה נקרא סעיף.

802
00:43:14,000 --> 00:43:16,000
אתה יכול או לא תזדקק לזה.

803
00:43:16,000 --> 00:43:19,000
הדבר הראשון שאתה צריך לעשות הוא ליישם שיטה

804
00:43:19,000 --> 00:43:22,000
קרא tableView: numberOfSectionsInTableView.

805
00:43:22,000 --> 00:43:25,000
זה פשוט מחזיר כמה סעיפים שיש לך,

806
00:43:25,000 --> 00:43:29,000
אז זה יכול להחזיר אחת אומר אם יש לך תצוגת שולחן אחד גדולה.

807
00:43:29,000 --> 00:43:33,000
השאלה הבאה שiOS צריך לדעת היא כמה שורות יש לך?

808
00:43:33,000 --> 00:43:36,000
לדוגמה, אתה מדפדף בתצוגת טבלה.

809
00:43:36,000 --> 00:43:39,000
יש לך מספר קבוע של שירים אתה מסתכל או מספר קבוע של אנשי קשר.

810
00:43:39,000 --> 00:43:41,000
אם אתה אותי, כמובן, לא רב,

811
00:43:41,000 --> 00:43:44,000
ואז ככה iOS יודע כמה תאים להצגה.

812
00:43:44,000 --> 00:43:46,000
>> שוב, זה יכול להגיד משהו כמו תשואה 3.

813
00:43:46,000 --> 00:43:49,000
תצוגת שולחני יש 3 שורות.

814
00:43:49,000 --> 00:43:52,000
לבסוף, iOS צריך לדעת מה כל תא נראה,

815
00:43:52,000 --> 00:43:54,000
אז מה זה בעצם הולך לעשות זה להתקשר שיטה זו כאן,

816
00:43:54,000 --> 00:43:57,000
tableView זה: cellForRowAtIndexPath.

817
00:43:57,000 --> 00:44:01,000
זה הולך לקרוא לשיטה זו בכל תא ותא בתוך הטבלה שלך.

818
00:44:01,000 --> 00:44:03,000
איך הוא יודע כמה פעמים לקרוא לזה?

819
00:44:03,000 --> 00:44:06,000
ובכן, אמר לו בתוך מספר השורות בקטע.

820
00:44:06,000 --> 00:44:08,000
אנחנו הולכים לקרוא לזה בכל אחד מהתאים שלנו,

821
00:44:08,000 --> 00:44:11,000
ובתוך זה שבו אתה באמת יכול לעשות דברים כמו

822
00:44:11,000 --> 00:44:16,000
להגדיר את הטקסט או להגיד לך מה שהכפתור הכחול הקטן בצד ימין עושה.

823
00:44:16,000 --> 00:44:19,000
הדפוס להשגת תאים אלה, אנחנו הולכים להשתמש בשיטה זו

824
00:44:19,000 --> 00:44:22,000
קרא dequeueReusableCellWithIdentifier.

825
00:44:22,000 --> 00:44:29,000
>> Objective-C היא למעשה מאוד ידוע לאורך המגוחך של שמות שיטתם,

826
00:44:29,000 --> 00:44:32,000
וזה באמת מקרה נחמד בדוגמא נקודה.

827
00:44:32,000 --> 00:44:37,000
מה עושה בשיטה זו הוא זה רק אומר שאני רוצה שתתן לי תא.

828
00:44:37,000 --> 00:44:39,000
רק דבר iOS.

829
00:44:39,000 --> 00:44:41,000
אם יש לך משהו כמו 100.000 שירים ב-iPod

830
00:44:41,000 --> 00:44:45,000
מה iOS לא רוצה לעשות הוא להקצות 100.000 תאים,

831
00:44:45,000 --> 00:44:48,000
כי אם אתה בראש הרשימה שלך, האם אתה באמת צריך להקצות זיכרון

832
00:44:48,000 --> 00:44:51,000
לתא זה 99000 שורות למטה?

833
00:44:51,000 --> 00:44:55,000
לא, כי כמו שאתה גלילה אתה יכול להקצות סוג של כמו שאתה הולך יחד.

834
00:44:55,000 --> 00:44:57,000
זה נעשה בשבילך.

835
00:44:57,000 --> 00:44:59,000
אתה לא צריך לדאוג לכל הדברים האלה ביצועים טפשים.

836
00:44:59,000 --> 00:45:02,000
כל מה שאתה אומר הוא שאתה קורא dequeueReusableCellWithIdentifier שיטה זו,

837
00:45:02,000 --> 00:45:06,000
וזה אומר, בסדר, אם אתה צריך אני הולך ליצור תא חדש עבורך.

838
00:45:06,000 --> 00:45:09,000
>> אבל אם אתה ובחלק התחתון של הטבלה כבר הוקצה כמה תאים

839
00:45:09,000 --> 00:45:12,000
בחלק העליון של הטבלה שאתה ממש לא הולך צריך בזמן קרוב

840
00:45:12,000 --> 00:45:15,000
אני הולך לתת לך אחד מאלה אחוריים במקום הקצאה חדשה,

841
00:45:15,000 --> 00:45:17,000
ואז זה דאגת ביצועים נחמדה.

842
00:45:17,000 --> 00:45:21,000
אתה לא צריך להקצות את התאים בעצמך.

843
00:45:21,000 --> 00:45:23,000
זה הולך לתת לך בחזרה לתא.

844
00:45:23,000 --> 00:45:25,000
זה הולך לחזור אליכם אובייקט תא.

845
00:45:25,000 --> 00:45:28,000
ברגע שיש לך את אובייקט התא אתה יכול לעשות את הדברים אליו.

846
00:45:28,000 --> 00:45:32,000
באפשרותך להגדיר את הטקסט של התא עם מאפיין זה נקרא תווית טקסט.

847
00:45:32,000 --> 00:45:36,000
אתה יכול להוסיף חץ שמצד ימין או כמה דברים אקראיים אחרים

848
00:45:36,000 --> 00:45:41,000
עם הרכוש האחר הזה שנקרא accessoryType, וכן הלאה וכן הלאה.

849
00:45:41,000 --> 00:45:46,000
>> בואו נסתכל על יישום תצוגת שולחן עכשיו ממש.

850
00:45:46,000 --> 00:45:49,000
כשיצרתי את הפרויקט הזה

851
00:45:49,000 --> 00:45:53,000
במקום לומר יישום תצוגה יחידה שהגעתי דווקא לכאן

852
00:45:53,000 --> 00:45:57,000
לבקשת אב - פרטים, ואז בעצם זה מתאים ליישום האלקטרוני

853
00:45:57,000 --> 00:46:01,000
באייפד עם תצוגת השולחן בצד השמאל ולאחר מכן את התוכן בצד ימין.

854
00:46:01,000 --> 00:46:07,000
ב-iPod או iPhone זה הולך מתאים לתצוגת שולחן אחד.

855
00:46:07,000 --> 00:46:10,000
כי שם קבלתי את קוד המתנע שלי.

856
00:46:10,000 --> 00:46:13,000
>> בואו נסתכל על לוח התכנון ראשון.

857
00:46:13,000 --> 00:46:15,000
כל זה נעשה בשבילי, בעצם נוצר.

858
00:46:15,000 --> 00:46:18,000
סרגל ניווט זה הראה לי מה תא דוגמה יכול להיראות כמו,

859
00:46:18,000 --> 00:46:22,000
ואני יכול ללחוץ את זה, לשנות את הכותרת.

860
00:46:22,000 --> 00:46:25,000
כל חששות UI אחרים אני יכול להתמודד שם.

861
00:46:25,000 --> 00:46:27,000
קובץ הכותרת נראה ממש פשוט.

862
00:46:27,000 --> 00:46:30,000
במקום לומר זה UIViewController עכשיו אתה אומר זה

863
00:46:30,000 --> 00:46:35,000
TableViewController, כך שאנחנו יודעים שאנחנו רוצים לקרוא לכל השיטות הללו בטבלה.

864
00:46:35,000 --> 00:46:38,000
הבא אני רוצה ליצור נכס שהולך לייצג את

865
00:46:38,000 --> 00:46:40,000
גם הדברים בשולחן שלי.

866
00:46:40,000 --> 00:46:43,000
שולחן זה הולך באופן שרירותי כדי להציג

867
00:46:43,000 --> 00:46:46,000
רשימה של פרי, ולכן אני צריך ליצור כמה מערך

868
00:46:46,000 --> 00:46:49,000
שבו אני יכול להכניס פרות.

869
00:46:49,000 --> 00:46:52,000
בתוך קובץ היישום שלי הדבר הראשון שאני רוצה לעשות

870
00:46:52,000 --> 00:46:55,000
הוא שאני רוצה לוודא שאני לאתחל מערך זה.

871
00:46:55,000 --> 00:46:58,000
>> אמרתי alloc init, יצרתי מערך פריי,

872
00:46:58,000 --> 00:47:03,000
ואני מוסיף 4 דברים אליו, שאחד מהם הוא הרבה יותר שנוי במחלוקת מ3 האחרים.

873
00:47:03,000 --> 00:47:06,000
ועכשיו יש לי מערך בגודל 4.

874
00:47:06,000 --> 00:47:08,000
אנחנו לוחצים אותו בCS50.

875
00:47:08,000 --> 00:47:11,000
עכשיו יש לי מערך בגודל 4.

876
00:47:11,000 --> 00:47:13,000
עכשיו אני הולך להתחיל לענות על שאלות אלה, ובעצם,

877
00:47:13,000 --> 00:47:16,000
כשיצרתי את היישום הזה כל זה כבר עשה בשבילי.

878
00:47:16,000 --> 00:47:19,000
לא היה לי להקליד את מספר הסעיפים בתצוגת טבלה.

879
00:47:19,000 --> 00:47:22,000
זה כבר היה שם, ואני ממלא את החסר.

880
00:47:22,000 --> 00:47:24,000
כמה מקטעים יש לי?

881
00:47:24,000 --> 00:47:26,000
אחד. הכל נעשה.

882
00:47:26,000 --> 00:47:28,000
כמה שורות יש לי?

883
00:47:28,000 --> 00:47:31,000
ובכן, יש לי שורה אחת לכל פרי, ולכן ספירה זו

884
00:47:31,000 --> 00:47:34,000
הוא רכושו של כל מערך שאומר כמה גדול הוא?

885
00:47:34,000 --> 00:47:36,000
זה כמה שורות שיש לי.

886
00:47:36,000 --> 00:47:42,000
לבסוף, אני צריך לומר מה כל תא נראה?

887
00:47:42,000 --> 00:47:46,000
אני הולך לומר dequeueReusableCellWithIdentifier.

888
00:47:46,000 --> 00:47:48,000
>> שוב, זה כבר נכתב בשבילי.

889
00:47:48,000 --> 00:47:51,000
אני לא צריך לעשות את זה בעצמי, ואני רוצה לחזור

890
00:47:51,000 --> 00:47:54,000
תא זה במיקום זה.

891
00:47:54,000 --> 00:47:57,000
זכור שאנחנו קוראים באותה שיטה כל תא ותא,

892
00:47:57,000 --> 00:48:01,000
וזה ויכוח כאן, ויכוח indexPath זה,

893
00:48:01,000 --> 00:48:03,000
מה אומר שורה אני בפנים

894
00:48:03,000 --> 00:48:05,000
אם אני אומר indexPath.row כאן

895
00:48:05,000 --> 00:48:09,000
זה יהיה 0, ואז זה יהיה 1, ואז זה יהיה 2, וזה כל כך אני יודע

896
00:48:09,000 --> 00:48:11,000
מה תא אני כרגע הצגה.

897
00:48:11,000 --> 00:48:15,000
אני רוצה להגדיר את הטקסט של התא באמצעות מאפיין זה textLabel

898
00:48:15,000 --> 00:48:19,000
ללכת בתוך מערך הפרות שלי ולקבל

899
00:48:19,000 --> 00:48:21,000
האובייקט המתאים לכל שורה.

900
00:48:21,000 --> 00:48:24,000
אם זה חוט, אני עכשיו הגדרה

901
00:48:24,000 --> 00:48:28,000
מאפיין הטקסט למחרוזת.

902
00:48:28,000 --> 00:48:30,000
אני יכול לעשות עוד דבר אחד.

903
00:48:30,000 --> 00:48:32,000
אני גם יכול לרשום טיפול באירועים בכל אחד מהתאים,

904
00:48:32,000 --> 00:48:35,000
ולכן כאשר אני נוקש כל אחד מהתאים האלה

905
00:48:35,000 --> 00:48:39,000
didSelectRowAtIndexPath זה, זה הולך להיות שם עבורי,

906
00:48:39,000 --> 00:48:42,000
כל כך פשוט על ידי ההגדרה הזו אני יכול להתמודד עם מה שקורה עכשיו

907
00:48:42,000 --> 00:48:46,000
כאשר תקישו על תא, ושוב, אנחנו עוברים שבתא היה האזנה

908
00:48:46,000 --> 00:48:50,000
כדי שנוכל לעשות שימוש חוזרים באותו מטפל אירוע זה לכל התאים שלנו.

909
00:48:50,000 --> 00:48:53,000
>> שוב, זה משהו iOS עושה בשבילי.

910
00:48:53,000 --> 00:48:55,000
בואו להציג עוד קופץ מעצבנת

911
00:48:55,000 --> 00:48:59,000
זה פשוט אומר שבחרת בו משהו שמשהו

912
00:48:59,000 --> 00:49:04,000
הולך להיות אובייקט השורה.

913
00:49:04,000 --> 00:49:10,000
כאשר אני מפעיל את זה, אני הולך להיות תצוגת שולחן זה נחמד

914
00:49:10,000 --> 00:49:14,000
בשורה אחת עבור כל אחד מפרות אלה, ואם אני מקיש 1

915
00:49:14,000 --> 00:49:16,000
זה אומר לי מה קרה.

916
00:49:16,000 --> 00:49:21,000
הגיוני?

917
00:49:21,000 --> 00:49:24,000
בואו נבנה קצת יותר מורכב של יישום,

918
00:49:24,000 --> 00:49:28,000
ככל שהלחיצה הרימה עגבנייה.

919
00:49:28,000 --> 00:49:31,000
חלק נחמד על storyboarding

920
00:49:31,000 --> 00:49:35,000
הוא שזה לא רק יעזור לנו מסכי עיצוב בנפרד,

921
00:49:35,000 --> 00:49:38,000
זה גם יעזור לנו לקשור יחד את כל האפליקציה שלנו,

922
00:49:38,000 --> 00:49:42,000
כך האפליקציה הסופית אהיה בניין זה נחמד ספורט קורא חדשות,

923
00:49:42,000 --> 00:49:45,000
ואז זה הולך ליש מסכים מרובה, ולכן אני בעצם יכול לייצג

924
00:49:45,000 --> 00:49:48,000
כל אחד ממסכים המרובים אלה בלוח התכנון,

925
00:49:48,000 --> 00:49:52,000
ואני יכול להקטין את התצוגה ולראות האפליקציה שלי מרמה גבוהה.

926
00:49:52,000 --> 00:49:55,000
>> על מנת ליצור בתוך אלמנט חדש של לוח התכנון שלי

927
00:49:55,000 --> 00:49:59,000
זה ממש פשוט בתוך ממשק קבלן.

928
00:49:59,000 --> 00:50:01,000
אם אני רוצה להוסיף מסך נוסף לזה, לדוגמה,

929
00:50:01,000 --> 00:50:06,000
אני יכול להקטין את התצוגה ראשונה עם זום הקמצוץ כי אפל אוהב כל כך הרבה,

930
00:50:06,000 --> 00:50:09,000
וכאן לפני שאחפש כפתור

931
00:50:09,000 --> 00:50:12,000
ואני לגרור ולשחרר כפתור

932
00:50:12,000 --> 00:50:15,000
אם אני רוצה ליצור רשת חדשה שבעצם יכול פשוט לגרור ולשחרר

933
00:50:15,000 --> 00:50:19,000
בקר נוף כולו, כך שאם אני לוקח את זה, מושך אותו לכאן,

934
00:50:19,000 --> 00:50:23,000
היי, יש מסך אחר, ואז עכשיו משתמש באותו קובץ לוח תכנון זה

935
00:50:23,000 --> 00:50:26,000
אני יכול לקבל את כל המסכים בתוך האפליקציה שלי, ואני יכול להקטין את התצוגה

936
00:50:26,000 --> 00:50:28,000
ולראות כיצד הם פועלים.

937
00:50:28,000 --> 00:50:32,000
אלה לא יהיו אינטראקציה עדיין.

938
00:50:32,000 --> 00:50:36,000
אופן שבו 2 המסכים האלה הוא אינטראקציתך להגדיר קשרי גומלין.

939
00:50:36,000 --> 00:50:39,000
אתה בעצם יכול לומר מסך זה, כאשר אתה לוחץ על כפתור זה,

940
00:50:39,000 --> 00:50:42,000
אני רוצה שמחליק מעל למסך החדש.

941
00:50:42,000 --> 00:50:44,000
זה אומר שיש סוג כזה של יחסים בין

942
00:50:44,000 --> 00:50:46,000
 המסך הראשון והמסך השני.

943
00:50:46,000 --> 00:50:49,000
יהיה לך חץ מכפתור למסך השני בעצם

944
00:50:49,000 --> 00:50:53,000
אומר שכשאתם לוחצים על כפתור זה ששם אני רוצה ללכת.

945
00:50:53,000 --> 00:50:57,000
בדיוק כמו שאנחנו שליטה לחצנו וגררנו להגדיר שקעים אלה

946
00:50:57,000 --> 00:51:01,000
אנחנו הולכים לעשות את אותו דבר להגדרת segues אלה.

947
00:51:01,000 --> 00:51:05,000
>> נראים דוגמה לכך, ולפני שאנחנו בעצם מעבר

948
00:51:05,000 --> 00:51:08,000
ממסך אחד למשנה iOS הוא נחמד מספיק כדי לקרוא לשיטה זו

949
00:51:08,000 --> 00:51:11,000
קרא prepareForSegue, וזה שבו אנחנו יכולים להתחיל

950
00:51:11,000 --> 00:51:14,000
שליחת נתונים מיישום אחד למשנו.

951
00:51:14,000 --> 00:51:17,000
בדוגמא שאנחנו עומדים מסתכלים על זה יהיה בעצם לאפשר לנו

952
00:51:17,000 --> 00:51:20,000
כדי לסנן קבוצות בייסבול בליגות ופיצולים.

953
00:51:20,000 --> 00:51:23,000
כאשר אני בוחר את הליגה, לדוגמה, אני רוצה מעבר

954
00:51:23,000 --> 00:51:25,000
למסך הבא שבו אני יכול להציג את כל החטיבות

955
00:51:25,000 --> 00:51:27,000
בליגה הזאת או כל הצוותות השונים.

956
00:51:27,000 --> 00:51:31,000
אני צריך לשלוח לאותו מסך מה אתה צריך להציג צוותות.

957
00:51:31,000 --> 00:51:35,000
כדי לעשות את זה אני הולך לנצל את השיטה הזאת כאן.

958
00:51:35,000 --> 00:51:39,000
>> לבסוף, רק נקודה אקראית על iOS.

959
00:51:39,000 --> 00:51:41,000
אם ברצונך לאחסן את הנתונים יש הדבר הזה שנקרא נתוני ליבה,

960
00:51:41,000 --> 00:51:44,000
שהוא למעשה סוג של מסובך לעבוד איתו.

961
00:51:44,000 --> 00:51:47,000
אתה יכול גם להשתמש ב-SQL לאחסון נתונים,

962
00:51:47,000 --> 00:51:51,000
ששוב, הוא נחמד, אבל סוג של בצד המסובך יותר לעבוד איתו,

963
00:51:51,000 --> 00:51:55,000
אבל iOS תומך גם דברים ממש מגניבים שנקראים רשימות רכוש,

964
00:51:55,000 --> 00:52:00,000
ורשימת רכוש היא רק קובץ שמייצג זוגות ערך מרכזיים.

965
00:52:00,000 --> 00:52:03,000
אתה מגדיר רשימה של מפתחות, ואתה אומר את המפתח הזה הולך להיות מערך.

966
00:52:03,000 --> 00:52:06,000
מפתח זה הולך להיות מחרוזת, ובעצם כל דבר שאתה יכול לעשות

967
00:52:06,000 --> 00:52:10,000
בJSON אתה יכול לעשות בתוך רשימת רכוש,

968
00:52:10,000 --> 00:52:14,000
ואז זה באמת יפה מאפשר לנו לעבוד עם נתונים מסוימים.

969
00:52:14,000 --> 00:52:18,000
לדוגמה, יש לי Teams.plist זה שאני יצרתי.

970
00:52:18,000 --> 00:52:22,000
אני יצרתי קובץ plist חדש, ואני יכול להסתעף.

971
00:52:22,000 --> 00:52:26,000
זהו מילון, זה מילון, אלה הם מחרוזות,

972
00:52:26,000 --> 00:52:30,000
ואז זה ייצוג גרפי נחמד של מסמך JSON

973
00:52:30,000 --> 00:52:33,000
או סתם אוסף של זוגות ערכי מפתח,

974
00:52:33,000 --> 00:52:37,000
ואז זה את הנתונים שאני אעבוד עם האפליקציה פנימית שלי.

975
00:52:37,000 --> 00:52:40,000
>> בואו נבוא לכאן לראשונה. יש לנו הרבה יותר קבצים עכשיו.

976
00:52:40,000 --> 00:52:44,000
אבל בואו נבוא לכאן לראשונה ללוח התכנון.

977
00:52:44,000 --> 00:52:48,000
לוח התכנון כאן, ואם אני יכול להקטין את התצוגה,

978
00:52:48,000 --> 00:52:51,000
עכשיו אנחנו יכולים לראות שזה הוא הזרימה של האפליקציה שלי.

979
00:52:51,000 --> 00:52:53,000
אני נוסע תחילה להתחיל במסך זה.

980
00:52:53,000 --> 00:52:55,000
אני הולך לתחקור מטה למסך הזה,

981
00:52:55,000 --> 00:52:58,000
ואני הולך לתחקור מטה למסך הזה, ואנחנו יכולים לראות כאן שאם אני סוג של

982
00:52:58,000 --> 00:53:04,000
להזיז אחד מאלה שסביב החצים הללו הולכים מכאן לכאן,

983
00:53:04,000 --> 00:53:08,000
וכפי שאני מגדיר את החץ שהיה אם אני להתקרב קצת,

984
00:53:08,000 --> 00:53:12,000
אם נבוא לבקר השקפה זו ו,

985
00:53:12,000 --> 00:53:16,000
והנה תא, ואני רוצה לומר שכאשר אתה מקיש תא

986
00:53:16,000 --> 00:53:18,000
אני רוצה שמחליק מעל למסך אחר.

987
00:53:18,000 --> 00:53:21,000
אני פשוט יכול להחזיק את השליטה,

988
00:53:21,000 --> 00:53:26,000
לגלול על קצת, החזק את מקש שליטה, לגרור את התא הזה ולהרפות.

989
00:53:26,000 --> 00:53:30,000
>> וכאן אנחנו אומרים מה המעבר שברצונך להשתמש?

990
00:53:30,000 --> 00:53:32,000
האם אתה רוצה להשתמש שבשקופית דבר שנקרא לדחוף?

991
00:53:32,000 --> 00:53:34,000
האם אתה רוצה להחליק למעלה מהתחתית?

992
00:53:34,000 --> 00:53:36,000
זה נקרא מודאלית.

993
00:53:36,000 --> 00:53:40,000
וברגע שאני לוחץ על אחד מאלה, זה הולך לצייר את החץ הזה בשבילי,

994
00:53:40,000 --> 00:53:44,000
וזה אומר שגם אני מתייחס למה שקורה בפועל כאשר אני לוחץ על כפתור זה בצורה גרפית.

995
00:53:44,000 --> 00:53:48,000
אני לא כתבתי את כל קוד למעשה להחליק ממסך אחד לאחד הבא.

996
00:53:48,000 --> 00:53:51,000
אני הגדרתי את זה בתוך חזותי של ממשק קבלן.

997
00:53:51,000 --> 00:53:55,000
אם אני לוחץ על החץ הזה, אנו יכולים לראות שנתתי את הדבר הזה שם.

998
00:53:55,000 --> 00:53:59,000
אני קראתי לזה showDivisions, וזה כל כך שאני יכול לדעת

999
00:53:59,000 --> 00:54:03,000
מה מעבר עומד להתרחש, ואנו רואים במה רק לשנייה.

1000
00:54:03,000 --> 00:54:06,000
ככה אני חוטית את המסכים השונה ביישום שלי.

1001
00:54:06,000 --> 00:54:09,000
אם זה היה כפתור, לדוגמה, במקום תצוגת שולחן,

1002
00:54:09,000 --> 00:54:11,000
אני יכול לשלוט ללחוץ על הכפתור, גרר מעל למסך הבא,

1003
00:54:11,000 --> 00:54:16,000
וככה אני יכול לעשות את זה דרך ניווט.

1004
00:54:16,000 --> 00:54:19,000
>> מהר מאוד, אם אנחנו באים לMasterViewController,

1005
00:54:19,000 --> 00:54:22,000
שוב, אנחנו פשוט הולכים להגדיר רשימה של דברים

1006
00:54:22,000 --> 00:54:26,000
שיוצג בתצוגת הטבלה.

1007
00:54:26,000 --> 00:54:29,000
כאן אני אומר שאני רוצה שתיקח אותו קובץ plist,

1008
00:54:29,000 --> 00:54:32,000
ואני רוצה אותך לטעון אותו למילון,

1009
00:54:32,000 --> 00:54:35,000
וברגע שיש לך מילון ש, אני הולך לענות את אותן שאלות שוב.

1010
00:54:35,000 --> 00:54:37,000
הנה מספר הקטעים.

1011
00:54:37,000 --> 00:54:41,000
אחד, יש שורה אחת עבור כל ליגה, ואת הטקסט של כל תא

1012
00:54:41,000 --> 00:54:46,000
צריך להיות ראשון, הליגה הראשונה, הליגה השנייה, וכן הלאה.

1013
00:54:46,000 --> 00:54:51,000
לבסוף, אני הולך להשתמש בשיטה זו שראינו הרגע קראה prepareForSegue,

1014
00:54:51,000 --> 00:54:54,000
וזו היא השיטה שהולכת להיות מפוטרים כאשר אני לוחץ

1015
00:54:54,000 --> 00:54:57,000
באחת מהשורות אלו, ולכן הפעלת מעבר ש

1016
00:54:57,000 --> 00:54:59,000
שאקים עם החצים.

1017
00:54:59,000 --> 00:55:02,000
זה אומר שאני יכול להיות מרובה

1018
00:55:02,000 --> 00:55:05,000
יחסים בין מסך אחד למשנו.

1019
00:55:05,000 --> 00:55:08,000
אם יש לי 2 כפתורים וכל כפתור יעביר אותך למסך אחר

1020
00:55:08,000 --> 00:55:10,000
אני הולך להיות 2 segues, 1 לכל כפתור.

1021
00:55:10,000 --> 00:55:14,000
אבל prepareForSegue זה הוא, שוב, הולך לשימוש חוזר

1022
00:55:14,000 --> 00:55:17,000
לכל אחת ממערכות היחסים השונים, אז זה אומר שאני צריך דרך

1023
00:55:17,000 --> 00:55:21,000
זיהוי אם אתה לוחץ על הכפתור הראשון, או שתלחץ על הכפתור השני.

1024
00:55:21,000 --> 00:55:25,000
>> זוכר שנתתי את הקונצרט ששם, זה showDivisions,

1025
00:55:25,000 --> 00:55:29,000
ככה שאני יודע עכשיו שזה על העניים שהופעלו.

1026
00:55:29,000 --> 00:55:32,000
כל מה שאני רוצה לעשות זה שאני רוצה להגיד

1027
00:55:32,000 --> 00:55:35,000
אני רוצה להבין מה בדיוק פגעתי,

1028
00:55:35,000 --> 00:55:38,000
וכך לקבל את זה, אני יכול להגיד שאני רוצה indexPath לשורה הנבחרת,

1029
00:55:38,000 --> 00:55:42,000
זוכר את indexPath רק אומר שבו אני פשוט לוחץ,

1030
00:55:42,000 --> 00:55:47,000
ואז אני רוצה לומר שאני רוצה להבין איפה אני עומד.

1031
00:55:47,000 --> 00:55:50,000
destinationViewController זה, זה רכושו של הרצף.

1032
00:55:50,000 --> 00:55:53,000
זה המסך שאני עומד,

1033
00:55:53,000 --> 00:55:56,000
אז אני יודע שהמסך אני הולך נקרא DivisionsViewController

1034
00:55:56,000 --> 00:55:59,000
משום שאני יצרתי מעמד ש,

1035
00:55:59,000 --> 00:56:02,000
ואז עכשיו אם אני אומר d.divisions

1036
00:56:02,000 --> 00:56:06,000
אני עכשיו הגדרת רכוש של בקר הנוף שאני עומד לעבור.

1037
00:56:06,000 --> 00:56:10,000
זה איך אני שולח נתונים ממסך אחד למסך אחר.

1038
00:56:10,000 --> 00:56:13,000
>> פשוט מסתכל על זה DivisionsViewController

1039
00:56:13,000 --> 00:56:16,000
אתם יכולים לראות כאן שב. קובץ h

1040
00:56:16,000 --> 00:56:20,000
יש שחטיבות הקניין, וזה מה שבעצם אני אכלוס,

1041
00:56:20,000 --> 00:56:25,000
אז ככה אני יודע שאני מציג את החטיבות המקבילות ל

1042
00:56:25,000 --> 00:56:28,000
הליגה שאני לוחץ, ושוב,

1043
00:56:28,000 --> 00:56:31,000
תצוגת השולחן בפועל נראית פחות או יותר אותו הדבר, רק עונה אלה

1044
00:56:31,000 --> 00:56:34,000
3 שאלות פשוטות, כמו גם זיהוי

1045
00:56:34,000 --> 00:56:37,000
מה קורה כאשר אתה עובר למסך הבא.

1046
00:56:37,000 --> 00:56:40,000
רק כמה דברים אחרים כאן.

1047
00:56:40,000 --> 00:56:43,000
שמתם לב שבחלק העליון כאן שבמקום לומר # כולל

1048
00:56:43,000 --> 00:56:45,000
עכשיו אני אומר # לייבא.

1049
00:56:45,000 --> 00:56:47,000
זה פשוט דבר Objective-C.

1050
00:56:47,000 --> 00:56:52,000
היבוא הוא בעצם גרסה יותר נחמדה מכולל,

1051
00:56:52,000 --> 00:56:57,000
ולדוגמה, אנחנו צריכים לדעת מה המעמד הזה הוא,

1052
00:56:57,000 --> 00:57:00,000
אז אני לא יכול פשוט להגיד DivisionsViewController.

1053
00:57:00,000 --> 00:57:05,000
אם לא הייתי בתוך hashtag standardio.c של. קובץ C שלנו

1054
00:57:05,000 --> 00:57:07,000
המהדר לא היה מושג מה היה printf.

1055
00:57:07,000 --> 00:57:12,000
בדומה לכך, אם אני לא לייבא DivisionsViewController

1056
00:57:12,000 --> 00:57:16,000
המהדר באמת אין לו מושג מה הוא DivisionsViewController.

1057
00:57:16,000 --> 00:57:19,000
רק לוודא שיש בתוך הקבצים מ שונים. לך לוודא לייבא

1058
00:57:19,000 --> 00:57:25,000
את קבצי h המתאימים. כך שהמהדר יודע מה קורה.

1059
00:57:25,000 --> 00:57:31,000
>> לבסוף, מה שאפל סופו של דבר עושה הוא להציג כמה נתונים באמצעות תצוגת אינטרנט,

1060
00:57:31,000 --> 00:57:35,000
וכן תצוגת אינטרנט היא אובייקט שבו אתה יכול להטביע

1061
00:57:35,000 --> 00:57:37,000
דפדפן אינטרנט קטן בתוך היישום שלך.

1062
00:57:37,000 --> 00:57:40,000
כל מה שאתה צריך לעשות הוא לספק כתובת אתר לדפדפן האינטרנט שלך,

1063
00:57:40,000 --> 00:57:43,000
אז אני רוצה ללכת לmlb.mlb.com,

1064
00:57:43,000 --> 00:57:46,000
וזה איך אני יכול לגשת לדף הבית לכל צוות,

1065
00:57:46,000 --> 00:57:49,000
וזאת על ידי ההעברה בכתובת זו

1066
00:57:49,000 --> 00:57:52,000
תצוגת האינטרנט יכול להציג את זה בשבילי, ואני יכול לגלוש בסביבה,

1067
00:57:52,000 --> 00:58:01,000
סימולטור ונמצא בשימוש על ידי זה.

1068
00:58:01,000 --> 00:58:03,000
עכשיו זה הגיע מplist.

1069
00:58:03,000 --> 00:58:07,000
אם אני לוחץ על זה זה גם בא מplist, וזזה זה טופלה

1070
00:58:07,000 --> 00:58:09,000
על ידי הגדרת segues אלה.

1071
00:58:09,000 --> 00:58:12,000
אני לוחץ על זה ועוד אחד,

1072
00:58:12,000 --> 00:58:15,000
ועכשיו הוא כאן UIWebView, כל כך פשוט כמו ש

1073
00:58:15,000 --> 00:58:19,000
הנה האתר לכתובת האתר שאני פשוט משובץ,

1074
00:58:19,000 --> 00:58:21,000
ולא היה לי להתמודד עם כל דבר מטורף.

1075
00:58:21,000 --> 00:58:24,000
זה איך להציג דף אינטרנט.

1076
00:58:24,000 --> 00:58:27,000
דברים כמו כפתור חזרה זה כאן גם ניתנו לי

1077
00:58:27,000 --> 00:58:33,000
לגמרי בחינם בגלל שהגדרתי את הקשרים הללו באמצעות segues.

1078
00:58:33,000 --> 00:58:37,000
>> יש שאלות? כן.

1079
00:58:37,000 --> 00:58:40,000
[סטודנטים] לכן, כאשר אתה משתמש alloc, אתה לא צריך שום דבר בחינם?

1080
00:58:40,000 --> 00:58:43,000
בדיוק, כאשר אתה קורא alloc וinit אתה לא צריך לשחרר אותו.

1081
00:58:43,000 --> 00:58:46,000
IOS הולך להתמודד עם כל זה בשבילך.

1082
00:58:46,000 --> 00:58:51,000
זה נפלא, ואתה לא שובר את כל כללים. כן.

1083
00:58:51,000 --> 00:58:54,000
[סטודנטים] אם היית כולל יותר קבוצות שיכולים להתאים על המסך,

1084
00:58:54,000 --> 00:58:58,000
הייתי זה באופן אוטומטי יש אפשרות גלילה, או משהו שאתה צריך להוסיף?

1085
00:58:58,000 --> 00:59:01,000
בדיוק, אם היה לי יותר צוותות, למשל, זה יהיה באופן אוטומטי להתמודד

1086
00:59:01,000 --> 00:59:04,000
הגלילה בשבילי, ואת כל חששות ביצועים

1087
00:59:04,000 --> 00:59:08,000
עם השולחן הענק מטופלים גם לגמרי בשבילי.

1088
00:59:08,000 --> 00:59:11,000
>> שאלות אחרות?

1089
00:59:11,000 --> 00:59:13,000
כל קוד שזה הולך להתפרסם.

1090
00:59:13,000 --> 00:59:16,000
אנחנו סוג של טושטשנו מעט את הפרטים הקטנים יותר,

1091
00:59:16,000 --> 00:59:19,000
אבל דברים כמו הגדרת מאפיינים מסוימים לאינטרנט הנוף

1092
00:59:19,000 --> 00:59:22,000
רק דברים שאתה יכול להשיג על ידי גלישת התיעוד של אפל,

1093
00:59:22,000 --> 00:59:24,000
שהוא באמת, באמת מסודר יפה.

1094
00:59:24,000 --> 00:59:27,000
יש להם הרבה של יישומים ושימושים לדוגמא דוגמה

1095
00:59:27,000 --> 00:59:34,000
של APIs השונה, אז בהחלט לעיין אלה אם אתה יכול.

1096
00:59:34,000 --> 00:59:36,000
רק כמה קישורים מועילים אולי כדאי לך להעיף מבט.

1097
00:59:36,000 --> 00:59:38,000
אלו הן כמה מדריכים שימושיים תיעוד.

1098
00:59:38,000 --> 00:59:41,000
את הכתובות הן מסיביות, אז הם קצרו.

1099
00:59:41,000 --> 00:59:44,000
הראשון זה כל הספרייה של תיעוד.

1100
00:59:44,000 --> 00:59:46,000
יש סורגי חיפוש קטנים, כך שאם אתה מתחיל כפתור הקלדה

1101
00:59:46,000 --> 00:59:50,000
הוא יתחיל לתת לך את כל המידע על כל הדברים שאתה יכול לעשות עם כפתור.

1102
00:59:50,000 --> 00:59:53,000
צרפתי גם מדריך תכנות צפו בטבלה.

1103
00:59:53,000 --> 00:59:56,000
הוא מטפל בנופי שולחן בפירוט רב יותר,

1104
00:59:56,000 --> 01:00:00,000
איך לעשות דברים כמו דינמי להוסיף תאים או תאים לערוך או להסיר אותם.

1105
01:00:00,000 --> 01:00:02,000
>> יש המון יישומים לדוגמה מתוך אפל שיראה לך איך לעשות את זה,

1106
01:00:02,000 --> 01:00:05,000
ולבסוף, אחרון זה את הנחיות ממשק אדם,

1107
01:00:05,000 --> 01:00:09,000
וזה בעצם חלק מדיון רכיבי ממשק משתמש,

1108
01:00:09,000 --> 01:00:12,000
דברים כמו לא עושים כפתור זה 4 פיקסלים על 4 פיקסלים.

1109
01:00:12,000 --> 01:00:15,000
זה רעיון לא רע, ודברים אחרים שאפל רוצה שתעשה

1110
01:00:15,000 --> 01:00:18,000
לעודד עיצוב טוב.

1111
01:00:18,000 --> 01:00:23,000
>> כל השאלות האחרונות לפני שאנחנו לסיים כבר?

1112
01:00:23,000 --> 01:00:27,000
בסדר, בהחלט מרגיש חופשי לשיחתנו תהיה לי תוויות מיוחדות על מה לדבר.

1113
01:00:27,000 --> 01:00:30,000
נצטרך iOS אחד, אז בהחלט תרגיש חופשי לנצל את זה.

1114
01:00:30,000 --> 01:00:34,000
אם אתה רוצה לעבוד עם החברים לכיתה שלך על פרויקטים

1115
01:00:34,000 --> 01:00:37,000
או לעזור להבין כמה דברי iOS אקראיים

1116
01:00:37,000 --> 01:00:40,000
תרגיש חופשי לשלוח לי דוא"ל, ובהחלט לעיין בכל הקוד באינטרנט כי

1117
01:00:40,000 --> 01:00:43,000
רק בעניין של זמן שאנחנו סוג של טושטשנו יותר

1118
01:00:43,000 --> 01:00:45,000
פרטים גרעיניים ממוקדים יותר בדברים.

1119
01:00:45,000 --> 01:00:47,000
אבל אם לא, אז מזל טוב על פרויקטי iOS שלך, ואני מקווה שיש לנו

1120
01:00:47,000 --> 01:00:53,000
נהירה גדולה של יישומים ב-App Store.

1121
01:00:53,000 --> 01:00:56,000
[CS50.TV]