1
00:00:00,000 --> 00:00:11,420

2
00:00:11,420 --> 00:00:13,590
>> Tianyu LIU: היי, איך זה
זה הולך כולם?

3
00:00:13,590 --> 00:00:20,250
וזה App iOS
תכנות של סמינר ג האובייקטיבי.

4
00:00:20,250 --> 00:00:21,520
והשם שלי הוא Tianyu ליו.

5
00:00:21,520 --> 00:00:26,114
אני זוטר לואל עכשיו,
להתרכז במדעי מחשב.

6
00:00:26,114 --> 00:00:28,030
אז בסמינר זה אני
הולך ללמד אתכם

7
00:00:28,030 --> 00:00:30,770
קצת על איך לעשות אפליקציה.

8
00:00:30,770 --> 00:00:33,030
Yay, להתרגש על זה.

9
00:00:33,030 --> 00:00:36,790
>> אז לפני שאנחנו אפילו להתחיל לצלול
לצד תכנות בפועל,

10
00:00:36,790 --> 00:00:41,840
בואו פשוט באמת במהירות לדבר על
מדוע ייתכן שתרצה לבנות יישום iOS?

11
00:00:41,840 --> 00:00:43,940
למה הוא כל כך מדהים iOS?

12
00:00:43,940 --> 00:00:47,250
אז הבעיה הראשונה, הראשון
דבר שהוא די מדהים עבורנו,

13
00:00:47,250 --> 00:00:51,190
במיוחד כCS50
סטודנט, הוא שiOS

14
00:00:51,190 --> 00:00:55,860
משתמש Objective C. ובכן, יש
שפה חדשה בשם סוויפט,

15
00:00:55,860 --> 00:00:58,260
אבל אנחנו לא הולכים ל
להשתמש בזה בסמינר זה.

16
00:00:58,260 --> 00:01:01,540
אם אתה מעוניין בסוויפט, שם
הוא סמינר עצמאי על זה.

17
00:01:01,540 --> 00:01:05,590
אבל מטרת C היא בעצם
קבוצה-על של משמעות ג

18
00:01:05,590 --> 00:01:10,230
שכל מה שאתה משתמש ב- C יכול
יתורגם לC Objective

19
00:01:10,230 --> 00:01:11,630
מאוד בקלות.

20
00:01:11,630 --> 00:01:15,730
>> כפי שאפשר לראות בהמשך, כי אכן
יש כמה תחביר בסיסי מאוד, הם

21
00:01:15,730 --> 00:01:19,790
בעצם בדיוק אותו דבר,
C ומטרת C. אז,

22
00:01:19,790 --> 00:01:22,860
מאז שצילמת CS50
עד לכאן, אתה כבר

23
00:01:22,860 --> 00:01:26,500
יודע Objective-C, לפחות 40%.

24
00:01:26,500 --> 00:01:30,720
כמו כן, אפל יש באמת
API חזק עבור iOS.

25
00:01:30,720 --> 00:01:33,750
יש הרבה של ממש מטורף
דברים שאתה יכול לעשות עם זה.

26
00:01:33,750 --> 00:01:36,760
אחד מהם הוא מישהו
למעשה נוצר אפליקציה iOS

27
00:01:36,760 --> 00:01:40,600
למכוניות שליטה, ש
הוא די מעניין.

28
00:01:40,600 --> 00:01:42,610
כנראה מסוק הוא יותר מרגש.

29
00:01:42,610 --> 00:01:47,020
אבל ככה חזק
API iOS יכול להיות.

30
00:01:47,020 --> 00:01:49,340
>> וכפי שאולי יש לי
הבין עכשיו,

31
00:01:49,340 --> 00:01:53,000
הצפת המחסנית היא כנראה אחד
המשאבים מקוונים החשובים ביותר

32
00:01:53,000 --> 00:01:54,250
לרשותך.

33
00:01:54,250 --> 00:01:58,090
וחדשות טובות, לכל
אחת בעיה אולי אתה יכול

34
00:01:58,090 --> 00:02:01,840
חושב עליך בעת הבנייה
פרויקט גמר בObjective-C,

35
00:02:01,840 --> 00:02:05,910
יש סיכוי תשובה הצפת מחסנית.

36
00:02:05,910 --> 00:02:07,420
זה פשוט מדהים.

37
00:02:07,420 --> 00:02:12,780
בנוסף לכך,
iOS הוא באמת פלטפורמה

38
00:02:12,780 --> 00:02:16,260
שבו אתה יכול להגיע ענק
קהל עם מעט מאמץ.

39
00:02:16,260 --> 00:02:20,170
זה לא כמו אנדרואיד, שבו
הכל די מקוטע.

40
00:02:20,170 --> 00:02:22,540
>> הכל iOS הוא אחיד.

41
00:02:22,540 --> 00:02:25,920
וכל עוד אתה יוצר
אפליקציה לאייפון,

42
00:02:25,920 --> 00:02:31,260
אתה יכול מאוד בקלות נמל שלiPad,
iPad mini, או גדלים שונים iPhone.

43
00:02:31,260 --> 00:02:33,050
כל אלה הם ממש נוחים.

44
00:02:33,050 --> 00:02:36,430
וזה פשוט ממש טוב
בכדי להרשים את החברים שלך.

45
00:02:36,430 --> 00:02:38,920
אתה פשוט יכול להחזיק iPhone
ולספר לחבר שלך היי,

46
00:02:38,920 --> 00:02:40,250
זה האפליקציה שאני עושה.

47
00:02:40,250 --> 00:02:43,860
אתה יכול לעשות את זה עבור כל
יישומי שולחן עבודה, וזה נחמד.

48
00:02:43,860 --> 00:02:48,870
>> בסדר, עכשיו בואו ממש מקבלים
לג Objective השפה

49
00:02:48,870 --> 00:02:52,910
אז למה שלא תתחילו עם
כמה באמת תחביר בסיסי.

50
00:02:52,910 --> 00:02:57,410
כפי שציינתי קודם Objective
C זה בעצם על של ג

51
00:02:57,410 --> 00:03:01,860
כל כך הרבה תחביר הבסיסי
למעשה בדיוק אותו הדבר.

52
00:03:01,860 --> 00:03:06,150
הכרזה על משתנה ו
הוספת שני משתנים יחד

53
00:03:06,150 --> 00:03:09,440
בדיוק כפי שעשינו במריו.

54
00:03:09,440 --> 00:03:11,140
שום דבר לא חדש כאן.

55
00:03:11,140 --> 00:03:17,370
>> באופן דומה, הדייר ללולאה
ותנאי הוא גם אותו.

56
00:03:17,370 --> 00:03:22,370
אתה יכול לעשות עבור לולאה בדיוק כפי שאתה
יש לי עשה במריו [לא ברור].

57
00:03:22,370 --> 00:03:26,280
ואתה יכול לעשות תנאים
בדיוק כמו מה שאתה

58
00:03:26,280 --> 00:03:29,240
כבר עושה בסטי p הקודמים שלך.

59
00:03:29,240 --> 00:03:33,400
עם זאת, מטרת C
לא לגמרי C,

60
00:03:33,400 --> 00:03:36,640
ויש משהו ש
הוא סוג של מוזר על זה.

61
00:03:36,640 --> 00:03:42,340
>> להיות ראשון שכאשר אתה
עושה תכנות C, אתה בדרך כלל קורא ל

62
00:03:42,340 --> 00:03:46,310
כולל ולאחר מכן את שם ספרייה.

63
00:03:46,310 --> 00:03:49,860
אבל בC Objective אתה קורא יבוא ש.

64
00:03:49,860 --> 00:03:53,100
בעצם אומר פונקציונלי,
שמות פשוט שונים.

65
00:03:53,100 --> 00:03:55,940
והמחרוזות
למעשה קצת מוזר.

66
00:03:55,940 --> 00:03:58,250
ניתן לראות כי הראשון
דבר שהוא סוג של מוזר

67
00:03:58,250 --> 00:04:04,190
הוא שיש לך די weird--
sorry-- יש לך NS די מוזר

68
00:04:04,190 --> 00:04:04,960
לחתום כאן.

69
00:04:04,960 --> 00:04:07,452

70
00:04:07,452 --> 00:04:09,160
והדבר השני
זה קצת מוזר

71
00:04:09,160 --> 00:04:14,090
הוא שיש לך בסימן לפני
למעשה מכריז על המחרוזת.

72
00:04:14,090 --> 00:04:19,209
אז בסימן יסודו
שמחרוזת היא לא רק מחרוזת,

73
00:04:19,209 --> 00:04:20,880
הוא למעשה אובייקט.

74
00:04:20,880 --> 00:04:22,780
אנחנו הולכים להסביר
שתעשה מאוחר יותר, כדי לא

75
00:04:22,780 --> 00:04:25,800
פאניקה אם לא
להבין מה זה אומר.

76
00:04:25,800 --> 00:04:29,980
והדפסה לקונסולה היא קצת
שונה, כי בC אנו קוראים printf,

77
00:04:29,980 --> 00:04:33,350
אבל בC Objective אנו קוראים [לא ברורים].

78
00:04:33,350 --> 00:04:35,640
>> ייתכן שאתה תוהה מה זה.

79
00:04:35,640 --> 00:04:38,070
זה בעצם printf,
רק בשפה שונה.

80
00:04:38,070 --> 00:04:41,370
בדיוק באותו השימוש,
בדיוק את אותה פונקציונלי.

81
00:04:41,370 --> 00:04:44,060
ובכן מתברר ש
C האובייקטיבי למעשה

82
00:04:44,060 --> 00:04:50,040
יש ns הקידומת כמעט ב
הכל, כל סוג נתונים בסיסי,

83
00:04:50,040 --> 00:04:52,690
nsstring, nsarray, nsdictionary.

84
00:04:52,690 --> 00:04:56,340
הסיבה לכך היא ns
למעשה עומד לשלב הבא,

85
00:04:56,340 --> 00:04:59,980
אשר הינה חברה ש
סטיב ג'ובס הקים,

86
00:04:59,980 --> 00:05:03,960
אשר הינה חברה שבי
C Objective שפה נולד.

87
00:05:03,960 --> 00:05:06,140
אז זה בעצם מסורת.

88
00:05:06,140 --> 00:05:09,010
אני יודע שזה קצת
מוזר, אבל זה של אפל.

89
00:05:09,010 --> 00:05:16,840
>> אז משהו שהוא אפילו יותר מוזר
יותר מזה הוא הצהרה על פונקציה.

90
00:05:16,840 --> 00:05:22,600
זה שונה מאוד ממה שאנחנו
לראות בC, כי כאן זה בעצם

91
00:05:22,600 --> 00:05:25,190
לא נראה כמו C יותר.

92
00:05:25,190 --> 00:05:28,810
מה שיש לך על ידי here--
דרך זו אינה נקודת כדור,

93
00:05:28,810 --> 00:05:30,690
זה סימן מינוס.

94
00:05:30,690 --> 00:05:36,440
יש לך סוגריים סימן מינוס
חלל ולאחר מכן את שם הפונקציה.

95
00:05:36,440 --> 00:05:38,450
בואו נגיד אם
יש לי שלום עולם, ולאחר מכן

96
00:05:38,450 --> 00:05:42,820
סוג ההחזרה יהיה חלל
כי אנחנו חוזרים שום דבר.

97
00:05:42,820 --> 00:05:44,680
>> מה מקבל ממש מוזר
הוא שכאשר אתה

98
00:05:44,680 --> 00:05:49,580
יש פרמטר אחד או יותר
עובר לאותו תפקיד ש

99
00:05:49,580 --> 00:05:53,870
יהיה ממש מוזר כפי שמוצגים כאן.

100
00:05:53,870 --> 00:05:58,230
יש לנו שם שיטה,
addInt נקרא ל[ לא ברורה]

101
00:05:58,230 --> 00:06:00,370
ואנחנו עוברים פרמטר אחד.

102
00:06:00,370 --> 00:06:05,170
אבל אחרי זה, יש לנו
יותר שם שיטת שיחה עם.

103
00:06:05,170 --> 00:06:08,500
ואחרי עם אנחנו עוברים
הפרמטר השני.

104
00:06:08,500 --> 00:06:11,940
זהו למעשה קצת מוזר,
אבל כל הצהרות הפונקציה הבאות

105
00:06:11,940 --> 00:06:14,770
בצע את אותו דפוס כמו זה.

106
00:06:14,770 --> 00:06:17,450
>> יש לנו סימן מינוס מלכתחילה.

107
00:06:17,450 --> 00:06:21,550
סימן מינוס יכול להיות סימן הפלוס
לפעמים מבוסס על איזה סוג של שיטה

108
00:06:21,550 --> 00:06:22,340
זה.

109
00:06:22,340 --> 00:06:25,000
שיטה היא בעצם
שם אחר לתפקיד.

110
00:06:25,000 --> 00:06:26,760
ואנחנו הולכים ל
להסביר שמאוחר יותר, כאשר

111
00:06:26,760 --> 00:06:30,580
על אובייקט שאנחנו מדברים
תכנות מונחה.

112
00:06:30,580 --> 00:06:34,300
אתה מציין את החזרה הראשונה
הקלד סוגריים בפנים,

113
00:06:34,300 --> 00:06:37,450
לאחר שמגיע שם השיטה.

114
00:06:37,450 --> 00:06:40,310
אתה עובר פרמטר אחד.

115
00:06:40,310 --> 00:06:44,750
ואם יש לך יותר פרמטרים
אתה צריך להאריך את שם השיטה

116
00:06:44,750 --> 00:06:46,770
ובעצם לכתוב משהו יותר כאן.

117
00:06:46,770 --> 00:06:48,090
>> זה יכול להיות כל דבר שאתה רוצה.

118
00:06:48,090 --> 00:06:50,140
במקרה שלנו זה עם.

119
00:06:50,140 --> 00:06:56,160
אבל אפשר לומר סוף, או או, או
בר abc מלא, מה שאתה רוצה.

120
00:06:56,160 --> 00:06:59,500
ואז אחרי שאתה
עובר פרמטר b.

121
00:06:59,500 --> 00:07:01,750
זה ממש מוזר
אבל אמנה אנחנו

122
00:07:01,750 --> 00:07:05,800
הולך לראות למה Apple רצה
לעשות את זה מהר מאוד.

123
00:07:05,800 --> 00:07:10,530
אז איך אתה קורא לפונקציה?

124
00:07:10,530 --> 00:07:15,520
קורא לפונקציה במטרה
C הוא גם שונה מג

125
00:07:15,520 --> 00:07:18,170
>> למעשה, קורא
פונקציה בC Objective

126
00:07:18,170 --> 00:07:21,030
הוא יותר כמו שאתה מדבר עם מישהו.

127
00:07:21,030 --> 00:07:27,030
כאן יש לנו עצמי, ש
נקרא אובייקט.

128
00:07:27,030 --> 00:07:33,830
אתה רוצה להגיד לי בעצם
מתנגד עצמי לומר "שלום העולם!"

129
00:07:33,830 --> 00:07:36,830
כלומר איך לקרוא לפונקציה.

130
00:07:36,830 --> 00:07:41,690
אובייקט ושם שיטה
בשילוב עם אחד את השני.

131
00:07:41,690 --> 00:07:49,600
וזה המקום שבי הסיומת המוזרה
לשם שיטה באמת נכנס לתמונה.

132
00:07:49,600 --> 00:07:52,150
>> בואו נסתכל על הדוגמא השנייה.

133
00:07:52,150 --> 00:07:56,780
אנחנו פשוט מוגדרים בשיטה המכונות
addInt עם בלה בלה בלה.

134
00:07:56,780 --> 00:08:00,066
אז במקרה הזה כאשר אתה מתקשר
[ספציפי ש? הודעה?] זה הולך

135
00:08:00,066 --> 00:08:02,035
להיראות כמו addInt העצמי: 10 עם: 2.

136
00:08:02,035 --> 00:08:05,410

137
00:08:05,410 --> 00:08:08,070
זה נשמע כמו אנגלית.

138
00:08:08,070 --> 00:08:11,980
למרות שהפונקציה
הצהרת פונקציה היא מוזרה,

139
00:08:11,980 --> 00:08:15,600
נקודת C של המטרה
דפוס הצהרת שיטה,

140
00:08:15,600 --> 00:08:18,830
הוא שכאשר אתה מתקשר
הפונקציה או שיטה

141
00:08:18,830 --> 00:08:21,980
זה נשמע כמו אנגלית בפועל.

142
00:08:21,980 --> 00:08:25,270
אז זה מאוד אינטואיטיבי
ברגע שאתה נכנסת לזה.

143
00:08:25,270 --> 00:08:28,740
>> במיוחד במקרה זה,
שבו אתה יכול בעצם

144
00:08:28,740 --> 00:08:33,010
רואה ששם הפונקציה הוא
סוג של התיעוד עצמו.

145
00:08:33,010 --> 00:08:35,390
אתה לא צריך שום
הסבר יותר לראות

146
00:08:35,390 --> 00:08:42,770
מה בדיוק קורה, מה
בדיוק פרמטר אחד עושה.

147
00:08:42,770 --> 00:08:48,470
הולך מעבר לזה, בואו נדבר קצת
קצת על תכנות מונחה עצמים.

148
00:08:48,470 --> 00:08:52,160
תכנות מונחה עצמים הוא
אחת מתכנות הבסיסי

149
00:08:52,160 --> 00:08:57,110
טכניקות או דפוסים שהן
בשימוש על ידי C Objective C. מטרה

150
00:08:57,110 --> 00:09:03,110
נקרא Objective-C, לא
C, מסיבה ממש טובה.

151
00:09:03,110 --> 00:09:07,560
>> אז לפני שאנחנו נכנסים ל
תחביר C אובייקטיבי,

152
00:09:07,560 --> 00:09:11,670
בואו באמת נראים במהירות ב
מה בדיוק הוא אובייקט.

153
00:09:11,670 --> 00:09:15,480
כנראה שעשינו משהו
כמו אובייקט לפני ש

154
00:09:15,480 --> 00:09:19,780
נקרא struct כאשר אתה
יישום עץ או רשימה מקושרת

155
00:09:19,780 --> 00:09:25,730
או [? לנסות. ?] אז, זה
בעצם כמו struct,

156
00:09:25,730 --> 00:09:28,560
אבל זה הרבה יותר חזק ממה ש.

157
00:09:28,560 --> 00:09:33,150
יש אובייקט שיטות ומאפיינים.

158
00:09:33,150 --> 00:09:35,310
שיטות הן בעצם פונקציות.

159
00:09:35,310 --> 00:09:39,480
בעצם פונקציות ש
ספציפי לאובייקט מסוים.

160
00:09:39,480 --> 00:09:45,440
>> ומאפיינים הם בעצם
שדה ציינת בstruct.

161
00:09:45,440 --> 00:09:48,500
אז עבור כל אובייקט
יש לנו כמה רכוש

162
00:09:48,500 --> 00:09:53,160
שיש לו כמה משתנים ש
ספציפיים לאובייקט.

163
00:09:53,160 --> 00:09:57,170
ויש לנו כמה פונקציות ש
גם ספציפיים לאובייקט.

164
00:09:57,170 --> 00:10:01,180
והפונקציות נקראות שיטות
והמשתנים נקראים מאפיינים.

165
00:10:01,180 --> 00:10:03,190
זה פשוט שם מפואר.

166
00:10:03,190 --> 00:10:10,440
בעוד העובדה שאתה, כל מבט
אתה רואה בזמן שאתה פותח את יישום iOS,

167
00:10:10,440 --> 00:10:17,720
בואו נגיד טוויטר או פייסבוק,
כל מבט שאתה רואה זה אובייקט.

168
00:10:17,720 --> 00:10:22,110
ואפילו כל האפליקציה היא
אובייקט להתחיל עם.

169
00:10:22,110 --> 00:10:25,340
מושג מאוד מעניין.

170
00:10:25,340 --> 00:10:28,480
>> ולמה אנחנו רוצים אובייקט
תכנות מונחה?

171
00:10:28,480 --> 00:10:33,530
אז אתה יכול לדמיין שכאשר אתה
תכנית שהוא מקבל די מסובך.

172
00:10:33,530 --> 00:10:36,400
בואו נגיד כשאתה
יישום לוח שחמט,

173
00:10:36,400 --> 00:10:40,020
ההיגיון הולך
להיות מסובך באמת.

174
00:10:40,020 --> 00:10:43,280
יש לך 36 שונה
חתיכות, כך שאם אתה

175
00:10:43,280 --> 00:10:48,370
רוצה לכתוב היגיון לכל
36 חלקים שונים בשחמט,

176
00:10:48,370 --> 00:10:52,150
זה הולך להיות הרבה
פונקציות שונות ומשתנים.

177
00:10:52,150 --> 00:10:54,070
זה הרבה צרות.

178
00:10:54,070 --> 00:10:58,980
וכנראה שאתה הולך לכתוב
שיטה אחרת או תפקיד אחר

179
00:10:58,980 --> 00:11:03,950
לכל אחד מהחתיכה ל
בדיוק לשלוט במה שהם עושים.

180
00:11:03,950 --> 00:11:08,830
>> אבל אם אתה עושה מונחה עצמים
תכנות, כל היצירות האלה

181
00:11:08,830 --> 00:11:12,440
ניתן הפשטה ל
אובייקט אחד ואחד.

182
00:11:12,440 --> 00:11:16,111
והאובייקט יהיה קצת נפוץ
תכונות, כמו איזה סוג של פיסה

183
00:11:16,111 --> 00:11:16,610
זה?

184
00:11:16,610 --> 00:11:17,740
איזה צבע זה?

185
00:11:17,740 --> 00:11:19,480
איך זה יכול לעבור?

186
00:11:19,480 --> 00:11:24,660
וכך יש לך מאוד
פישט את ההיגיון שלו.

187
00:11:24,660 --> 00:11:28,480
אז זה רק דרך ממש טוב
כדי להפוך את התוכניות מסובכות,

188
00:11:28,480 --> 00:11:33,700
ומערכת יחסים היררכיות
במסגרת התכנית, פשוט מאוד.

189
00:11:33,700 --> 00:11:36,800
כפי שאנו הולכים לראות
למה מהר מאוד כש

190
00:11:36,800 --> 00:11:39,660
אנחנו בעצם עושים
programming-- כשאנחנו למעשה

191
00:11:39,660 --> 00:11:42,830
עושה קוד S
תכנות פגישה מאוחרת יותר.

192
00:11:42,830 --> 00:11:48,120
>> ובכן, בנוסף לזה,
תכנות מונחה עצמים

193
00:11:48,120 --> 00:11:50,030
רק הרבה כיף.

194
00:11:50,030 --> 00:11:51,990
יש לך לעצב האובייקט שלך.

195
00:11:51,990 --> 00:11:56,080
יש לך לעצב את מה שעושה
זה נראה כמו בעצמך.

196
00:11:56,080 --> 00:11:58,250
אין תשובה נכונה לזה.

197
00:11:58,250 --> 00:12:02,940
וזה מעניין לחלוטין.

198
00:12:02,940 --> 00:12:07,270
אז בתכנות מונחה עצמים,
שני מושגי יסוד

199
00:12:07,270 --> 00:12:10,130
יהיה מעמד ודוגמה.

200
00:12:10,130 --> 00:12:13,570
כיתה היא בעצם
תבנית לאובייקט.

201
00:12:13,570 --> 00:12:18,070
ודוגמה היא בעצם
אובייקט ספציפי אחד.

202
00:12:18,070 --> 00:12:21,090
>> בואו נגיד שאתה עושה את עוגייה.

203
00:12:21,090 --> 00:12:24,800
במקרה זה, כל אחד
עוגייה אתה באמת בסופו של דבר עם

204
00:12:24,800 --> 00:12:27,310
הולך להיות אובייקט.

205
00:12:27,310 --> 00:12:35,830
אבל צלחת העוגיות אתה משתמש כדי לאפות
כל העוגיות תהיה בכיתה.

206
00:12:35,830 --> 00:12:37,880
כיתה היא בעצם תבנית.

207
00:12:37,880 --> 00:12:46,170
והדוגמא תהיה ספציפית אחד
אובייקט שנוצר מהכיתה ש.

208
00:12:46,170 --> 00:12:49,970
>> ודוגמה תיווצר
בהסתמך על הצהרה בכיתה,

209
00:12:49,970 --> 00:12:56,760
כפי שנראה בשקופיות מאוחר יותר.

210
00:12:56,760 --> 00:13:00,010
אז בואו באמת עושים באמת
דוגמא מהירה [לא ברור].

211
00:13:00,010 --> 00:13:04,280
נניח שאנחנו מכריזים
אובייקט לחתול.

212
00:13:04,280 --> 00:13:07,930
האובייקט צריך have--
כיתת החתול צריך

213
00:13:07,930 --> 00:13:11,260
יש כמה מאפיינים ושיטות.

214
00:13:11,260 --> 00:13:17,300
איזה סוג של תכונות צריכים
כיתת have-- צריכה החתול?

215
00:13:17,300 --> 00:13:20,580
>> לדוגמא, צבע,
גיל וגזע, אלה

216
00:13:20,580 --> 00:13:24,440
יהיה משתנה ש
הם ספציפיים לכל חתול.

217
00:13:24,440 --> 00:13:27,790
ואלה כמה דברים
שאנו משתמשים כדי לתאר את חתול.

218
00:13:27,790 --> 00:13:31,880
איזה סוג, של שיטה
או מה חתול יכול לעשות?

219
00:13:31,880 --> 00:13:37,160
כמה דוגמאות מהירות תהיה מרדף
עכבר, לאכול דגים או פשוט meow.

220
00:13:37,160 --> 00:13:40,900
זה באמת מהיר
דוגמא לכיתת חתול.

221
00:13:40,900 --> 00:13:46,920
ובאמת ספציפי
אובייקט חתול יהיה חתול

222
00:13:46,920 --> 00:13:50,930
שבו אנו מציינים את
צבע, הגיל וגזע.

223
00:13:50,930 --> 00:13:53,790
>> במקרה זה, האובייקט שלנו הוא
כבר לא ברמה יותר.

224
00:13:53,790 --> 00:14:00,010
אנו להעתיק את התבנית מהכיתה ו
אנו מציינים כל מידע ספציפי

225
00:14:00,010 --> 00:14:04,510
שלאובייקט מסוים
כדי להפוך אותו עצמאי.

226
00:14:04,510 --> 00:14:09,350
וכשאתה מתקשר
שיטה בתוך אובייקט,

227
00:14:09,350 --> 00:14:16,640
אתה פשוט קורא meow על האובייקט,
שהוא החתול שזה עתה יצר.

228
00:14:16,640 --> 00:14:19,020
>> כנראה שתדפיס
משהו כמו "Hello World!

229
00:14:19,020 --> 00:14:20,000
מייאו. "

230
00:14:20,000 --> 00:14:22,110
די חמוד.

231
00:14:22,110 --> 00:14:24,500
בסדר, בואו פשוט
להיכנס לכמה פרטים

232
00:14:24,500 --> 00:14:30,650
ולראות מה עושה בדיוק את זה
לתרגם להיות תכנות iOS.

233
00:14:30,650 --> 00:14:36,500
אז בiOS תכנות כל
כיתה תיושם בשני קבצים.

234
00:14:36,500 --> 00:14:41,420
קובץ אחד הוא כאן, ש
נקרא הממשק.

235
00:14:41,420 --> 00:14:45,300
קובץ נוסף הוא כאן, ש
נקרא יישום.

236
00:14:45,300 --> 00:14:48,890
>> בדרך כלל הממשק
יהיה לי extension.h

237
00:14:48,890 --> 00:14:51,740
כפי שראינו בספריות C.

238
00:14:51,740 --> 00:14:56,340
וקובץ יישום הוא
הולך להיות extension.n.

239
00:14:56,340 --> 00:14:57,260
זה קצת מוזר.

240
00:14:57,260 --> 00:15:01,270
אבל .n בעצם אומר .ג, אין
הבדל מהותי בין

241
00:15:01,270 --> 00:15:02,100
שתי.

242
00:15:02,100 --> 00:15:06,650
אז במקרה הזה, אנחנו יכולים לראות שאנחנו
הכרזת ממשק, חתול: אובייקט.

243
00:15:06,650 --> 00:15:10,660

244
00:15:10,660 --> 00:15:13,760
זה נקרא ירושה.

245
00:15:13,760 --> 00:15:19,170
אנחנו יורשים בעצם
כיתת חתול מכיתת האובייקט.

246
00:15:19,170 --> 00:15:24,790
אז כל רכוש ושיטה שהיה
שהוגדר בעבר בכיתת האובייקט

247
00:15:24,790 --> 00:15:28,560
יוגדר באופן אוטומטי
בכיתת חתול גם כן.

248
00:15:28,560 --> 00:15:35,900
>> בנוסף לכך, אנו מגדירים צבע,
גזע, וגיל, שלושה משתנים.

249
00:15:35,900 --> 00:15:39,360
שבאמת נראה כמו
משהו שעשית בעבר.

250
00:15:39,360 --> 00:15:41,770
זה נראה כמו struct.

251
00:15:41,770 --> 00:15:44,950
זה בעצם התחביר
להצהרת struct,

252
00:15:44,950 --> 00:15:47,710
וזה נכון לחלוטין.

253
00:15:47,710 --> 00:15:51,825
ומכיוון שהזכיר לי לפני,
ההבדל struct

254
00:15:51,825 --> 00:15:53,960
ואובייקט, אחד מ
הבדלים בסיסיים

255
00:15:53,960 --> 00:15:59,080
הוא שיש אובייקט שיטה,
בעוד struct יש רק משתנה.

256
00:15:59,080 --> 00:16:03,450
אז בנוסף לתכונות או
משתנים שיצרנו עבור האובייקט,

257
00:16:03,450 --> 00:16:05,700
אנו מציינים כמה שיטה.

258
00:16:05,700 --> 00:16:09,720
>> בואו נגיד שיש לנו כאן
שתי שיטות, אחת היא מיאו,

259
00:16:09,720 --> 00:16:12,460
עוד אחד הוא עכבר מרדף.

260
00:16:12,460 --> 00:16:18,600
אנחנו כנראה רוצים להיות חולפים
פרמטר המבוסס על השיטה הקודמת שלנו

261
00:16:18,600 --> 00:16:20,440
דפוס הצהרה.

262
00:16:20,440 --> 00:16:22,160
אתה בטח רוצה להיות עובר עכבר.

263
00:16:22,160 --> 00:16:25,180
ואתה בטח רוצה
לחזור מסמנים bool

264
00:16:25,180 --> 00:16:30,010
אם החתול שלך יש בהצלחה
תפס את העכבר או לא.

265
00:16:30,010 --> 00:16:33,170
>> זהו הממשק, אבל אנחנו יכולים
רואה שהממשק למעשה

266
00:16:33,170 --> 00:16:35,150
לא עושה כלום.

267
00:16:35,150 --> 00:16:40,800
זה רק אומר לי תכנית מה exists--
מה שמקיים בכיתת החתול.

268
00:16:40,800 --> 00:16:43,640
אז על מנת ש
תכנית לעשות משהו,

269
00:16:43,640 --> 00:16:46,680
אנחנו צריכים קבצי יישום.

270
00:16:46,680 --> 00:16:51,940
אז הנה, הדבר הראשון שאנחנו עושים הוא
ברור שאנו מייבאים את הממשק.

271
00:16:51,940 --> 00:16:56,470
לאחר שאנו מייבאים הממשק,
אנו מגדירים את השיטה.

272
00:16:56,470 --> 00:17:00,150
>> בואו רק נאמר כאן meow
היה להדפיס את פשוט

273
00:17:00,150 --> 00:17:01,740
"Hello World!" למסוף.

274
00:17:01,740 --> 00:17:04,319

275
00:17:04,319 --> 00:17:08,460
ולאחר היישום
קובץ, אנחנו די הרבה לעשות.

276
00:17:08,460 --> 00:17:14,530
זהו בעצם כיתה
הכרזה לכיתה אחת.

277
00:17:14,530 --> 00:17:19,970
אז עכשיו השאלה הוא,
איך אתה מצהיר על משתנה?

278
00:17:19,970 --> 00:17:26,880
הדרך בה אתה משתמש בכיתה כדי ליצור
אובייקט במטרת C שכתוב כאן.

279
00:17:26,880 --> 00:17:30,730
>> אתה מציין ראשון ש
זה הוא מצביע חתול,

280
00:17:30,730 --> 00:17:38,700
משום שכל אובייקט במטרת C
לבסוף מיושם כמצביע.

281
00:17:38,700 --> 00:17:46,210
ואתה קורא בכיתה, קורא להם
כalloc, שהוא בעצם malloc,

282
00:17:46,210 --> 00:17:51,220
אומר לי מערכת ההפעלה שב
צריך קצת מרחב זיכרון לאובייקט זה.

283
00:17:51,220 --> 00:17:55,780
אחרי שיש לך אובייקט
כבר ואתה פשוט לאתחל אותו.

284
00:17:55,780 --> 00:17:56,780
זוהי רק מוסכמה.

285
00:17:56,780 --> 00:17:59,390

286
00:17:59,390 --> 00:18:04,410
אני יודע שזה הוא קצת מוזר, אבל
זה בעצם איך אפל עושה דברים.

287
00:18:04,410 --> 00:18:07,130
>> הקצאת נכסים הוא
למעשה די פשוט.

288
00:18:07,130 --> 00:18:09,250
זה מאוד דומה ל
מה אתה עושה כש

289
00:18:09,250 --> 00:18:13,780
אתה הקצאת חלקם ספציפי
שדה הפנימי של struct.

290
00:18:13,780 --> 00:18:16,830
רק יש לך משתנה
שם, שם הרכוש,

291
00:18:16,830 --> 00:18:20,140
ולהקצות ערך ספציפי אליו.

292
00:18:20,140 --> 00:18:24,120
וקורא שיטה דומה מאוד.

293
00:18:24,120 --> 00:18:29,080
שיטה קוראת היא
בעצם מה שאני מדבר על

294
00:18:29,080 --> 00:18:32,390
להעמדת שיטה כלשהי בג Objective

295
00:18:32,390 --> 00:18:36,660
>> אתה עובר אובייקט, ב
מקרה זה הולך להיות myCat,

296
00:18:36,660 --> 00:18:42,490
ואתה עובר שם השיטה.

297
00:18:42,490 --> 00:18:47,130
כאילו שאתה מדבר על האובייקט,
myCat, כי אתה צריך meow.

298
00:18:47,130 --> 00:18:48,570
זה די מעניין.

299
00:18:48,570 --> 00:18:52,010

300
00:18:52,010 --> 00:18:55,680
לאחר מכן, יש אחד
תבנית עיצוב חיונית יותר

301
00:18:55,680 --> 00:18:59,940
שאנחנו צריכים לדבר על
לפני שמגיעים לקוד S בפועל.

302
00:18:59,940 --> 00:19:03,300
שדפוס העיצוב נקרא
אירוע מונע תכנות.

303
00:19:03,300 --> 00:19:09,660
זו גם כנראה אחד ביותר
רעיונות בסיסיים בתכנות iOS.

304
00:19:09,660 --> 00:19:14,410
>> אז אתה כנראה לא יודע מה בדיוק
הוא תכנות האירוע מונחה,

305
00:19:14,410 --> 00:19:16,990
אבל זה לא באמת כל כך מפחיד.

306
00:19:16,990 --> 00:19:20,400
ובכן למעשה, יש לך
כבר עשה את זה לפני.

307
00:19:20,400 --> 00:19:24,894
זהו אחד מהקווים שיש לך כנראה
כבר נכתב ב[ לא ברור] האחרונה

308
00:19:24,894 --> 00:19:26,810
של CS50,
google.maps.event.addListener (סמן,

309
00:19:26,810 --> 00:19:27,810
"לחץ", פונקציה () {}) :.

310
00:19:27,810 --> 00:19:32,410

311
00:19:32,410 --> 00:19:37,620
על ידי קורא את הקו הזה אתה
למעשה הוראה למחשב

312
00:19:37,620 --> 00:19:42,650
כי בכל פעם שנקרא האירוע
"לחץ על" קורה על הסמן,

313
00:19:42,650 --> 00:19:43,630
להשתמש בפונקציה ש.

314
00:19:43,630 --> 00:19:46,910

315
00:19:46,910 --> 00:19:50,950
>> זה שונה מאוד מ
מה שאתה עושה בmario.c.

316
00:19:50,950 --> 00:19:56,670
בmario.c אתה פשוט להפעיל את התכנית
פעם אחת, זה נותן לך פלט,

317
00:19:56,670 --> 00:19:58,590
ותסיים.

318
00:19:58,590 --> 00:20:02,590
אלה הם כמו סוג של
תוכניות ירייה אחת.

319
00:20:02,590 --> 00:20:05,830
תוכניות אירוע מונע
מאוד, מאוד שונים.

320
00:20:05,830 --> 00:20:10,230
בואו נדמיין, אם פייסבוק הוא אחד
תכנית ירייה זה לא ממש טוב.

321
00:20:10,230 --> 00:20:13,750
אתה פשוט ללכת לפייסבוק
פעם אחת וזה נעשה.

322
00:20:13,750 --> 00:20:16,700
זה נותן לך כמה פלט
ואתה אף פעם לא קיבלת אותו בחזרה.

323
00:20:16,700 --> 00:20:19,380
אתה אף פעם לא קיבלת שום דבר יותר.

324
00:20:19,380 --> 00:20:23,880
>> אז הנה, במיוחד
הדפוס אנו משתמשים הוא

325
00:20:23,880 --> 00:20:26,940
אירוע מונע, כך ש
כל פונקציה

326
00:20:26,940 --> 00:20:31,480
להיתפס על סמך מה
אירוע שקרה.

327
00:20:31,480 --> 00:20:34,670
לדוגמא, אם יש לנו
כפתור ולציין

328
00:20:34,670 --> 00:20:39,870
כי בכל פעם שלוחץ על הכפתור,
לקרוא לפונקציה הנקראת "Hello World!"

329
00:20:39,870 --> 00:20:47,810
בדרך זו אנו יכולים באמת
לנהל את היגיון הפונקציה

330
00:20:47,810 --> 00:20:50,560
לזרום בצורה גמישה מאוד.

331
00:20:50,560 --> 00:20:55,840
המשתמש יכול לעשות או לקרוא לפונקציה
שכבר קרא כבר.

332
00:20:55,840 --> 00:20:59,900
זה מבוסס לחלוטין על מה שמשתמשים עושים.

333
00:20:59,900 --> 00:21:04,080
>> אז אנחנו יכולים לראות שזה הוא
למעשה הרבה יותר טוב מאשר mario.c.

334
00:21:04,080 --> 00:21:07,190
וחדשות טובות היא שזה
בעצם לא רעיון חדש.

335
00:21:07,190 --> 00:21:12,140
אתם כבר עשיתם
שבבעיה האחרונה שנקבעה.

336
00:21:12,140 --> 00:21:16,640
אז במטרת C יש
שלושה תרשימים שונים

337
00:21:16,640 --> 00:21:19,030
לתכנות מונחה אירוע.

338
00:21:19,030 --> 00:21:21,970
התרשים הראשון הוא
נקרא פעולת יעד,

339
00:21:21,970 --> 00:21:26,990
שבו אתה קושרים כפתור
עיתונאים עם כמה פונקציה.

340
00:21:26,990 --> 00:21:31,590
בואו רק נאמר, בכל פעם שאתה לוחץ
איזה כפתור, אתה קורא כמה פונקציה.

341
00:21:31,590 --> 00:21:33,620
זוהי פעולת יעד מאוד פשוט.

342
00:21:33,620 --> 00:21:35,580
>> השני הוא
למעשה הכי הקשה,

343
00:21:35,580 --> 00:21:38,450
זה נקרא משלחת בפרוטוקול.

344
00:21:38,450 --> 00:21:41,800
אנחנו הולכים להסביר
כי בפירוט רב מאוחר יותר.

345
00:21:41,800 --> 00:21:44,420
והדרך השלישית היא הודעה.

346
00:21:44,420 --> 00:21:46,770
זהו למעשה לא
חשוב מאוד מבחינת

347
00:21:46,770 --> 00:21:50,920
כפי שאנו מודאגים, משום שהסיכוי
כי אתה הולך להשתמש הודעה

348
00:21:50,920 --> 00:21:53,310
בפרויקט הגמר שלך הוא די נמוך.

349
00:21:53,310 --> 00:21:56,440
אז אנחנו הולכים לדלג על החלק הזה.

350
00:21:56,440 --> 00:21:59,460
>> ואנחנו הולכים לצלול
למשלחת בפרוטוקול.

351
00:21:59,460 --> 00:22:02,380

352
00:22:02,380 --> 00:22:04,470
אז מה בדיוק פרוטוקול?

353
00:22:04,470 --> 00:22:06,450
או מה בדיוק הוא משלחת?

354
00:22:06,450 --> 00:22:09,670
בואו נדבר על פרוטוקול להתחיל עם.

355
00:22:09,670 --> 00:22:13,360
פרוטוקולים אינם אלא אירועים.

356
00:22:13,360 --> 00:22:19,230
אבל מקבלים את האירועים הללו ל
לך על ידי Apple כדי להתחיל עם.

357
00:22:19,230 --> 00:22:22,640
לדוגמא, אני לא
לגמרי בטוח כמה מכם

358
00:22:22,640 --> 00:22:27,930
בחורים להשתמש המקורי של אפל
דואר אפליקציה או מגע,

359
00:22:27,930 --> 00:22:32,180
אבל בכל פעם שאתה לגלול
שולחן ולחץ על תא המסוים

360
00:22:32,180 --> 00:22:36,130
על השולחן, כי הוא אירוע.

361
00:22:36,130 --> 00:22:38,330
>> ואם אתה רוצה לעשות
אירוע זה בעצמך,

362
00:22:38,330 --> 00:22:40,410
זה בעצם קצת קשה.

363
00:22:40,410 --> 00:22:44,880
אז אפל נתנה שגם לך
כך שאתה יכול פשוט להשתמש ישירות

364
00:22:44,880 --> 00:22:49,610
האירוע לעשות משהו בעצמך.

365
00:22:49,610 --> 00:22:52,980
פרוטוקולים הם למעשה
באמת, באמת בשימוש נרחב

366
00:22:52,980 --> 00:22:58,320
במטרת ג ובכן ב
למעשה, כל יישום

367
00:22:58,320 --> 00:23:00,870
יש משהו תפס את נציג אפליקציה.

368
00:23:00,870 --> 00:23:06,330
בתוך עדין הוא כל
פרוטוקולים לטעינת האפליקציה.

369
00:23:06,330 --> 00:23:12,470
>> בואו נגיד שיש
אירוע לאפליקציה עשה עומס.

370
00:23:12,470 --> 00:23:18,200
אז מה צריך לקרות אחרי שיש לך
נוצרה אפליקציה, לאחר שאתה פותח את האפליקציה,

371
00:23:18,200 --> 00:23:22,630
לאחר שתסגור את האפליקציה, או לאחר
אתה שם את iPhone לישון.

372
00:23:22,630 --> 00:23:27,480
כל אלה הם האירועים שיש
כבר ניתנו לך.

373
00:23:27,480 --> 00:23:34,730
ובמקור בתוך חלקיקים אלה
לא יהיה יישום.

374
00:23:34,730 --> 00:23:39,750
אפל פשוט אמר לך שפונקציה זו
יקרה כאשר אירוע כלשהו קורה,

375
00:23:39,750 --> 00:23:44,380
אבל מה שאתה עושה עם זה
פונקציה היא לגמרי תלויה בך.

376
00:23:44,380 --> 00:23:49,290
>> משלחת היא בעצם
אומר לי הכיתה

377
00:23:49,290 --> 00:23:53,060
כי אתה צריך לטפל בפרוטוקולים אלה.

378
00:23:53,060 --> 00:23:55,340
זה קצת
מבלבל, אבל זה יהיה

379
00:23:55,340 --> 00:23:59,380
הרבה יותר ברור כאשר אנו עושים
הקודים של בפעולה.

380
00:23:59,380 --> 00:24:04,760
משלחת בפרוטוקול היא למעשה
מנגנון חזק מאוד במובן

381
00:24:04,760 --> 00:24:08,160
שאם אנחנו עושים משלחת
למחלקה מסוימת,

382
00:24:08,160 --> 00:24:12,400
אנחנו יכולים להתמודד עם מהות
כל מיני אירועים

383
00:24:12,400 --> 00:24:17,040
שימוש בכל כיתה יש לנו,
כלי נוח מאוד.

384
00:24:17,040 --> 00:24:21,530
>> אז דוגמא מהירה אחת ל
משלחת בפרוטוקול

385
00:24:21,530 --> 00:24:24,120
יהיה מה שאני רק דיברתי עליו.

386
00:24:24,120 --> 00:24:26,720

387
00:24:26,720 --> 00:24:30,890
פרוטוקול זה במיוחד נקרא
tableview [לא ברור] בחר תפקיד

388
00:24:30,890 --> 00:24:35,480
ב[? מדד?] [? האחרון. אז?] זה
אירוע שייתפס כשאתה

389
00:24:35,480 --> 00:24:39,710
למעשה להקיש על ספציפי
תא בtableview שלך,

390
00:24:39,710 --> 00:24:43,570
בואו נגיד בדואר שלך
או ביישום אנשי הקשר שלך.

391
00:24:43,570 --> 00:24:48,180
>> בתוך פונקציה הייתה
במקור ולא עושה כלום.

392
00:24:48,180 --> 00:24:51,950
הפונקציה לא
לעשות כל דבר כברירת מחדל.

393
00:24:51,950 --> 00:24:55,540
אבל אתה יכול לציין
מה הפונקציה עושה,

394
00:24:55,540 --> 00:24:59,610
בהתחשב במה שאתה רוצה מתוך היישום שלך.

395
00:24:59,610 --> 00:25:01,610
כלי נוח מאוד.

396
00:25:01,610 --> 00:25:06,840
ועם כל זה
נאמר, אני בעצם

397
00:25:06,840 --> 00:25:11,430
לכסות חלק תחביר בסיסי מאוד ו
מושג יסוד לC Objective

398
00:25:11,430 --> 00:25:15,860
תכנות, ואנחנו יכולים לעשות קצת קוד של.

399
00:25:15,860 --> 00:25:17,980
הרבה יותר מרגש.

400
00:25:17,980 --> 00:25:21,070
אז הקוד של הוא למעשה
קצת מכריע

401
00:25:21,070 --> 00:25:23,330
כאשר אתה פותח אותו בפעם הראשונה.

402
00:25:23,330 --> 00:25:26,640
>> הערה מהירה אחד, כך שאם אתה
רוצה לעשות פיתוח iOS,

403
00:25:26,640 --> 00:25:29,630
אני מאוד ממליץ לך מק.

404
00:25:29,630 --> 00:25:33,930
מכיוון עושה פיתוח iOS ב
Windows היא באמת, באמת קשה.

405
00:25:33,930 --> 00:25:37,560
זה בר ביצוע, אבל זה ממש קשה.

406
00:25:37,560 --> 00:25:40,610
ואתה בהחלט לעשות
לא רוצה להשתמש בעריכת ז.

407
00:25:40,610 --> 00:25:47,950
אז בקוד של שיש לנו
מספר תחומים שונים.

408
00:25:47,950 --> 00:25:53,050
כאשר אתה ראשון לפתוח את קוד של
תוכל לראות אזור ניווט,

409
00:25:53,050 --> 00:25:57,470
אשר בעצם מראה את כולכם
קבצים שנמצאים בפרויקט הנוכחי שלך.

410
00:25:57,470 --> 00:26:03,590
>> יש לך אזור סרגל כלים, ש
הוא בעצם ניהול תצוגות,

411
00:26:03,590 --> 00:26:08,570
או כמה מעט מהיר
כלים על הקוד של עצמו.

412
00:26:08,570 --> 00:26:11,140
וזה אזור העורך בפועל.

413
00:26:11,140 --> 00:26:15,900
אזור זה הוא לערוך g דומה מאוד,
אבל הרבה יותר טוב מאשר לערוך g.

414
00:26:15,900 --> 00:26:21,150
ובאזור זכות זו, היא
נקרא אזור השירות.

415
00:26:21,150 --> 00:26:27,170
האזור הופך להיות ממש שימושי כאשר
אתה יוצר ממשק או ציון

416
00:26:27,170 --> 00:26:30,070
כמה הגדרות מהירות עבור היישום שלך.

417
00:26:30,070 --> 00:26:34,570
>> והשטח הסופי הוא ניפוי השגיאות.

418
00:26:34,570 --> 00:26:37,970
אזור זה כולל את הקונסולה.

419
00:26:37,970 --> 00:26:43,170
אז בכל פעם שאתה אומר printf,
או nslog במקרה שלנו,

420
00:26:43,170 --> 00:26:47,330
כל התוצאות שלך
הולך להיות מודפס כאן.

421
00:26:47,330 --> 00:26:48,260
בסדר?

422
00:26:48,260 --> 00:26:52,090
אני מניח שאנחנו באמת יכולים לעשות במהירות
דוגמא לתכנות iOS.

423
00:26:52,090 --> 00:26:54,220
ובואו למעשה לפתוח את קוד של.

424
00:26:54,220 --> 00:26:57,210

425
00:26:57,210 --> 00:27:01,346
אז בכל פעם שאתה פותח את קוד של, זה
הולך להראות משהו כזה.

426
00:27:01,346 --> 00:27:03,220
זה הולך לשאול אותך
מה אתה רוצה לעשות?

427
00:27:03,220 --> 00:27:06,830
האם אתה רוצה להתחיל משהו
אקראי, מגרש משחקים, בעצם אתה

428
00:27:06,830 --> 00:27:11,250
רק יכול לבדוק את קוד ללא
למעשה התחייבות לכל יישום.

429
00:27:11,250 --> 00:27:13,020
>> האם אתה רוצה ליצור פרויקט חדש?

430
00:27:13,020 --> 00:27:16,660
או שאתה רוצה להמשיך
לעבוד על הפרויקט קיים?

431
00:27:16,660 --> 00:27:20,270
במקרה שלנו אנחנו הולכים
כדי ליצור פרויקט חדש.

432
00:27:20,270 --> 00:27:22,980
אז זה ממש נחמד, S
קוד בעצם יש כבר

433
00:27:22,980 --> 00:27:26,820
נתתי לך כמה תבניות
ליצירת אובייקטים.

434
00:27:26,820 --> 00:27:32,680
אם אתה רוצה לעשות משחק, זה קוד
למעשה יש תבנית משחק בשבילכם,

435
00:27:32,680 --> 00:27:36,890
יש יישומי דף מבוסס,
יישום מבוסס כרטיסייה.

436
00:27:36,890 --> 00:27:39,280
במקרה זה, אנחנו הולכים
לעשות משהו מאוד פשוט,

437
00:27:39,280 --> 00:27:43,230
ואנחנו הולכים להשתמש ב
יישום תצוגה אחת.

438
00:27:43,230 --> 00:27:48,270
>> לאחר שרק מה שאתה רוצה לקרוא ל
המוצר שלך, ומה השם שלך,

439
00:27:48,270 --> 00:27:52,760
מה המזהה שלך, ו
באיזו שפה אתה משתמש.

440
00:27:52,760 --> 00:27:57,060
כאן אנחנו לא רוצים
לבדוק באמצעות Core נתונים.

441
00:27:57,060 --> 00:28:00,170
Core Data הוא בעצם databasing iOS.

442
00:28:00,170 --> 00:28:05,360
אם אתה עושה Core Data, זה
קוד הולך להגדיר

443
00:28:05,360 --> 00:28:07,710
שיעורים מסובכים הרבה יותר בשבילך.

444
00:28:07,710 --> 00:28:12,740
אז כדי לשמור על הכל פשוט, אנחנו
רק הולך לעשות בלי Core Data

445
00:28:12,740 --> 00:28:15,290
עכשיו.

446
00:28:15,290 --> 00:28:18,030
>> הבעיה שאנחנו הולכים להיות
באמצעות הוא that-- הבעיה

447
00:28:18,030 --> 00:28:23,770
אנחנו הולכים להיות יצירת הוא שאנחנו
בעצם רוצה לייבא מריו מC

448
00:28:23,770 --> 00:28:25,437
ליישום iOS.

449
00:28:25,437 --> 00:28:26,645
אז בואו נקראים לזה מריו iOS.

450
00:28:26,645 --> 00:28:31,230

451
00:28:31,230 --> 00:28:34,880
כמובן שתציין את מה שאתה
רוצה לשים בפרויקט שלך.

452
00:28:34,880 --> 00:28:37,870
ויש לנו ללכת.

453
00:28:37,870 --> 00:28:41,390
>> אז זה קצת
מכריע, אבל זה בעצם

454
00:28:41,390 --> 00:28:43,540
מה שראינו בשקופיות.

455
00:28:43,540 --> 00:28:49,710
והאזור הראשון שאנחנו רואים עכשיו
הוא בעצם פרויקט תצורה.

456
00:28:49,710 --> 00:28:53,390
אז כל מה שאתה רוצה לעשות
פרויקט, איזה סוג של מכשיר,

457
00:28:53,390 --> 00:28:58,810
בואו נגיד איזה סוג של מכשיר
אתה רוצה האפליקציה שלך תופיע ב?

458
00:28:58,810 --> 00:29:01,280
האם זה iPhone, iPad או אוניברסלי?

459
00:29:01,280 --> 00:29:04,660
אז אורינטציה של מכשיר, את כל הדברים האלה.

460
00:29:04,660 --> 00:29:08,490
לא מאוד חשוב,
אבל יכול להיות, אבל זה

461
00:29:08,490 --> 00:29:11,050
הוא מקום שבו אתה מגדיר את
הפרויקט שלך אם אתה באמת

462
00:29:11,050 --> 00:29:15,180
רוצה לפרוס בחנות של אפל.

463
00:29:15,180 --> 00:29:20,420
>> בסדר, בואו נסתכל על
משהו שהוא בתוך הקוד שלנו.

464
00:29:20,420 --> 00:29:22,360
בואו נעבור נווט הקובץ.

465
00:29:22,360 --> 00:29:30,140
וכל אלה הם הקבצים שכבר
באתי עם התבנית, נחמדה מאוד.

466
00:29:30,140 --> 00:29:35,980
לכן, כאשר אנו לחצו על אחד מהם
זה מה שזה נראה.

467
00:29:35,980 --> 00:29:38,530
דומה מאוד לעריכת g.

468
00:29:38,530 --> 00:29:41,340
אבל אתה יכול לראות ש
הדגשת תחביר היא כנראה

469
00:29:41,340 --> 00:29:42,780
קצת יותר נחמד.

470
00:29:42,780 --> 00:29:45,610
וזה בעצם הרבה יותר
חזק מאשר עריכת g.

471
00:29:45,610 --> 00:29:49,970
ואתה יכול להשלים אוטומטי
הרבה דברים בשבילך,

472
00:29:49,970 --> 00:29:52,370
כפי שנראה מהר מאוד.

473
00:29:52,370 --> 00:29:54,100
>> בואו לפתוח את האזור לאיתור באגים גם כן.

474
00:29:54,100 --> 00:30:02,790

475
00:30:02,790 --> 00:30:07,000
בסדר, כפי שניתן לראות,
הקונסולה היא ממש כאן.

476
00:30:07,000 --> 00:30:13,840
זה מה שאתה הולך לראות בי
אתה בprintf או nsloging משהו.

477
00:30:13,840 --> 00:30:17,155
אז בלי עיכובים נוספים, בואו למעשה
לקמפל את האפליקציה ולראות מה קורה.

478
00:30:17,155 --> 00:30:20,000

479
00:30:20,000 --> 00:30:23,410
תכונה חיונית אחד ל
קוד של, הוא שהקוד של

480
00:30:23,410 --> 00:30:25,850
מגיע עם סימולטור iPhone.

481
00:30:25,850 --> 00:30:29,820
אז אתה לא צריך
iPhone לנסות את הפרויקט שלך,

482
00:30:29,820 --> 00:30:34,440
קוד של שיכול לדמות ל
אתה, כפי שאנו רואים עכשיו.

483
00:30:34,440 --> 00:30:36,406
>> זה די נחמד.

484
00:30:36,406 --> 00:30:38,640
זה לוקח קצת
קצת זמן כדי ללקט

485
00:30:38,640 --> 00:30:43,040
ובעצם יש לנו
יישום ריק,

486
00:30:43,040 --> 00:30:44,640
אשר למעשה לא עושה כלום.

487
00:30:44,640 --> 00:30:46,175
אבל זה הידור.

488
00:30:46,175 --> 00:30:47,380
זה די מדהים.

489
00:30:47,380 --> 00:30:50,200
זה הרבה יותר טוב מאשר C, הא?

490
00:30:50,200 --> 00:30:52,130
בסדר, אז בואו
תנסה להוסיף משהו.

491
00:30:52,130 --> 00:30:56,050

492
00:30:56,050 --> 00:31:02,650
קובץ אחד שהוא קצת
מוזר כאן נקרא לוח תכנון.

493
00:31:02,650 --> 00:31:08,020
זהו למעשה גדול,
תכונה מדהימה לקוד של.

494
00:31:08,020 --> 00:31:14,170
משום שבקוד של, אתה בעצם יכול לגרור
ושחררו אלמנטים על הממשק

495
00:31:14,170 --> 00:31:17,430
וזה יהיה ישירות להופיע.

496
00:31:17,430 --> 00:31:18,055
בואו ננסה את זה.

497
00:31:18,055 --> 00:31:21,230

498
00:31:21,230 --> 00:31:27,236
>> אנחנו שחררו תווית כאן, "Hello World !!!"

499
00:31:27,236 --> 00:31:29,740
אנחנו יכולים למרכז ש.

500
00:31:29,740 --> 00:31:30,970
די מגניב.

501
00:31:30,970 --> 00:31:33,915
עכשיו בואו נרוץ סימולציה תחנה זו.

502
00:31:33,915 --> 00:31:36,940

503
00:31:36,940 --> 00:31:38,700
כאן יש לנו "Hello World !!!"

504
00:31:38,700 --> 00:31:40,810
אנחנו אפילו לא עשינו שום קידוד עדיין.

505
00:31:40,810 --> 00:31:42,750
מה לעזאזל קורה?

506
00:31:42,750 --> 00:31:45,880
כך חזק
ממשק Builder יכול להיות.

507
00:31:45,880 --> 00:31:48,030
מישהו אפילו אמר ש
כנראה שאתה יכול פשוט

508
00:31:48,030 --> 00:31:52,800
להשלים את יישום ללא כתיבה
כנראה אלף שורות קוד

509
00:31:52,800 --> 00:31:54,820
רק על ידי שימוש בממשק Builder.

510
00:31:54,820 --> 00:31:59,680
אבל זה כנראה לא
הדרך הטובה ביותר לעשות את זה.

511
00:31:59,680 --> 00:32:01,670
>> עכשיו בואו באמת ניגשים לקידוד.

512
00:32:01,670 --> 00:32:04,860

513
00:32:04,860 --> 00:32:08,330
אז המבנה של הקובץ
הוא למעשה באמת מעניין

514
00:32:08,330 --> 00:32:15,610
כי, כפי שאתה יכול לראות, יש
אין פונקציה העיקרית בכל מקום.

515
00:32:15,610 --> 00:32:17,466
רואה?

516
00:32:17,466 --> 00:32:19,340
כפי שהזכרנו קודם,
אתה יכול לראות שזה

517
00:32:19,340 --> 00:32:22,830
הוא קובץ יישום
למחלקה מסוימת.

518
00:32:22,830 --> 00:32:25,690
אבל אין בשום מקום עיקרי.

519
00:32:25,690 --> 00:32:27,490
אז איפה הוא עיקרי?

520
00:32:27,490 --> 00:32:31,970
למעשה, יש עיקרי, אבל
עיקרי הוא למעשה מוסתר ממך.

521
00:32:31,970 --> 00:32:34,560
העיקרי הוא כאן.

522
00:32:34,560 --> 00:32:37,120
שנראה מוכר.

523
00:32:37,120 --> 00:32:41,000
>> אז בעצם מה שiOS
הוא עושה בתוך ראשי

524
00:32:41,000 --> 00:32:43,540
הוא שכל פעם שעיקרית הוא
בשם, שהוא בעצם

525
00:32:43,540 --> 00:32:49,000
בכל פעם שהאפליקציה מבוצעת, זה
יוצר אובייקט נקרא AppDelegate.

526
00:32:49,000 --> 00:32:52,980

527
00:32:52,980 --> 00:32:57,350
כפי שציינתי קודם, כל
אפליקציה היא למעשה אובייקט בפני עצמו.

528
00:32:57,350 --> 00:33:02,270
אז בדרך זו, בעצם
האפליקציה iOS אומרת למהדר

529
00:33:02,270 --> 00:33:05,540
אישור זה, אני הולך ליצור
מוצר שנקרא AppDelegate,

530
00:33:05,540 --> 00:33:07,620
וכי הוא הולך להיות האפליקציה שלי.

531
00:33:07,620 --> 00:33:09,640
אז אתה צריך ללכת
דרך AppDelegate ש

532
00:33:09,640 --> 00:33:12,040
ותראה מה הבחור הזה עושה.

533
00:33:12,040 --> 00:33:14,850
התפקיד שלי הוא עשה בשבילי.

534
00:33:14,850 --> 00:33:22,070
>> ובAppDelegate אתה יכול לראות ש
יש כמה פונקציות ממש מוזרות,

535
00:33:22,070 --> 00:33:25,290
גם למעשה שיטות, ש
אפל כבר נתן לך.

536
00:33:25,290 --> 00:33:27,464
מה אלה?

537
00:33:27,464 --> 00:33:31,010
אלה הם למעשה רק פרוטוקולים
שאני מדבר.

538
00:33:31,010 --> 00:33:35,670
אז אלה הם אירועים שApple
נתן לך להתחיל עם.

539
00:33:35,670 --> 00:33:38,050
אין שום דבר בכמה
של הפונקציות עכשיו,

540
00:33:38,050 --> 00:33:40,820
אבל אם אנחנו רוצים לאתחל
משהו לאפליקציה שלנו

541
00:33:40,820 --> 00:33:46,140
לפני שנכנס למוצגות
כל תצוגה, אנחנו עושים את זה כאן.

542
00:33:46,140 --> 00:33:51,150
>> רק אתה יכול לקרוא את שמו ואני מניח ש
האירוע הוא למעשה ממש ברור.

543
00:33:51,150 --> 00:33:54,160

544
00:33:54,160 --> 00:33:58,350
אז עכשיו עיקרי יצר
אובייקט לAppDelegate.

545
00:33:58,350 --> 00:34:05,220
ומה AppDelegate הוא הולך לעשות
הוא למעשה גם מוסתר ממך.

546
00:34:05,220 --> 00:34:09,250
AppDelegate עומד להתחיל
טעינת מניית ViewController.

547
00:34:09,250 --> 00:34:13,170
אז זה בעצם הולך להתחיל
טוען את כל הדעות שיש לך

548
00:34:13,170 --> 00:34:17,500
ורק להבהיר את התצוגה
המבוסס על ההיררכיה.

549
00:34:17,500 --> 00:34:21,280
>> אז במקרה הזה יש לנו רק
מבט אחד, שהוא כאן.

550
00:34:21,280 --> 00:34:25,060
כך שהוא יחיד ש
זה הולך להיות בשם.

551
00:34:25,060 --> 00:34:28,159
היגיון ViewController הוא ממש כאן.

552
00:34:28,159 --> 00:34:32,159
זהו הקוד שלמעשה
שולט בנוף רק שראינו.

553
00:34:32,159 --> 00:34:33,679
בסדר, בואו נעשה משהו כאן.

554
00:34:33,679 --> 00:34:44,030

555
00:34:44,030 --> 00:34:50,560
אז viewDidLoad נשמע כמו אירוע,
כאשר למעשה זה הוא גם נציג,

556
00:34:50,560 --> 00:34:52,500
זה גם פרוטוקול.

557
00:34:52,500 --> 00:34:56,350
>> אז מה הדעה נטענת,
כל מה שבתוך הפונקציה

558
00:34:56,350 --> 00:34:57,920
ייקרא.

559
00:34:57,920 --> 00:35:02,840
במקרה זה אנו צריכים לראות "שלום
Tianyu! "אם אנחנו מפעילים את התכנית.

560
00:35:02,840 --> 00:35:09,820

561
00:35:09,820 --> 00:35:12,842
זה מתחיל להיות קצת איטי
עריכת קבצי לוח תכנון.

562
00:35:12,842 --> 00:35:15,440

563
00:35:15,440 --> 00:35:18,190
ובכן אכן, אנו רואים פלט עבורו.

564
00:35:18,190 --> 00:35:20,720
זה די מגניב.

565
00:35:20,720 --> 00:35:22,000
עכשיו בואו בעצם לעשות מריו.

566
00:35:22,000 --> 00:35:25,400

567
00:35:25,400 --> 00:35:27,625
אני הולך להגדיר את
לתפקד מהר מאוד.

568
00:35:27,625 --> 00:35:31,510

569
00:35:31,510 --> 00:35:54,245
marioWithLevels: תוצאות (int) רמה.

570
00:35:54,245 --> 00:36:01,120

571
00:36:01,120 --> 00:36:06,410
>> בסדר, זה בעצם מדהים
תכונת השלמה האוטומטית של קוד.

572
00:36:06,410 --> 00:36:10,680
לכן, כאשר אתה כותב ולהקלד להיכנס,
זה כבר נתן את התבנית

573
00:36:10,680 --> 00:36:12,325
בשבילך, וזה די מגניב.

574
00:36:12,325 --> 00:36:50,480

575
00:36:50,480 --> 00:36:52,850
זה צריך להיראות ממש
מוכר לכם.

576
00:36:52,850 --> 00:36:55,940

577
00:36:55,940 --> 00:36:59,680
מצטער, זה באשמתי.

578
00:36:59,680 --> 00:37:15,790

579
00:37:15,790 --> 00:37:18,120
בסדר, מגניב.

580
00:37:18,120 --> 00:37:22,710
ההיגיון שצריך נראה ממש מוכר
לכם, במיוחד רק מריו.

581
00:37:22,710 --> 00:37:26,140
>> אבל אנחנו עכשיו להדפיס ל
הקונסולה בכל פעם,

582
00:37:26,140 --> 00:37:29,280
כי אנחנו רוצים לשמור איכשהו
מסלול של מה שאנחנו מדפיסים.

583
00:37:29,280 --> 00:37:31,810
אנחנו הולכים להשתמש ב
תוצאות איכשהו מאוחר יותר,

584
00:37:31,810 --> 00:37:35,010
כדי להציג את ההדפסה
את התוצאה למשתמש.

585
00:37:35,010 --> 00:37:37,730
אז במקום שאנחנו פשוט
nslogging הכל,

586
00:37:37,730 --> 00:37:42,410
שאנחנו אחסון הכל
לקריאה לפונקצית תוצאה מכך,

587
00:37:42,410 --> 00:37:44,070
אבל ההיגיון הוא בדיוק אותו הדבר.

588
00:37:44,070 --> 00:37:48,030

589
00:37:48,030 --> 00:37:51,800
אחרי שנסיים את זה, אנחנו
פשוט להדפיס את התוצאות שלנו.

590
00:37:51,800 --> 00:37:59,330

591
00:37:59,330 --> 00:38:04,970
>> וכאן במקום להדפיס אותי
שם, אנחנו הולכים לקרוא לפונקציה.

592
00:38:04,970 --> 00:38:15,340

593
00:38:15,340 --> 00:38:18,090
בואו לראות מה קורה.

594
00:38:18,090 --> 00:38:21,240
אופס, כמובן.

595
00:38:21,240 --> 00:38:24,320
יש לנו נחמד
פירמידה קטנה כאן.

596
00:38:24,320 --> 00:38:28,370
זה בעצם C, אנחנו רק
מניפולציה שבו אתה קורא לפונקציה

597
00:38:28,370 --> 00:38:30,010
ואיך פונקציה נראית כמו.

598
00:38:30,010 --> 00:38:31,560
אין שום דבר שונה.

599
00:38:31,560 --> 00:38:34,040
אבל זה בעצם
לא מאוד מרגש כאן,

600
00:38:34,040 --> 00:38:37,500
בגלל שאנחנו לא רואים
שום דבר מיישום iPhone.

601
00:38:37,500 --> 00:38:42,120
>> אז אם אתה באמת צריך iPhone app--
אם באמת יש לך זכות מריו iOS

602
00:38:42,120 --> 00:38:45,080
עכשיו, אתה לא הולך
לראות כל דבר ש

603
00:38:45,080 --> 00:38:49,450
יש משהו לעשות עם מריו כי
כל יציאות אלה לקונסולה

604
00:38:49,450 --> 00:38:51,620
הם מוסתרים ממשתמש.

605
00:38:51,620 --> 00:38:53,850
זה מה שאתה רואה,
אשר הוא "Hello World !!!"

606
00:38:53,850 --> 00:38:55,720
לא טוב.

607
00:38:55,720 --> 00:39:03,090
עכשיו בואו ננסה לעשות את המשתמש לראות
מה בדיוק אנחנו מדפיסים את.

608
00:39:03,090 --> 00:39:06,000
אז אנחנו לא צריכים לתייג יותר.

609
00:39:06,000 --> 00:39:09,800
בואו ננסה להבין משהו
אחר שיכול להיות שימושי.

610
00:39:09,800 --> 00:39:12,140
>> יש למעשה אחד
אלמנט שנקרא

611
00:39:12,140 --> 00:39:16,460
שדה טקסט, שיכל
להיות מאוד מועיל לנו.

612
00:39:16,460 --> 00:39:19,880
זה בעצם מציג אזור
טקסט שניתן לערוך.

613
00:39:19,880 --> 00:39:22,320
אז זה נראה באמת מועיל.

614
00:39:22,320 --> 00:39:23,810
עכשיו בואו לגרור אותו ושחרר אותו.

615
00:39:23,810 --> 00:39:26,880

616
00:39:26,880 --> 00:39:32,670
וואו, יש לנו תצוגת טקסט
לדעתנו, מפואר באמת.

617
00:39:32,670 --> 00:39:35,430
זה קצת גדול מדי.

618
00:39:35,430 --> 00:39:38,150
בואו נעשה את זה קטן יותר.

619
00:39:38,150 --> 00:39:40,290
הכניס אותו לתוך מרכז.

620
00:39:40,290 --> 00:39:43,760
יקטין אותה גם כן.

621
00:39:43,760 --> 00:39:50,110
>> עכשיו יש לנו תצוגת טקסט, שבו אנו יכולים
לשמש כדי להציג התוצאה הסופית שלנו.

622
00:39:50,110 --> 00:39:52,860
אבל כרגע זה
בהחלט לא הולך לעבודה

623
00:39:52,860 --> 00:39:56,970
כי יש no--
ViewController אנחנו פשוט

624
00:39:56,970 --> 00:40:03,010
מוגדר לא יודע ש
יש תצוגת טקסט שם בחוץ.

625
00:40:03,010 --> 00:40:06,550
אז אנחנו צריכים איכשהו
לקשר את תצוגת הטקסט פשוט

626
00:40:06,550 --> 00:40:11,660
נוצר עם הכיתה ש
כבר בא איתנו.

627
00:40:11,660 --> 00:40:14,860
>> הדרך בה אנו עושים את זה היא
למעשה קסום באמת.

628
00:40:14,860 --> 00:40:18,190
אז לפתוח את לוח תכנון.

629
00:40:18,190 --> 00:40:22,220
יש [לא ברור] מיוחד
נקרא [? עוזר? [לא ברור]].

630
00:40:22,220 --> 00:40:25,190
כאשר אתה לוחץ על זה, זה
הולך לפתוח שני קבצים.

631
00:40:25,190 --> 00:40:29,425
אחת מהן היא בכיתה ואחרת אחד
הוא נוף מקביל לזה.

632
00:40:29,425 --> 00:40:31,920
זה מאוד, מאוד מועיל.

633
00:40:31,920 --> 00:40:35,950
ובואו פשוט עוברים את קובץ .h.

634
00:40:35,950 --> 00:40:39,110
שליטה, זה [לא ברור] הוא היגיון.

635
00:40:39,110 --> 00:40:47,280
לחץ בקרה וגרור
תצוגת טקסט להכרזה.

636
00:40:47,280 --> 00:40:48,780
אנחנו הולכים לקרוא outputView ש.

637
00:40:48,780 --> 00:40:52,189

638
00:40:52,189 --> 00:40:53,670
חבר.

639
00:40:53,670 --> 00:40:59,420
אז הנה אנחנו הכרזנו חדשים
נכס לכיתת ViewController שלנו.

640
00:40:59,420 --> 00:41:02,300
והנכס החדש
רק תצוגת הטקסט

641
00:41:02,300 --> 00:41:05,000
שיצרנו בבניין הממשק.

642
00:41:05,000 --> 00:41:07,990
אז ככה שיכולנו
גישה לכל הנתונים

643
00:41:07,990 --> 00:41:13,630
ולתפעל את כל מה שיש בתוכו
צפה בפלט, וזה מדהים.

644
00:41:13,630 --> 00:41:19,260
>> אז בקוד האמיתי שלנו,
בואו נעשה עם זה משהו.

645
00:41:19,260 --> 00:41:23,810
אז זה זמן שבו אנחנו כמו הדפסה
את התוצאה הסופית למריו,

646
00:41:23,810 --> 00:41:28,020
אנחנו בכניסה לא שום דבר.

647
00:41:28,020 --> 00:41:30,080
אני אומר שאנחנו יכולים לשמור
הצהרת הרישום.

648
00:41:30,080 --> 00:41:41,490
בנוסף לכך, אנחנו
לשלוח את ההודעה אנחנו פשוט

649
00:41:41,490 --> 00:41:47,622
נוצר לתצוגת הפלט, ש
הוא ממשק משתמש TextView אנחנו פשוט נוצרו.

650
00:41:47,622 --> 00:41:48,746
עכשיו בואו לראות מה קורה.

651
00:41:48,746 --> 00:41:54,470

652
00:41:54,470 --> 00:41:56,620
וואו.

653
00:41:56,620 --> 00:41:59,130
יש לנו פירמידה באפליקציה עכשיו.

654
00:41:59,130 --> 00:42:06,720
>> כך שהמשתמש יכול לראות הפלט שלנו, כי
יש לנו להעתיק את הפלט מהקוד שלנו

655
00:42:06,720 --> 00:42:08,045
לממשק שלנו.

656
00:42:08,045 --> 00:42:10,950
זה די טוב.

657
00:42:10,950 --> 00:42:14,990
זה בעצם לא כל כך
מרגש כי אנחנו can--

658
00:42:14,990 --> 00:42:18,250
כל האפליקציה עושה היא
מראה פירמידה אליך,

659
00:42:18,250 --> 00:42:20,520
ואין שום דבר שאתה יכול לעשות בקשר לזה.

660
00:42:20,520 --> 00:42:22,330
זה לא מרגש במיוחד.

661
00:42:22,330 --> 00:42:27,840
אז עכשיו בואו נעשה את כפתור
שינקה את הנוף.

662
00:42:27,840 --> 00:42:30,290
נראה כי לחץ יהיה מועיל.

663
00:42:30,290 --> 00:42:33,270
גרור ושחרר.

664
00:42:33,270 --> 00:42:33,900
כפתור אחד.

665
00:42:33,900 --> 00:42:36,730

666
00:42:36,730 --> 00:42:37,320
לחצן שני.

667
00:42:37,320 --> 00:42:49,170

668
00:42:49,170 --> 00:42:52,052
>> לכן, כאשר אנו לחצו השמאל
כפתור, התצוגה צריכה לנקות.

669
00:42:52,052 --> 00:42:53,635
לא צריך להיות שום דבר על המסך.

670
00:42:53,635 --> 00:42:56,970
וכאשר אנו לחצו
הלחצן ימני, מריו,

671
00:42:56,970 --> 00:42:59,740
התצוגה עומדת להופיע שוב.

672
00:42:59,740 --> 00:43:05,510
אז ככה אנחנו גם עושים
דברים קסם, שליטה וגרור

673
00:43:05,510 --> 00:43:08,740
להכרזת הכיתה
בdirector-- העוזר

674
00:43:08,740 --> 00:43:11,600
במציג העוזר.

675
00:43:11,600 --> 00:43:18,620
במקרה זה אנו מפרטים
שזה צריך להיות פעולה.

676
00:43:18,620 --> 00:43:19,120
clearMario.

677
00:43:19,120 --> 00:43:21,650

678
00:43:21,650 --> 00:43:26,830
>> אז הנה אנחנו כבר נוצרו
פעולה נקראת clearMario,

679
00:43:26,830 --> 00:43:34,210
שהיא השיטה שתיקרא
בכל פעם שאנו לוחצים על הכפתור ברור.

680
00:43:34,210 --> 00:43:41,030
אז בלמעשה הקוד שלנו, בואו פשוט
לשים את טקסט הפלט ותצוגת הפלט

681
00:43:41,030 --> 00:43:44,620
לשום דבר, ודרך ש
היא תופיע להיות ברורה.

682
00:43:44,620 --> 00:43:47,500

683
00:43:47,500 --> 00:43:57,230
בנוסף לכך, בואו ליצור
שיטה אחרת, הנקראת runMario.

684
00:43:57,230 --> 00:44:00,140

685
00:44:00,140 --> 00:44:03,436
אה מצטער, שלא צריך להיות רכוש.

686
00:44:03,436 --> 00:44:12,107

687
00:44:12,107 --> 00:44:13,940
בסדר, כי במקרה ש
להיות פעולה גם כן.

688
00:44:13,940 --> 00:44:25,780

689
00:44:25,780 --> 00:44:34,740
>> וכאשר הפונקציה ש
בשם, אנחנו פשוט לרוץ מריו עשר.

690
00:44:34,740 --> 00:44:37,620

691
00:44:37,620 --> 00:44:39,780
אני מקווה שיהיה בסדר.

692
00:44:39,780 --> 00:44:41,120
האם זה לקמפל?

693
00:44:41,120 --> 00:44:43,920
כן.

694
00:44:43,920 --> 00:44:45,090
עכשיו יש לנו נוף.

695
00:44:45,090 --> 00:44:46,560
יש לנו פלט.

696
00:44:46,560 --> 00:44:50,040
ובואו רק לראות מה קורה.

697
00:44:50,040 --> 00:44:52,590
שנעלם.

698
00:44:52,590 --> 00:44:54,500
היא חזרה שוב.

699
00:44:54,500 --> 00:44:57,620
אז הנה יש לנו מפורט
איזה סוג של פונקציה

700
00:44:57,620 --> 00:45:00,400
ייקרא כאשר
אנחנו סוג ב משהו,

701
00:45:00,400 --> 00:45:03,160
כאשר אנו לוחצים על כפתור מסוים.

702
00:45:03,160 --> 00:45:07,890
זה בעצם
תכנית פעולת יעד

703
00:45:07,890 --> 00:45:12,510
לאירוע מונע
תכנות ב C. המטרה

704
00:45:12,510 --> 00:45:15,030
>> בנוסף לכך,
זה לא מאוד מרגש

705
00:45:15,030 --> 00:45:19,810
כי אנחנו לא באמת יכולים לשנות
כמה גבוה תהיה הפירמידה,

706
00:45:19,810 --> 00:45:23,640
אז כנראה שאנחנו רוצים איכשהו
לקבל קלט מהמשתמש

707
00:45:23,640 --> 00:45:29,490
ולשנות את הגובה של
פירמידה מבוססת על מה שהם פלט.

708
00:45:29,490 --> 00:45:32,900
אז אנחנו הולכים לעשות את זה.

709
00:45:32,900 --> 00:45:38,720
אז זה זמן שבו אנחנו קוראים runMario,
אנחנו פשוט לא קוראים מריו ישירות.

710
00:45:38,720 --> 00:46:06,280

711
00:46:06,280 --> 00:46:07,000
הכותרת של אחד זה.

712
00:46:07,000 --> 00:46:22,180

713
00:46:22,180 --> 00:46:23,700
>> נציג.

714
00:46:23,700 --> 00:46:25,160
זה מאוד מעניין.

715
00:46:25,160 --> 00:46:26,720
מהו ציר?

716
00:46:26,720 --> 00:46:28,950
אני הולך לשים עצמי כאן.

717
00:46:28,950 --> 00:46:31,038
ואנחנו הולכים לראות
מה זה אומר מאוחר יותר.

718
00:46:31,038 --> 00:46:46,380

719
00:46:46,380 --> 00:46:51,120
אז הנה יש לנו בעצם נוצרו
מקרה מסוים שנקרא התראת UI

720
00:46:51,120 --> 00:46:52,210
תצוגה.

721
00:46:52,210 --> 00:46:54,440
תצוגת התראת UI היא
בעצם מה שאתה רוצה

722
00:46:54,440 --> 00:46:58,940
לראות כל פעם שדבר אבא
ושואל אותך לקלט,

723
00:46:58,940 --> 00:47:03,080
כמו מה יקרה כאשר אתה מנסה
לרכוש משהו בחנות אפליקציות.

724
00:47:03,080 --> 00:47:14,250
>> בנוסף לכך, לאחר ש
ליצור אותו, אנחנו פשוט נציג את ההתראה.

725
00:47:14,250 --> 00:47:20,090

726
00:47:20,090 --> 00:47:22,568
בסדר, בואו פשוט במהירות
בדיקה שעבודה או לא.

727
00:47:22,568 --> 00:47:31,105

728
00:47:31,105 --> 00:47:32,140
זה מאוד מגניב.

729
00:47:32,140 --> 00:47:55,370

730
00:47:55,370 --> 00:47:59,120
עכשיו בואו למעשה ליצור
קלט שדה להתראת UI.

731
00:47:59,120 --> 00:48:01,170
כך אנחנו עושים את זה.

732
00:48:01,170 --> 00:48:07,490
ואנחנו צריכים
קלט מבט להתראה.

733
00:48:07,490 --> 00:48:09,020
מאוד מגניב.

734
00:48:09,020 --> 00:48:12,330
בואו נגיד 10.

735
00:48:12,330 --> 00:48:14,900
>> זה לא עושה שום דבר נכון
עכשיו בגלל השיחה בפועל

736
00:48:14,900 --> 00:48:17,770
לא שיניתי לביצוע מריו.

737
00:48:17,770 --> 00:48:23,470
אז זה הפך לקטן
קצת מוזר, כי בכל פעם ש

738
00:48:23,470 --> 00:48:30,790
אנחנו לוחצים על כפתור למטה, בכל פעם שאנו
ללחוץ על כפתור בתצוגת ההתראה,

739
00:48:30,790 --> 00:48:35,560
משהו צריך לקרות,
אבל זה לא קורה.

740
00:48:35,560 --> 00:48:37,220
איך לתפוס את זה?

741
00:48:37,220 --> 00:48:41,280
איך אנחנו יודעים שהמשתמש
דחה תצוגת התראה

742
00:48:41,280 --> 00:48:45,630
וכבר נכנס מספר, כי
עכשיו שום דבר לא באמת קורה.

743
00:48:45,630 --> 00:48:50,450
>> ובכן, אתה יכול לנחש
זה נכון, משלחת.

744
00:48:50,450 --> 00:48:55,440
אז בנוסף לכל
הצהרות אלה,

745
00:48:55,440 --> 00:49:03,190
אנחנו צריכים להוסיף משלחת חדשה ל
זה נקרא ציר תצוגת התראת UI.

746
00:49:03,190 --> 00:49:06,440
כך שכל אחת
אינטראקציה או אירוע

747
00:49:06,440 --> 00:49:10,190
שאנחנו הולכים יש לי
עם הנוף להתראת UI

748
00:49:10,190 --> 00:49:14,100
הולך להיות מטופלים
על פי המעמד שלנו גם כן.

749
00:49:14,100 --> 00:49:26,297
>> אז בנוסף לזה, יהיה
לחצן לחץ על צג התראה במדד.

750
00:49:26,297 --> 00:49:34,260

751
00:49:34,260 --> 00:49:37,730
זה הגיע.

752
00:49:37,730 --> 00:49:42,020
אז במקרה שיש לנו
already-- כך שיש לנו

753
00:49:42,020 --> 00:49:46,210
גילה פרוטוקול ש
יהיה לטפל באירוע כאשר

754
00:49:46,210 --> 00:49:51,320
אנו לחצו על כפתור Done
במבט הערני.

755
00:49:51,320 --> 00:49:55,976
אז בכל פעם שאנו דוחים את
מבט ערני, זה צריך לקרות.

756
00:49:55,976 --> 00:49:57,350
תן לי רק לבדוק את זה מהר מאוד.

757
00:49:57,350 --> 00:50:16,220

758
00:50:16,220 --> 00:50:19,300
ובכן אכן, הגענו לכאן.

759
00:50:19,300 --> 00:50:22,210
>> אז הנה, מה שאנחנו לא יהיו
ממש מקבל הוא למעשה

760
00:50:22,210 --> 00:50:43,120
לקבל the-- אז אנחנו רוצים לצאת
הטקסט שיש לנו בעבר

761
00:50:43,120 --> 00:50:45,350
נכנס בתצוגת ההתראה.

762
00:50:45,350 --> 00:50:48,505
ומבוסס על טקסט, אנחנו
הולך להציג מריו.

763
00:50:48,505 --> 00:50:52,336

764
00:50:52,336 --> 00:50:55,480
זה מתברר מהר מאוד
אם זה באמת עובד או לא.

765
00:50:55,480 --> 00:50:59,476
אז במקרה כזה, אם אנחנו קלט,
נניח, 10, אנחנו צריכים לראות 10.

766
00:50:59,476 --> 00:51:02,740

767
00:51:02,740 --> 00:51:05,210
>> טוב מאוד, יש לנו מספר כאן.

768
00:51:05,210 --> 00:51:06,470
זה די טוב.

769
00:51:06,470 --> 00:51:16,840
עכשיו השלב האחרון יהיה be-- אז
הצעד אחרון שאנחנו צריכים לעשות עכשיו

770
00:51:16,840 --> 00:51:21,100
הוא פשוט קורא מריו עם
רמה מבוססת על הקלט

771
00:51:21,100 --> 00:51:23,270
שיש לנו לשים לעין התראה.

772
00:51:23,270 --> 00:51:26,920
אז אנחנו צריכים להמיר
מחרוזת זו לתוך iOS.

773
00:51:26,920 --> 00:51:33,820

774
00:51:33,820 --> 00:51:35,496
גלישת סטטי היא מאוד מדהימה.

775
00:51:35,496 --> 00:51:44,930

776
00:51:44,930 --> 00:51:51,182
ואז אנחנו פשוט קוראים עצמיים
ערך marioWithLevels.

777
00:51:51,182 --> 00:51:54,550

778
00:51:54,550 --> 00:51:56,284
בואו לראות יהיה ש
באמת עובד או לא.

779
00:51:56,284 --> 00:51:59,070

780
00:51:59,070 --> 00:52:01,550
>> אנחנו כבר נתנו פירמידה.

781
00:52:01,550 --> 00:52:04,785
בואו ננסה לשנות את הגובה.

782
00:52:04,785 --> 00:52:06,530
זה באמת עובד.

783
00:52:06,530 --> 00:52:07,610
זה די מגניב.

784
00:52:07,610 --> 00:52:10,420
כך שעכשיו אתה יכול פשוט
קלט כל ערך שאתה רוצה.

785
00:52:10,420 --> 00:52:12,440
בואו נגיד ארבעה.

786
00:52:12,440 --> 00:52:14,260
זה די מדהים.

787
00:52:14,260 --> 00:52:17,090
אז זה בעצם
דוגמא ממש מהירה

788
00:52:17,090 --> 00:52:23,170
לכיצד ליצור פרויקט בקוד של
ואיך להתניע ככה ממש מהר

789
00:52:23,170 --> 00:52:26,220
כמה אירועים ממש פשוטים ופונקציות.

790
00:52:26,220 --> 00:52:28,840
>> אז המקור הולך
כדי לשים מקוון מאוחר יותר.

791
00:52:28,840 --> 00:52:33,400
אז אם אתה מעוניין
באופן iOS מריו עובד,

792
00:52:33,400 --> 00:52:38,360
אני הולך לשים בדיוק אותו הדבר
פרויקטים על אתר CS50 מאוחר יותר.

793
00:52:38,360 --> 00:52:41,260
אנחנו עושים בעצם עם
הקיץ, ולפני שנסיים

794
00:52:41,260 --> 00:52:45,190
אני רק רוצה לציין שאתם ל
כמה משאבים באמת מדהים ש

795
00:52:45,190 --> 00:52:47,550
זמין באופן מקוון.

796
00:52:47,550 --> 00:52:52,270
>> ברור תיעוד Apple
הולך להיות מאוד מועיל.

797
00:52:52,270 --> 00:52:57,630
אבל בנוסף לזה, אני במיוחד
ממליץ ארבעה מקורות, בית ספר קוד,

798
00:52:57,630 --> 00:53:02,120
בית עץ, קטעי וידאו וAppCoda WWDC.

799
00:53:02,120 --> 00:53:07,270
בית ספר קוד ובית העץ הם
שני אתרי האינטרנט מחנכים,

800
00:53:07,270 --> 00:53:10,210
שדווקא להתמקד
בהנדסת תוכנה.

801
00:53:10,210 --> 00:53:16,930
במיוחד עבור בית ספר קוד, הם
יש לי הדרכה ממש טובה על iOS.

802
00:53:16,930 --> 00:53:19,550
>> זאת דוגמא ממש מהירה לזה.

803
00:53:19,550 --> 00:53:22,980
הם בעצם ליצור באמת cute--
מסתכל שiPhone הקטן והחמוד

804
00:53:22,980 --> 00:53:24,920
אחי שם, זה די מדהים.

805
00:53:24,920 --> 00:53:31,010
והדרך בה הם מסבירים Objective
תחביר C הוא ברור לחלוטין.

806
00:53:31,010 --> 00:53:32,230
בית העץ הוא אותו הדבר.

807
00:53:32,230 --> 00:53:34,660
וAppCoda הוא פורום.

808
00:53:34,660 --> 00:53:38,130
זה בעצם בלוג שנוהל
על ידי C Objective באמת חווה

809
00:53:38,130 --> 00:53:39,120
מתכנת.

810
00:53:39,120 --> 00:53:43,950
וכל הדרכות אלה בAppCoda הן
די קצר וקל ליישום,

811
00:53:43,950 --> 00:53:45,390
מומלץ מאוד.

812
00:53:45,390 --> 00:53:47,700
>> ואם אתה מפתח,
בהחלט ללכת לבדוק

813
00:53:47,700 --> 00:53:55,660
כיצד סרטוני WWDC שבו אתה יכול
ללמוד על תכנות iOS האחרון

814
00:53:55,660 --> 00:53:58,250
טכניקות, APIs וספריות.

815
00:53:58,250 --> 00:54:02,850
אז זה פחות או יותר
זה לסמינר.

816
00:54:02,850 --> 00:54:03,820
תודה רבה לך.

817
00:54:03,820 --> 00:54:08,040
ואני מקווה שיהיה לך כיף
יצירת האפליקציה iOS שלך.

818
00:54:08,040 --> 00:54:09,302