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

2
00:00:11,420 --> 00:00:13,590
>> Tianyu లియు: హే, ఎలా వార్తలు
అది అందరికీ జరగబోతోంది?

3
00:00:13,590 --> 00:00:20,250
మరియు ఈ iOS App ఉంది
లక్ష్యం సి సదస్సు ప్రోగ్రామింగ్.

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
అవును, అది ఉత్తేజితులులవవద్దు.

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
ఆబ్జెక్టివ్ సి బాగా ఉపయోగిస్తుంది, ఉంది
స్విఫ్ట్ అనే కొత్త భాష,

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 లో ఉపయోగించే ప్రతిదీ
ఆబ్జెక్టివ్ సి లోకి అనువదించవచ్చు

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. కాబట్టి,

22
00:01:19,790 --> 00:01:22,860
మీరు CS50 తీసుకున్న నుండి
ఈ అప్ ఇప్పటివరకు, మీరు ఇప్పటికే

23
00:01:22,860 --> 00:01:26,500
కనీసం 40% ఆబ్జెక్టివ్ సి తెలుసు.

24
00:01:26,500 --> 00:01:30,720
కూడా, ఆపిల్ ఒక నిజంగా ఉంది
iOS కోసం బలమైన API.

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
కానీ ఎలా శక్తివంతమైన వార్తలు
iOS API ఉంటుంది.

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
నిర్మాణ సమయంలో ఆలోచించవచ్చు మీ
ఆబ్జెక్టివ్ సి లో చివరి ప్రాజెక్ట్

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
ఇది Android, పేరు ఇష్టం లేదు
ప్రతిదీ అందంగా ముక్కలైన.

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
మీరు చాలా సులభంగా పోర్ట్ ఐప్యాడ్ ఆ,
ఐప్యాడ్ మినీ, లేదా వివిధ ఐఫోన్ పరిమాణాలు.

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
మీరు కేవలం ఒక ఐఫోన్ జరపవచ్చని
మరియు, హే మీ స్నేహితుడు చెప్పండి

46
00:02:38,920 --> 00:02:40,250
ఈ నేను తయారు అనువర్తనం ఉంది.

47
00:02:40,250 --> 00:02:43,860
మీరు ఏ ఆ చేయవచ్చు
nice ఇది డెస్క్టాప్ అనువర్తనాలను.

48
00:02:43,860 --> 00:02:48,870
>> All right, ఇప్పుడు యొక్క నిజానికి పొందుటకు వీలు
భాష ఆబ్జెక్టివ్ సి లోకి

49
00:02:48,870 --> 00:02:52,910
సో ఎందుకు మేము ప్రారంభం లేదు
కొన్ని నిజంగా ప్రాథమిక సింటాక్స్.

50
00:02:52,910 --> 00:02:57,410
నేను ఆబ్జెక్టివ్ ముందు చెప్పినట్లుగా
సి ఇది 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
అయితే, ఆబ్జెక్టివ్ సి
, సి పూర్తిగా కాదు

60
00:03:33,400 --> 00:03:36,640
మరియు ఏదో ఉంది అని
అసహజ యొక్క దాని గురించి ఉంది.

61
00:03:36,640 --> 00:03:42,340
>> మొదటి ఒకటిగా మీరు ఉన్నప్పుడు ఆ
సి ప్రోగ్రామింగ్ చేయడం, మీరు సాధారణంగా కాల్

62
00:03:42,340 --> 00:03:46,310
చేర్చాలని మరియు తరువాత ఒక లైబ్రరీ పేరు.

63
00:03:46,310 --> 00:03:49,860
కానీ ఆబ్జెక్టివ్ సి లో మీరు దిగుమతి కాల్.

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
మీరు ఒక అందమైన అసహజ కలిగి ఉంది
క్షమించాలి మీరు ఒక అందమైన అదృష్టము 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
మరియు కన్సోల్ ప్రింటింగ్ కొద్దిగా ఉంది
వివిధ ఎందుకంటే మేము printf కాల్ సి లో,

77
00:04:29,980 --> 00:04:33,350
కానీ ఆబ్జెక్టివ్ సి లో మేము [వినబడని] కాల్.

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
బాగా ఆ బయటకు వస్తాడు
ఆబ్జెక్టివ్ సి నిజానికి

82
00:04:44,060 --> 00:04:50,040
ఒక NS దాదాపు ఉపసర్గ ఉంది
ప్రతిదీ, ప్రతి ప్రాథమిక డేటా రకం,

83
00:04:50,040 --> 00:04:52,690
NSDictionary, NSArray, NSString.

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
ఒక కంపెనీ పేరు
భాష ఆబ్జెక్టివ్ సి జన్మించాడు.

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
>> కూడా weirder కాబట్టి ఆ ఏదో
కంటే ఫంక్షన్ ప్రకటన.

90
00:05:16,840 --> 00:05:22,600
ఈ మేము ఏమి నుండి చాలా భిన్నంగా ఉంటుంది
, సి లో చూడండి ఇక్కడ నిజానికి ఎందుకంటే

91
00:05:22,600 --> 00:05:25,190
ఇకపై సి వంటి అనిపించడం లేదు.

92
00:05:25,190 --> 00:05:28,810
మీరు ఇక్కడ ఏమి
ఈ ఒక తూటా బిందువు కాదు మార్గం,

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
ఆపిల్ కోరిక ఎందుకు చూడటానికి వెళ్ళడం
చాలా త్వరగా చేయాలని.

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
>> అసలైన, పిలుపునిచ్చింది
ఆబ్జెక్టివ్ సి ఫంక్షన్

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
అని పద్ధతులు లేదా నమూనాలతో
ఆబ్జెక్టివ్ సి ఆబ్జెక్టివ్ సి ద్వారా ఉపయోగిస్తారు

150
00:08:57,110 --> 00:09:03,110
ఆబ్జెక్టివ్ సి, కాదు అంటారు
సి, ఒక నిజంగా మంచి కారణం కోసం.

151
00:09:03,110 --> 00:09:07,560
>> మేము పొందడానికి ముందు
ఆబ్జెక్టివ్ సి సింటాక్స్,

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
, యొక్క కేవలం ట్విట్టర్ లేదా Facebook పిలవబడు
మీరు చూడండి ప్రతి దృశ్యం ఒక వస్తువు.

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
మేము నిజంగా చేస్తున్న
మేము నిజానికి ఉన్నప్పుడు ప్రోగ్రామింగ్

191
00:11:39,660 --> 00:11:42,830
ఒక S కోడ్ చేస్తోంది
తరువాత సెషన్ ప్రోగ్రామింగ్.

192
00:11:42,830 --> 00:11:48,120
>> Well ఆ పాటు,
ఆబ్జెక్ట్ ఓరియంటెడ్ ప్రోగ్రామింగ్

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
వస్తువు దగ్గర ఉండాలి
పిల్లి తరగతి తప్పక

213
00:13:07,930 --> 00:13:11,260
కొన్ని లక్షణాలు మరియు పద్ధతులు ఉన్నాయి.

214
00:13:11,260 --> 00:13:17,300
లక్షణాలు తప్పక ఏ విధమైన
తరగతి దగ్గర పిల్లి కలిగి ఉండాలి?

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
కొన్ని శీఘ్ర ఉదాహరణలు చేజ్ ఉంటుంది
మౌస్, చేపలు తినడానికి లేదా కేవలం మిఅవ్.

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
మీరు కేవలం, వస్తువు మీద మియావ్ కాల్
ఇది మీరు కేవలం రూపొందించినవారు పిల్లి.

228
00:14:16,640 --> 00:14:19,020
>> బహుశా మీరు ముద్రిస్తుంది
"హలో వరల్డ్ వంటి ఏదో!

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
All right, యొక్క కేవలం వీలు
కొన్ని వివరాలు పొందడానికి

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
>> యొక్క కేవలం ఇక్కడ మియావ్ చెప్పటానికి లెట్
కేవలం ముద్రించాలా చేస్తుంది

273
00:17:00,150 --> 00:17:01,740
"హలో ప్రపంచ!" కన్సోల్ కు.

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
విధంగా మీరు ఒక సృష్టించడానికి ఒక తరగతి ఉపయోగించవచ్చు
ఆబ్జెక్టివ్ సి వస్తువు ఇక్కడ రాస్తారు.

279
00:17:26,880 --> 00:17:30,730
>> మీరు మొదటి పేర్కొనవచ్చు
ఈ ఒక పిల్లి పాయింటర్ ఉంది

280
00:17:30,730 --> 00:17:38,700
ఆబ్జెక్టివ్ సి లో ప్రతి వస్తువు ఎందుకంటే
చివరకు ఒక పాయింటర్ వలె అమలు చేయబడుతుంది.

281
00:17:38,700 --> 00:17:46,210
మీరు తరగతి కాల్ వాటిని కాల్
ప్రధానంగా malloc ఇది alloc, వంటి,

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
ఆబ్జెక్టివ్ సి లో ఏ పద్ధతి కాల్

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.

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
Well నిజానికి, మీరు కలిగి
ఇప్పటికే ఆ ముందు చేసిన.

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
మీరు కేవలం Facebook కు వెళ్ళి
ఒకసారి మరియు అది పూర్తి.

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
ఆ బటన్ క్లిక్ చేసినప్పుడు ఆ,
అని ఫంక్షన్ కాల్ "హలో ప్రపంచ!"

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
ఆబ్జెక్టివ్ సి లో ఉన్నాయి
మూడు వేర్వేరు చిత్రములు

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
కాబట్టి మేము ఆ భాగం skip చూడాలని.

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
కానీ ఈ సంఘటనలు ఇస్తారు
ఆపిల్ ద్వారా మీరు ప్రారంభించడానికి.

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
లక్ష్య C. వెల్
నిజానికి, ప్రతి అనువర్తనం

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
తర్వాత మీరు తర్వాత అనువర్తనం దగ్గరగా, లేదా
మీరు నిద్ర ఐఫోన్ చాలు.

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
ఈ నియమావళి ప్రత్యేకంగా అంటారు
టేబుల్ వ్యూ [వినబడని] పాత్రకు ఎంచుకోండి

388
00:24:30,890 --> 00:24:35,480
[వద్ద? సూచిక?] [? గత. ?] కాబట్టి ఈ ఒక
క్యాచ్ కలగవచ్చునని ఉన్నప్పుడు మీరు

389
00:24:35,480 --> 00:24:39,710
నిజానికి ఒక నిర్దిష్ట నొక్కండి
మీ టేబుల్ వ్యూ లో సెల్,

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
కొన్ని చాలా ప్రాథమిక వాక్యనిర్మాణం కవర్ మరియు
ఆబ్జెక్టివ్ సి ప్రాథమిక భావన

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
కాబట్టి s కోడ్ వాస్తవానికి ఒక ఉంది
కొద్దిగా అధిక

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
నేను అత్యంత మీరు ఒక Mac కలిగి సిఫారసు.

404
00:25:29,630 --> 00:25:33,930
న iOS అభివృద్ధి చేయడం ఎందుకంటే
Windows నిజంగా కష్టం, నిజంగా ఉంది.

405
00:25:33,930 --> 00:25:37,560
Doable ఉంది, కానీ అది నిజంగా కష్టం.

406
00:25:37,560 --> 00:25:40,610
మరియు మీరు ఖచ్చితంగా దీన్ని
గ్రా మార్చు ఉపయోగించడానికి వద్దు.

407
00:25:40,610 --> 00:25:47,950
కాబట్టి s కోడ్ మనం కలిగి
అనేక వివిధ ప్రాంతాల్లో.

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
ఈ ప్రాంతంలో చాలా పోలి గ్రా ఎడిట్ ఉంది
గ్రా మార్చు కంటే కానీ చాలా మంచి.

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
కనుక ఇది నిజంగా మంచిది వార్తలు
కోడ్ వాస్తవానికి ఇప్పటికే ఉంది

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
ఇక్కడ మేము వద్దు
కోర్ డేటా ఉపయోగించి తనిఖీ.

441
00:27:57,060 --> 00:28:00,170
కోర్ డేటా ప్రాథమికంగా ఒక databasing iOS ఉంది.

442
00:28:00,170 --> 00:28:05,360
మీరు కోర్ డేటా చేస్తే, వార్తలు
కోడ్ నిర్వచించే అన్నారు

443
00:28:05,360 --> 00:28:07,710
మీరు చాలా క్లిష్టమైన తరగతులు.

444
00:28:07,710 --> 00:28:12,740
కాబట్టి మేము ఉన్నాము, సాధారణ ప్రతిదీ ఉంచడానికి
కేవలం కోర్ డేటా లేకుండా చేయ

445
00:28:12,740 --> 00:28:15,290
ప్రస్తుతం.

446
00:28:15,290 --> 00:28:18,030
>> మేము చేయబోతున్నామని సమస్య
ఉపయోగించి సమస్య ఆ ఉంది

447
00:28:18,030 --> 00:28:23,770
మేము సృష్టిస్తున్నారు వుంటుంది చూడాలని మేము ఆ
ప్రధానంగా సి నుండి మారియో దిగుమతి చేయదలిచారా

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
అది ఐఫోన్, ఐప్యాడ్ లేదా సామాన్యమైనది?

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
>> All right, యొక్క చూద్దాం
మా కోడ్ లోపల ఏదో.

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
గ్రా మార్చు పోలి.

468
00:29:38,530 --> 00:29:41,340
కానీ మీరు చూడగలరు
వాక్యనిర్మాణం హైలైటింగ్ బహుశా ఉంది

469
00:29:41,340 --> 00:29:42,780
కొద్దిగా NICER.

470
00:29:42,780 --> 00:29:45,610
మరియు అది నిజానికి మరింత వార్తలు
గ్రా ఎడిటింగ్ కంటే శక్తివంతమైన.

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
All right, మేము చూడగలరు గా,
కన్సోల్ ఇక్కడే ఉంది.

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
ఒక ఐఫోన్ సిమ్యులేటర్ వస్తుంది.

481
00:30:25,850 --> 00:30:29,820
కాబట్టి మీరు ఒక కలిగి అవసరం లేదు
ఐఫోన్, మీ ప్రాజెక్ట్ ప్రయత్నించండి

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
>> మేము ఇక్కడ "హలో వరల్డ్ !!!" ఒక లేబుల్ డ్రాప్

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
ఇక్కడ మేము "హలో వరల్డ్ !!!" కలిగి

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
ఈ ఎంత శక్తివంతమైన
ఇంటర్ఫేస్ బిల్డర్ ఉంటుంది.

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
కేవలం ఇంటర్ఫేస్ బిల్డర్ ఉపయోగించి.

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
కాబట్టి ఈ సంఘటనలు ఆపిల్
ప్రారంభం మీకిచ్చిన.

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
All right, యొక్క ఇక్కడ ఏదో ఒకటి చూద్దాం.

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
Well, నిజానికి, మేము అది ఒక అవుట్పుట్ చూడండి లేదు.

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
మేము ఒక nice ఉన్నాయి
ఇక్కడే కొద్దిగా పిరమిడ్.

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
మేము చూసిన లేదు ఎందుకంటే
ఐఫోన్ అనువర్తనం నుండి ఏదైనా.

601
00:38:37,500 --> 00:38:42,120
>> కాబట్టి మీరు నిజంగా 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
ఈ మీరు చూసే ఉంది
ఇది "హలో వరల్డ్ !!!" ఉంది

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 ఒక UI ఉంది.

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
ఈవెంట్ నడిచే
ఆబ్జెక్టివ్ సి ప్రోగ్రామింగ్

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
>> Well, మీరు ఊహించిన ఉండవచ్చు
ఇది కుడి, ప్రతినిధి బృందం.

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
మేము పూర్తయింది బటన్ క్లిక్
హెచ్చరిక దృశ్యం.

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
Well, నిజానికి, మేము ఇక్కడ చేరుకున్నారు.

759
00:50:19,300 --> 00:50:22,210
>> ఇక్కడ, మనం రెడీ
నిజానికి నిజానికి పొందండి

760
00:50:22,210 --> 00:50:43,120
కాబట్టి మనం పొందడానికి కావలసిన వాట్ పొందండి
మేము గతంలో కలిగి టెక్స్ట్

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
ఇప్పుడు చివరి దశలో కాబట్టి ఉండబోతుంది ఉంటుంది
చివరి దశలో మేము ఇప్పుడు చెయ్యాల్సిన

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
కోసం s కోడ్ లో ఒక ప్రాజెక్ట్ సృష్టించడానికి ఎలా
మరియు నిజంగా త్వరగా అప్ WIRE ఎలా

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
>> సహజంగానే ఆపిల్ డాక్యుమెంటేషన్
చాలా సహాయకారిగా అన్నారు.

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-- సృష్టించడానికి
ఆ చిన్న అందమైన ఐఫోన్ చూడండి

804
00:53:22,980 --> 00:53:24,920
అక్కడ వాసి, అది చాలా అద్భుతంగా ఉంటుంది.

805
00:53:24,920 --> 00:53:31,010
మరియు మార్గం వారు ఆబ్జెక్టివ్ వివరించేందుకు
సి సింటాక్స్ ఖచ్చితంగా స్పష్టం.

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
ఇది వాస్తవానికి అమలు ఒక బ్లాగ్ వార్తలు
ఒక నిజంగా అనుభవంలోకి ఆబ్జెక్టివ్ సి ద్వారా

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
పద్ధతులు, API లు మరియు గ్రంధాలయాలు.

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