1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [సెమినార్] [iOS: ఒక బాస్ ను రాయడం]

2
00:00:02,000 --> 00:00:04,000
[టామీ MacWilliam] [హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:04,000 --> 00:00:08,000
[ఈ CS50 ఉంది.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> All right, ప్రతి ఒక్కరూ, iOS స్వాగతం: ఒక బాస్ ను రాయడం.

5
00:00:12,000 --> 00:00:16,000
ఈ సదస్సు ఐఫోన్ అనువర్తనాలను రాయడం దృష్టి అన్నారు

6
00:00:16,000 --> 00:00:19,000
మరియు బదులుగా ఐప్యాడ్ కోసం Apps రాయడం, అందువలన మేము ప్రధానంగా నడవడానికి వెళుతున్న

7
00:00:19,000 --> 00:00:23,000
ఒక అనువర్తనం చేయడానికి ఎలా జంట వివిధ ఉదాహరణలు, ఈడ్పు టాక్ TOE వంటి సాధారణ ఆట,

8
00:00:23,000 --> 00:00:26,000
లేదా మీరు న్యూస్ రీడర్ ఏదో వంటి ఒక అనువర్తనం చేయడానికి మరింత ఆసక్తి ఉంటే

9
00:00:26,000 --> 00:00:30,000
లేదా నేను కూడా దాని గురించి చర్చ ఉంటుంది ఇంటర్నెట్ సంకర్షణ ఏదో.

10
00:00:30,000 --> 00:00:32,000
ఇక్కడ మా సంక్షిప్త ఎజెండా ఉంది.

11
00:00:32,000 --> 00:00:36,000
>> IOS Apps, ఆబ్జెక్టివ్-C అనే భాషలో వ్రాయబడిన

12
00:00:36,000 --> 00:00:39,000
మరియు ఈ, సి పోలి కానీ నిజంగా అన్ని వద్ద కొద్దిగా ఉంటుంది

13
00:00:39,000 --> 00:00:41,000
కాబట్టి మేము భాష గురించి కొద్దిగా మాట్లాడుతూ వస్తుంది

14
00:00:41,000 --> 00:00:45,000
తరువాత ఎలా XCode అని ఈ అనువర్తనం కార్యక్రమం ఉపయోగించి ఐఫోన్ అనువర్తనాలను రూపొందించడానికి,

15
00:00:45,000 --> 00:00:48,000
మీరు ఇంకా అది డౌన్లోడ్ కాలేదు ఉంటే ఇది ఇప్పుడు డౌన్లోడ్ ప్రారంభించేందుకు సంకోచించకండి.

16
00:00:48,000 --> 00:00:50,000
ఇది అనేక గిగాబైట్ల ఉంది.

17
00:00:50,000 --> 00:00:54,000
ఇది App దుకాణం లో ఉచితంగా ఉండాలి, కాబట్టి మీరు Mac కలిగి ఉంటుంది

18
00:00:54,000 --> 00:00:57,000
ఆదర్శప్రాయంగా OS X యొక్క తాజా వెర్షన్ అమలు

19
00:00:57,000 --> 00:00:59,000
మీరు కాకపోతే, సమస్య లేదు.

20
00:00:59,000 --> 00:01:02,000
మీ అందుబాటులో సైన్స్ సెంటర్ లో Macs కలిగి

21
00:01:02,000 --> 00:01:05,000
XCode ఇన్స్టాల్, మరియు తద్వారా అభివృద్ధి కోసం ఆ ఉపయోగించడానికి సంకోచించకండి. తో

22
00:01:05,000 --> 00:01:07,000
మీరు ఒక అనువర్తనం అనుకున్న కాని ఒక Mac లేకపోతే, ఆందోళన చెందకండి.

23
00:01:07,000 --> 00:01:09,000
ఆ కోసం క్యాంపస్ వనరులు పుష్కలంగా ఉన్నాయి.

24
00:01:09,000 --> 00:01:15,000
కాబట్టి అప్పుడు మేము మీరు చేయవచ్చు వివిధ Apps యొక్క 2 పెద్ద ఉదాహరణలు కవర్ చూడాలని.

25
00:01:15,000 --> 00:01:19,000
ఆబ్జెక్టివ్-C C. ఒక సూపర్ సెట్ అని ఏమి సాంకేతికంగా

26
00:01:19,000 --> 00:01:24,000
ఏ సి కోడ్ కూడా చెల్లుబాటు అయ్యే ఆబ్జెక్టివ్-C కోడ్ అర్థం.

27
00:01:24,000 --> 00:01:29,000
అంటే వాహిక యొక్క రకం C. కొన్ని అదనపు లక్షణాలు పై టేపు అర్థం

28
00:01:29,000 --> 00:01:33,000
వీటిలో కొన్ని లక్షణాలు ఎప్పుడైనా మళ్ళీ malloc రాయడానికి చేయడంలో ఉంటాయి, దేవుని ధన్యవాదాలు

29
00:01:33,000 --> 00:01:36,000
ఏ ఆ స్టుపిడ్ గమనికలు గురించి ఆందోళన అవసరం మరియు వాటిని విడుదల చేసి అన్ని అంశాలను

30
00:01:36,000 --> 00:01:40,000
మీరు C గురించి అసహ్యించుకున్నారు మరియు ఇది యొక్క రకం ఆబ్జెక్టివ్-C లో పోతుంది.

31
00:01:40,000 --> 00:01:43,000
>> ఇప్పుడు, ఆబ్జెక్టివ్-C కూడా, చాలా పెద్ద ప్రమాణం గ్రంథాలయం ఉంది

32
00:01:43,000 --> 00:01:47,000
కాబట్టి మీరు ఆబ్జెక్టివ్-C యొక్క ఉచిత లోపల పొందండి చాలా కార్యాచరణ ఉంది.

33
00:01:47,000 --> 00:01:50,000
మేము PHP రాయడం ఉన్నప్పుడు గుర్తుంచుకో మేము నుంచి గమనించి

34
00:01:50,000 --> 00:01:54,000
మీరు చేయవచ్చు ఈ క్రేజీ విషయాలను దిగ్గజం లైబ్రరీ ఈ చిన్న భాష.

35
00:01:54,000 --> 00:01:56,000
ఇదే iOS జరుగుతుంది.

36
00:01:56,000 --> 00:01:59,000
అక్కడ బౌద్ధ క్యాలెండర్ అంశాలని వస్తువులు, మరియు నిజంగా ఏదైనా

37
00:01:59,000 --> 00:02:05,000
మీరు బహుశా బహుశా ఆబ్జెక్టివ్-C యొక్క అమలు లో ఇప్పటికే ఉంది కూడా ఆలోచించవచ్చు.

38
00:02:05,000 --> 00:02:08,000
ఆబ్జెక్టివ్-C యొక్క లక్ష్యం భాగంగా ఏదో సూచిస్తున్నారని

39
00:02:08,000 --> 00:02:11,000
విషయ ఆధారిత ప్రోగ్రామింగ్ అని.

40
00:02:11,000 --> 00:02:14,000
ఈ కొత్త విధానం యొక్క రకం, కాని మేము నిజంగా ఎక్కువగా నేర్చుకున్నాడు చేసిన

41
00:02:14,000 --> 00:02:17,000
ఇప్పటికే ఈ భావనలు చాలా.

42
00:02:17,000 --> 00:02:19,000
విషయ ఆధారిత ప్రోగ్రామింగ్ వెనుక ఆలోచన మీరు రూపొందించాలని చూడాలని ఉంది

43
00:02:19,000 --> 00:02:23,000
ఈ విషయాలు చుట్టూ మీ కోడ్ చాలా, తరగతులు అని

44
00:02:23,000 --> 00:02:26,000
మరియు ఈ తరగతులు నిజంగా structs ఉన్నత శిఖరాలను అందుకున్న.

45
00:02:26,000 --> 00:02:30,000
ఒక struct లోపలి మేము ప్రధానంగా ఇక్కడ చెప్పారు, ఒక విషయం

46
00:02:30,000 --> 00:02:32,000
మరియు ఈ విషయం సభ్యులు ఉండవచ్చు.

47
00:02:32,000 --> 00:02:35,000
ఉదాహరణకు, ఒక లింక్ జాబితాలో ఒక నోడ్ ఇతర విషయాల్లో కాలేదు

48
00:02:35,000 --> 00:02:38,000
ఒక విలువ వంటి జాబితాలో తదుపరి నోడ్ ఒక పాయింటర్,

49
00:02:38,000 --> 00:02:44,000
మరియు కలిసి పాయింటర్ మరియు ఆ విలువను ఒక struct ఈ ఒక సందర్భంలో కూర్చిన ఆ.

50
00:02:44,000 --> 00:02:47,000
తప్ప తరగతులు పోలి ఉంటాయి

51
00:02:47,000 --> 00:02:50,000
తరగతులు కూడా వాటిలో లోపల విధులు ఉన్నాయి.

52
00:02:50,000 --> 00:02:54,000
మేము ఒక struct డిక్లేర్డ్, మేము మాత్రమే Int n లేదా తదుపరి నోడ్ * చెప్పొచ్చు.

53
00:02:54,000 --> 00:02:57,000
>> ఇప్పుడు ఆబ్జెక్టివ్-C తో మేము నిజంగా విధులు ఉంచవచ్చు

54
00:02:57,000 --> 00:02:59,000
ఆ విషయాలను లోపల.

55
00:02:59,000 --> 00:03:03,000
తరగతులు చేయవచ్చు మరొక విషయమేమంటే వారు ఇతర తరగతుల నుంచి వారసత్వంగా డేటా చేయవచ్చు ఉంది.

56
00:03:03,000 --> 00:03:07,000
ఉదాహరణకు, ఆబ్జెక్టివ్-C తరగతులు అంతర్నిర్మిత కొంత చూడటం వస్తుంది.

57
00:03:07,000 --> 00:03:11,000
వాటిలో ఒకటి, స్క్రీన్ చూడండి ప్రాతినిధ్యం తరగతి ఉంటుంది

58
00:03:11,000 --> 00:03:14,000
అందువలన విధంగా నేను నా స్వంత అభిప్రాయం అమలుచెయ్యాలని

59
00:03:14,000 --> 00:03:18,000
మేము ప్రధానంగా ఆపిల్ వద్ద మీద ఎవరైనా, బహుశా నిజంగా నైస్ ప్రజలు సే,

60
00:03:18,000 --> 00:03:21,000
నాకు ఈ తరగతి రాశారు, మరియు అది బటన్లు ప్రదర్శించడం వంటి వాటిని నిర్వహిస్తుంది

61
00:03:21,000 --> 00:03:25,000
లేదా స్క్రీన్ అభివర్ణిస్తూ, మరియు మేము నిజంగా pained ఉంటుంది

62
00:03:25,000 --> 00:03:28,000
అన్ని కార్యాచరణను మేమే అమలు, అందువలన కేవలం ద్వారా

63
00:03:28,000 --> 00:03:31,000
డేటా వారసత్వంగా మేము మీరు ఆ తరగతి లో చేసిన ప్రతిదీ చెప్పగలదు

64
00:03:31,000 --> 00:03:34,000
నేను కూడా నా క్లాస్ లోపల మీరు, ఆ తరువాత, కొన్ని ఇతర అంశాలు చేయ బోతున్నాను

65
00:03:34,000 --> 00:03:37,000
అవి ఒక అనువర్తనం అమలు.

66
00:03:37,000 --> 00:03:40,000
ఆ ఏమి ఆ పదం వారసత్వం అర్థం. మేము మరింత కాంక్రీటు ఉదాహరణ చూస్తారు.

67
00:03:40,000 --> 00:03:42,000
>> చివరకు, విషయ ఆధారిత ప్రోగ్రామింగ్ కీ అని

68
00:03:42,000 --> 00:03:45,000
అది డేటా తొడుగు దారితీస్తుంది.

69
00:03:45,000 --> 00:03:48,000
మా సమస్య యొక్క కొన్ని సెట్లలో మేము ఈ పెద్ద, ప్రపంచ వేరియబుల్స్ కలిగి

70
00:03:48,000 --> 00:03:51,000
మరియు ప్రతిచోటా గ్లోబల్స్, మరియు మేము రాష్ట్ర ట్రాక్ కావలసిన ఎలా.

71
00:03:51,000 --> 00:03:55,000
తరగతులు తో మేము ఒక వస్తువు యొక్క లోపలి సమాచారం encapsulating ప్రారంభించవచ్చు.

72
00:03:55,000 --> 00:03:58,000
మేము మా అనువర్తనంలో ఒక స్క్రీన్ కలిగి ఉంటే, మేము నిజంగా నుండి ఏ డేటాను కలిగి లేదు

73
00:03:58,000 --> 00:04:01,000
ఆ మా అనువర్తనం లోపల మరో స్క్రీన్,

74
00:04:01,000 --> 00:04:04,000
అందువలన తరగతులు వస్తువులు encapsulating ద్వారా ఈ వాస్తవానికి దారితీస్తుంది

75
00:04:04,000 --> 00:04:08,000
మెరుగైన కోడ్ రూపకల్పన, మరియు ఈ అదనపు ఫీచర్లను సాధ్యం

76
00:04:08,000 --> 00:04:11,000
ఆబ్జెక్టివ్-C యొక్క.

77
00:04:11,000 --> 00:04:15,000
ముందు జాగ్రత్త, ఆబ్జెక్టివ్-C కోసం సింటాక్స్ అరటి ఉంది.

78
00:04:15,000 --> 00:04:19,000
ఇది మేము ముందు చూసిన ఏమీ వంటిది

79
00:04:19,000 --> 00:04:22,000
కాబట్టి ఇది ఒక సాంకేతికతను ఉపయోగించే విధానం యొక్క కొద్దిగా ఉంటుంది

80
00:04:22,000 --> 00:04:24,000
ఈ హెక్ అర్థం ఏమిటి?

81
00:04:24,000 --> 00:04:27,000
కానీ ఒకసారి మీరు నిజంగా సున్నితమైన ప్రారంభ సాంకేతికతను గత పొందండి

82
00:04:27,000 --> 00:04:29,000
Apps రాయటం మొదలుపెట్టాలని.

83
00:04:29,000 --> 00:04:33,000
>> ఇక్కడ చెప్పడానికి, ఒక తరగతి ప్రకటించాలని, ఇది, నా తరగతి ఉంది

84
00:04:33,000 --> 00:04:35,000
మరియు ఇంకా ఇక్కడ నేను తరువాత నిర్వచించే వెళుతున్న కొన్ని విషయాలు ఉన్నాయి

85
00:04:35,000 --> 00:04:38,000
నేను @ ఇంటర్ఫేస్ చెప్పడానికి వెళుతున్నాను.

86
00:04:38,000 --> 00:04:41,000
నేను @ ఇంటర్ఫేస్ చెప్పడానికి వెళుతున్నాను. నా తరగతి ఒక పేరు ఇచ్చి వెళుతున్న.

87
00:04:41,000 --> 00:04:43,000
తర్వాత ఎక్కడైనా నేను, @ ముగింపు చెప్పడానికి వెళుతున్న

88
00:04:43,000 --> 00:04:46,000
@ ఇంటర్ఫేస్ మరియు @ ముగింపు మధ్య మరియు ప్రతిదీ

89
00:04:46,000 --> 00:04:48,000
నా తరగతి ఉండాలని అనుకున్నాము.

90
00:04:48,000 --> 00:04:51,000
మా. H ఫైళ్ళ లోపల ఏమి అని అన్నారు.

91
00:04:51,000 --> 00:04:55,000
జస్ట్ సి లో మన. H ఫైళ్లను ప్రధానంగా ఉండే కొన్ని విషయాలు ఇక్కడ చెప్పారు.

92
00:04:55,000 --> 00:04:57,000
నేను తప్పనిసరిగా వారు ఇంకా ఏమి మీరు చెప్పటం లేదు

93
00:04:57,000 --> 00:04:59,000
కానీ కంపైలర్ వారు ఉనికిలో తెలుసుకోవాలి.

94
00:04:59,000 --> 00:05:04,000
తరువాత లోపల మా. మీ ఫైల్స్ ఎందుకంటే ఆబ్జెక్టివ్-C కోసం m

95
00:05:04,000 --> 00:05:08,000
అక్కడ వాస్తవానికి ఈ తరగతులు ఏమి నిర్వచించటానికి వెళుతున్న ఉంది.

96
00:05:08,000 --> 00:05:11,000
చాలా మా. సి ఫైళ్లు వంటి, మేము విధులు కోసం ఒక అమలు అందించింది.

97
00:05:11,000 --> 00:05:15,000
ఇన్సైడ్ మా. M ఫైల్ మేము ఇక్కడ చెప్పడానికి వెళుతున్న ఏమి విధులను అన్ని

98
00:05:15,000 --> 00:05:18,000
వారు ఇవన్నీ నా తరగతి-ఏమి లోపల.

99
00:05:18,000 --> 00:05:22,000
చివరకు, లోపల struct యొక్క మేము ఆ గిరజాల జంట కలుపులు లోపలి చెప్పగల్గినవి

100
00:05:22,000 --> 00:05:25,000
Int n లేదా నోడ్ * తర్వాత,

101
00:05:25,000 --> 00:05:28,000
మరియు ఆబ్జెక్టివ్-C లో మేము, కీవర్డ్ @ ఆస్తి ఉపయోగించడానికి వెళుతున్న

102
00:05:28,000 --> 00:05:31,000
మరియు ఈ, లక్షణాలు నిర్వచించడం ఏమి ఉంది

103
00:05:31,000 --> 00:05:36,000
లేదా నా తరగతుల ఒక భాగమైన కాని పనిచేస్తుంది.

104
00:05:36,000 --> 00:05:40,000
>> ఆబ్జెక్టివ్-C లో విధులు కాలింగ్ కూడా అరటి ఉంది.

105
00:05:40,000 --> 00:05:43,000
మేము సి లో విధులు ప్రకటించారు మేము Int foo లాంటి మాట్లాడుతూ

106
00:05:43,000 --> 00:05:46,000
ఆపై బ్రాకెట్ ఓపెన్ మరియు వాదనలు జాబితా ఇచ్చారు.

107
00:05:46,000 --> 00:05:51,000
ఈ పద్ధతులు లేదా ఫంక్షన్లు ప్రకటించారు ఆబ్జెక్టివ్-C లో ఎలా ఉంది.

108
00:05:51,000 --> 00:05:54,000
నేను ఒక ఫంక్షన్ లేదా ఒక పద్ధతి డిక్లేర్ చేయాలనుకుంటే

109
00:05:54,000 --> 00:05:58,000
నేను పద్ధతి మాట్లాడుతూ నేను అక్కడ నిజంగా తరగతి యొక్క ఒక సభ్యుని అది విధి

110
00:05:58,000 --> 00:06:01,000
మార్చుకోగలిగిన రకం, కానీ నిజంగా, కాబట్టి

111
00:06:01,000 --> 00:06:03,000
లోపల నా పద్ధతి యొక్క నేను ఒక కొత్త పద్ధతి సృష్టించాలనుకునే.

112
00:06:03,000 --> 00:06:06,000
ఇది ఏమీ తిరిగి వెళ్లి, కనుక IT రకం తప్ప యొక్క చేస్తాడు.

113
00:06:06,000 --> 00:06:08,000
ఈ నా విధి తిరిగి రకం.

114
00:06:08,000 --> 00:06:11,000
-I ఎందుకంటే తెలియదు ఇప్పుడు మేము ఇక్కడ parens ఉన్నాయి.

115
00:06:11,000 --> 00:06:14,000
తరువాత, నా చర్య యొక్క పేరును మాత్రం ఉంది

116
00:06:14,000 --> 00:06:17,000
మరియు తర్వాత చివరకు మేము C. కలిగి వంటి సెమికోలన్ కలిగి

117
00:06:17,000 --> 00:06:19,000
ఇక్కడికి కొత్తది ఇక్కడ ఈ వ్యక్తి.

118
00:06:19,000 --> 00:06:22,000
ఈ అడ్డగీత వాస్తవానికి అవసరం, మరియు ఈ చెప్పారు అని

119
00:06:22,000 --> 00:06:26,000
ఇక్కడ ఈ పద్ధతి ఒక తరగతి యొక్క తక్షణ న పిలవబడతాయి.

120
00:06:26,000 --> 00:06:29,000
>> మేము మా structs డిక్లేర్డ్ తరువాత మేము బహుశా ఏదో వంటి చెప్పారు

121
00:06:29,000 --> 00:06:32,000
struct నోడ్ n, మరియు నిజానికి సృష్టించిన

122
00:06:32,000 --> 00:06:35,000
నిజానికి పని మొదలు తద్వారా లేదా ఆ structs ఒకటి ఇన్స్టాన్షిఎట్

123
00:06:35,000 --> 00:06:38,000
అది లోపల ఏమి కలిగి ఉంది, అందువలన ఈ డాష్ మేము ఉండవు

124
00:06:38,000 --> 00:06:41,000
కేవలం మేము ఇన్స్టాన్షిఎట్ వంటి తరగతిలో instantiate ఆ struct

125
00:06:41,000 --> 00:06:43,000
మేము దానిపై ఈ పద్ధతి కాల్ ముందు.

126
00:06:43,000 --> 00:06:46,000
నా పద్ధతులకు వాదనలు జోడించడాన్ని ప్రారంభించడానికి చేయాలనుకుంటే

127
00:06:46,000 --> 00:06:48,000
ఇది మరింత అరటి పొందుతాడు.

128
00:06:48,000 --> 00:06:50,000
ఇక్కడ నా పద్ధతి పేరు ఉంది.

129
00:06:50,000 --> 00:06:53,000
అప్పుడు నేను ఒక కోలన్ కలిగి వెళుతున్న మరియు ఈ పెద్దప్రేగు తరువాత ఇక్కడ చెప్పారు కొన్ని వాదనలు వస్తుంది.

130
00:06:53,000 --> 00:06:56,000
ఈ పద్ధతి ఒక వాదన పడుతుంది.

131
00:06:56,000 --> 00:06:59,000
దాని వాదన రకం ఒక Int, మరియు ఆ వాదన యొక్క పేరు

132
00:06:59,000 --> 00:07:03,000
లేదా నేను పద్ధతి యొక్క లోపల ఉపయోగించడం ప్రారంభించడానికి వెళుతున్న ఆ వేరియబుల్ నేను అంటారు.

133
00:07:03,000 --> 00:07:05,000
మళ్ళీ, ఈ పద్ధతి. ఇది ఒక వాదన పడుతుంది.

134
00:07:05,000 --> 00:07:10,000
>> మీరు మరింత వాదనలు జోడించడం ప్రారంభం కావాలి అది మరింత అరటి గెట్స్

135
00:07:10,000 --> 00:07:13,000
ఆ మేము ఇక్కడ అని ఈ పెద్దప్రేగు వాదనలు జాబితాను వస్తుంది చేశారు.

136
00:07:13,000 --> 00:07:15,000
ఈ మొదటి వాదన ఒక పూర్ణ సంఖ్య.

137
00:07:15,000 --> 00:07:17,000
ఇప్పుడు, ఈ రెండవ వాదన ఆసక్తికరంగా ఉంటుంది.

138
00:07:17,000 --> 00:07:20,000
నా ప్రమేయం లోపల ఉపయోగించి వెళుతున్న ఆ వేరియబుల్

139
00:07:20,000 --> 00:07:23,000
కాబట్టి లోపల నా ప్రమేయం నేను కాలేదు, F అని పిలుస్తారు

140
00:07:23,000 --> 00:07:25,000
F + = 1 లేదా ఏదో.

141
00:07:25,000 --> 00:07:30,000
ఇక్కడ ఈ విషయం ప్రధానంగా ఆ వాదన లేదా పారామితి కొరకు కీ.

142
00:07:30,000 --> 00:07:34,000
మేము కీ విలువ జతలను కలిగి మరియు JSON లేదా అనుబంధ శ్రేణుల వంటి ఏదో జస్ట్ వంటి

143
00:07:34,000 --> 00:07:37,000
ఆబ్జెక్టివ్-C అది నిజంగా స్పష్టమవుతుంది కేవలం ఆ, సరే, చెప్పడానికి నిర్ణయం

144
00:07:37,000 --> 00:07:39,000
మీరు ఈ పారామితులు ఏమిటో ఒక పద్ధతి కాల్ చేసినప్పుడు

145
00:07:39,000 --> 00:07:41,000
నిజానికి వాటిని అన్ని పేరు వెళుతున్న.

146
00:07:41,000 --> 00:07:45,000
మీరు ఒక పద్ధతి కాల్, మీరు నిజంగా, andFloat సే ​​చేస్తాము

147
00:07:45,000 --> 00:07:47,000
మరియు మీకు సైన్ పాస్ చేస్తాము

148
00:07:47,000 --> 00:07:50,000
>> ఆసక్తికరంగా, ఈ ఒక అనే, అయితే ఇతర పారామితులు అన్ని లేదు

149
00:07:50,000 --> 00:07:53,000
మేము ఒక 3 వ వాదన వచ్చింది కాబట్టి నేను andFloat చెప్పగల్గినవి

150
00:07:53,000 --> 00:07:56,000
మరియు మరొక ఫ్లోట్ మరియు మొదలైనవి.

151
00:07:56,000 --> 00:08:01,000
నేను ఈ పద్ధతులు కాల్ అది, కోర్సు అరటిపండ్ల ఉంది

152
00:08:01,000 --> 00:08:04,000
నేను ఒక వస్తువు లేదు, నాకు, foo అనే పద్ధతి నిర్వచించిన అయితే

153
00:08:04,000 --> 00:08:09,000
మరియు నేను foo చేయడం / parens మాట్లాడుతూ కాల్ కాకుండా మీరు

154
00:08:09,000 --> 00:08:11,000
నేను ఒక బ్రాకెట్ తెరిచి వెళుతున్న.

155
00:08:11,000 --> 00:08:13,000
ఇక్కడ నా పద్ధతి యొక్క పేరు ఉంది.

156
00:08:13,000 --> 00:08:17,000
నేను బ్రాకెట్ దగ్గరగా వెళుతున్న మరియు ఈ నేను పిలుపునిచ్చారు నేను వస్తువు.

157
00:08:17,000 --> 00:08:20,000
గుర్తుంచుకోండి, ఈ పద్ధతులు అన్ని తరగతులు లోపల ఉన్నాయి

158
00:08:20,000 --> 00:08:23,000
తరగతులు వాటిలో లోపల నిర్వచించవచ్చు పద్ధతులను కలిగి ఉన్నాయి ఎందుకంటే.

159
00:08:23,000 --> 00:08:26,000
>> ఇక్కడ నేను ఏకపక్ష, కొన్ని తరగతి యొక్క ఒక వస్తువు సృష్టించిన

160
00:08:26,000 --> 00:08:28,000
మరియు ఇది చేయటానికి వాక్యనిర్మాణం.

161
00:08:28,000 --> 00:08:31,000
ఒక వస్తువు రూపొందించటంలో 2 దశలు ఉన్నాయి.

162
00:08:31,000 --> 00:08:34,000
మొదటి దశ I స్పేస్ కేటాయించే అనుకుందాం ఉంది.

163
00:08:34,000 --> 00:08:37,000
ఈ ఒక malloc యొక్క సమానం. మేము ఇకపై malloc చెప్పడానికి లేదు.

164
00:08:37,000 --> 00:08:42,000
మేము, మీ పడిపోయింది అది alloc చేసిన, మరియు. M తో. సి స్థానంలో.

165
00:08:42,000 --> 00:08:47,000
మేము alloc ఏదో తరువాత మేము అప్పుడు ప్రారంభించడం అవసరం.

166
00:08:47,000 --> 00:08:49,000
నిజానికి మీరు వస్తువులు సృష్టించడానికి మీరు కొన్ని లాజిక్ కలిగి ఉంటుంది

167
00:08:49,000 --> 00:08:53,000
వారు సృష్టించిన చేసినప్పుడు అమలు చేసే, కాబట్టి మీరు కొన్ని అప్రమేయ విలువలు లో తరలిస్తారు

168
00:08:53,000 --> 00:08:57,000
లేదా అలాంటిదే, మరియు ఈ init పద్ధతి వాస్తవానికి వస్తువు సృష్టిస్తుంది ఏమిటి.

169
00:08:57,000 --> 00:08:59,000
మేము మొదటి, మేము సి లో చేసిన వలె, స్పేస్ కేటాయించాలని

170
00:08:59,000 --> 00:09:04,000
మరియు తర్వాత మేము లేదా మొత్తం చేస్తాను కాకపోవచ్చు, అది ప్రారంభించడం.

171
00:09:04,000 --> 00:09:07,000
అప్పుడు మేము ఒక వస్తువు o ఈ విషయం తిరిగి చేస్తున్నారు.

172
00:09:07,000 --> 00:09:09,000
ఈ సాంకేతికంగా ఒక పాయింటర్ ఎందుకంటే ఒక నటుడు, ఇక్కడ ఉన్నాయి

173
00:09:09,000 --> 00:09:12,000
కానీ గమనికలు ఆ ఆబ్జెక్టివ్-C పెద్ద ఒప్పందం ఇకపై కాదు, ఆందోళన చెందకండి.

174
00:09:12,000 --> 00:09:15,000
>> ఇప్పుడు మేము, NSObject అని ఈ తరగతి ఇన్స్టాన్షిఎట్ చేసిన

175
00:09:15,000 --> 00:09:19,000
మరియు ఈ కేవలం ఆపిల్ కలిగి యాదృచ్ఛిక తరగతి ఉంది.

176
00:09:19,000 --> 00:09:22,000
మేము ఈ ఇన్స్టాన్షిఎట్ చేశారు, ఇప్పుడు నేను ఈ తరగతి యొక్క ఒక ఉదాహరణగా ఉన్నాయి

177
00:09:22,000 --> 00:09:25,000
ఈ వస్తువు o, కాబట్టి నేను నిర్వచించిన ఉంటే అర్థం

178
00:09:25,000 --> 00:09:29,000
ఈ పద్ధతులు నేను ఈ వంటి వాటిని కాల్ కాలేదు.

179
00:09:29,000 --> 00:09:31,000
అదేవిధంగా, నేను ఒక వాదన ఒక పద్ధతి కాల్ కోరుకుంటే,

180
00:09:31,000 --> 00:09:34,000
ఈ బార్ పద్ధతి కాబట్టి, ఆ, ఒక వాదన పడుతుంది

181
00:09:34,000 --> 00:09:38,000
qux పద్ధతి, అందువలన ఈ 2 వాదనలు పడుతుంది: ఇక్కడ బాజ్ ఉంది.

182
00:09:38,000 --> 00:09:44,000
ఈ వస్తువు o ఒక చర్యను కాల్ ఉంది.

183
00:09:44,000 --> 00:09:46,000
సమంజసం?

184
00:09:46,000 --> 00:09:50,000
వాక్యనిర్మాణం సమంజసం ఉండాలి, కానీ మీరు రకమైన అది అలవాటుపడతారు.

185
00:09:50,000 --> 00:09:54,000
>> సరే, యొక్క ఆబ్జెక్టివ్-C లోకి నిర్మించబడ్డాయి కొన్ని విషయాల గురించి మాట్లాడండి తెలియజేయండి

186
00:09:54,000 --> 00:09:56,000
ఆ అవసరం C. లోకి నిర్మించని

187
00:09:56,000 --> 00:09:59,000
సి లో మేము రకమైన, ఈ స్టుపిడ్ పాత్ర శ్రేణుల వంటి తీగలను వ్యవహరించవలసిఉంది

188
00:09:59,000 --> 00:10:01,000
అది నిజంగా బాధించే వచ్చింది.

189
00:10:01,000 --> 00:10:04,000
ఆబ్జెక్టివ్-C అన్ని మాకు నిర్మించారు ఆ ఉంది, మరియు అది నిర్మించబడిన

190
00:10:04,000 --> 00:10:06,000
NSString అని ఈ తరగతి ఉపయోగించి.

191
00:10:06,000 --> 00:10:10,000
మనం మరింత అద్భుత సింటాక్స్ కలిగి ఒక NSString సృష్టించడానికి ఉంటుంది.

192
00:10:10,000 --> 00:10:15,000
అయితే మేము @ "cs50" సే "cs50" అని కంటే

193
00:10:15,000 --> 00:10:17,000
మరియు ఈ కేవలం ఆబ్జెక్టివ్-C లో తీగలను చాటి వాక్యనిర్మాణం.

194
00:10:17,000 --> 00:10:21,000
ఈ మర్చిపోతే, ఐతే వద్దు చాలా సులభం.

195
00:10:21,000 --> 00:10:24,000
ఇప్పుడు, ఒకసారి నేను ఈ కలిగి, ఈ స్ట్రింగ్, కానీ గమనించి

196
00:10:24,000 --> 00:10:26,000
ఇది నిజంగా కేవలం ఒక వస్తువు యొక్క.

197
00:10:26,000 --> 00:10:30,000
నేను అన్నాడు నేను క్లాస్ ఇన్స్టాన్షిఎట్ అంటే NSString,

198
00:10:30,000 --> 00:10:32,000
ఎవరో నాకు రాసింది NSString, అని

199
00:10:32,000 --> 00:10:35,000
మరియు వారు ప్రస్తుతం దాని గురించి చాలా మంచి, మరియు

200
00:10:35,000 --> 00:10:37,000
నేను పద్ధతులు కాల్ చెయ్యవచ్చు.

201
00:10:37,000 --> 00:10:40,000
నేను ఈ వస్తువు లు న పద్ధతి పొడవు కాల్ ఉంటే

202
00:10:40,000 --> 00:10:43,000
అది నాకు స్ట్రింగ్ యొక్క పొడవు తిరిగి వెళుతున్న.

203
00:10:43,000 --> 00:10:45,000
ఈ C. కేవలం strlen వంటిది

204
00:10:45,000 --> 00:10:47,000
ఈ 4 చేరాడు.

205
00:10:47,000 --> 00:10:51,000
>> అదేవిధంగా, నేను పట్టించుకోనట్లు ఉంటుంది మరొక పద్ధతి ఈ characterAtIndex ఉంది.

206
00:10:51,000 --> 00:10:54,000
ఈ స్ట్రింగ్ s చెప్పాడు ఒక పద్ధతి

207
00:10:54,000 --> 00:10:57,000
నేను, మీరు జేరోయేత్ పాత్ర పొందడానికి కావలసిన

208
00:10:57,000 --> 00:10:59,000
మరియు ఈ నా పాత్ర సి తిరిగి

209
00:10:59,000 --> 00:11:02,000
మరియు మీరు నిజంగా సులభంగా Google చేసే పద్ధతులను మరింత మొత్తం అక్కడ ఉంది.

210
00:11:02,000 --> 00:11:07,000
Apple యొక్క డాక్యుమెంటేషన్ గొప్ప ఉంది, మరియు మేము ఒక బిట్ లో ఆ వద్ద టేక్ ఎ లుక్ వస్తుంది.

211
00:11:07,000 --> 00:11:09,000
ఆ తీగలు ఉంటాయి.

212
00:11:09,000 --> 00:11:11,000
మేము కూడా వేరియబుల్ పరిమాణం శ్రేణుల కలిగి ఉన్నాయి

213
00:11:11,000 --> 00:11:13,000
మేము ఒక అర్రే ప్రకటించడంతో సి లో గుర్తుంచుకో

214
00:11:13,000 --> 00:11:16,000
మేము మీరు 5 అంశాలు, కథ ముగింపు ఉన్నాయి, అవి వచ్చింది.

215
00:11:16,000 --> 00:11:18,000
మేము JavaScript మరియు PHP పరుగులకు చేరుకున్నప్పుడు మేము ప్రారంభం కాలేదు

216
00:11:18,000 --> 00:11:20,000
అంశాలను జోడించడం లేదా అంశాలను కదిలే వంటి పనులను.

217
00:11:20,000 --> 00:11:22,000
మేము ఆబ్జెక్టివ్-C లో అదే చేయవచ్చు.

218
00:11:22,000 --> 00:11:26,000
సాధారణ సి విధంగా ఒక అమరికను రూపొందించడానికి కాకుండా

219
00:11:26,000 --> 00:11:30,000
మేము మళ్లీ NSMutableArray అని మరొక తరగతి ఉంది.

220
00:11:30,000 --> 00:11:33,000
, NSArray కూడా ఉన్నాయి

221
00:11:33,000 --> 00:11:35,000
మరియు ఈ ప్రాథమికంగా కొన్ని శ్రేణి మాత్రం అన్నారు.

222
00:11:35,000 --> 00:11:38,000
ఈ నేను చేయాలనుకుంటున్నారా మొదటి మాట కేటాయించే కావలసిన చెప్పారు

223
00:11:38,000 --> 00:11:41,000
ఒక కొత్త శ్రేణి స్థలాన్ని, మరియు నేను కేటాయించాలని తర్వాత

224
00:11:41,000 --> 00:11:43,000
అప్పుడు కూడా నేను దీనిని ప్రారంభించడం అవసరం.

225
00:11:43,000 --> 00:11:45,000
మళ్ళీ, ఈ 2 పద్ధతులు కాల్.

226
00:11:45,000 --> 00:11:48,000
ఇప్పుడు ఈ ఈ వస్తువు యొక్క లోపల అర్థం

227
00:11:48,000 --> 00:11:50,000
నేను అక్కడ ఒక ఖాళీ శ్రేణిని కూర్చొని ఉన్నారు.

228
00:11:50,000 --> 00:11:54,000
నేను ఈ శ్రేణి ఏదో జోడించాలనుకుంటే, నేను addObject పద్ధతి కాల్ చేయవచ్చు.

229
00:11:54,000 --> 00:11:59,000
నేను ఒక శ్రేణి ఒక వస్తువు జోడించదలచిన, మరియు నేను స్ట్రింగ్ CS50 జోడించాలనుకుంటున్నాను.

230
00:11:59,000 --> 00:12:02,000
నేను దానికి నేను చేసే తొలగించాలని అనుకుంటే నేను మీరు

231
00:12:02,000 --> 00:12:09,000
అర్రే మొదటి స్థానంలో వస్తువు తీసివేయండి లేదా వస్తువు.

232
00:12:09,000 --> 00:12:11,000
>> సమంజసం?

233
00:12:11,000 --> 00:12:14,000
సరే, మీరు రకమైన ఈ చదరపు బ్రాకెట్ విషయం అలవాటుపడతారు.

234
00:12:14,000 --> 00:12:18,000
మార్గం ద్వారా, Apple యొక్క గ్రంథాలయాల్లో చాలా లోపల మీరు ఈ NS చూస్తారు.

235
00:12:18,000 --> 00:12:21,000
NS వాస్తవానికి స్టీవ్ జాబ్స్ మొదటి కంపెనీలలో ఒకటి ఇది తదుపరి దశలో, అనగా

236
00:12:21,000 --> 00:12:24,000
అతను నిజంగా కోడ్ చాలా రాయడం మొదలుపెట్టారు పేరు మరియు ఆ

237
00:12:24,000 --> 00:12:27,000
Mac OS X మరియు ఇతర విషయాలను ఆధారంగా యొక్క రకమైన,

238
00:12:27,000 --> 00:12:32,000
మరియు ఈ NS ఈ nice లెగసీ రకం ముందు కంపెనీల్లో ఒకటి బయటకు అరవండి ఉంది

239
00:12:32,000 --> 00:12:34,000
తిరిగి ఆపిల్ మొదటి ప్రారంభమైన సమయంలో.

240
00:12:34,000 --> 00:12:36,000
ఇది ప్రతిచోటా ఉంది.

241
00:12:36,000 --> 00:12:41,000
యొక్క మరింత సమగ్రమైన ఆబ్జెక్టివ్-C ఉదాహరణ పరిశీలించి చూద్దాం.

242
00:12:41,000 --> 00:12:44,000
ఇక్కడ నేను XCode లోపలి am.

243
00:12:44,000 --> 00:12:47,000
ఇక్కడ ఉండటానికి, నేను మొదటి, App స్టోర్ నుండి XCode డౌన్లోడ్

244
00:12:47,000 --> 00:12:50,000
నేను, ఫైలు ఇక్కడ, తర్వాత దానిని ప్రారంభించారు, మరియు

245
00:12:50,000 --> 00:12:54,000
ఇక్కడ పైగా కొత్త, ఆపై ప్రాజెక్ట్.

246
00:12:54,000 --> 00:12:57,000
నేను సృష్టించడానికి ఏమి ఈ ఎంపికలు ఉన్నాయి అలా తరువాత,

247
00:12:57,000 --> 00:12:59,000
అందువలన మేము, తర్వాత ఈ ఎంపికలు వద్ద టేక్ ఎ లుక్ వస్తుంది

248
00:12:59,000 --> 00:13:03,000
కానీ ఈ ఉదాహరణకు, ఎందుకంటే మేము నిజానికి, ఇంకా ఒక అనువర్తనం ఏమీ ఉండదని చేస్తున్నారు

249
00:13:03,000 --> 00:13:06,000
నేను ఇక్కడ వచ్చాడు, మరియు నేను కమాండ్ లైన్ టూల్ చెప్పారు

250
00:13:06,000 --> 00:13:09,000
మరియు ఈ నేను కమాండ్ లైన్ వద్ద అమలు చేయగల ఒక అనువర్తనం ఉంది

251
00:13:09,000 --> 00:13:12,000
మేము C. నుండి అమలు చేసిన వలె

252
00:13:12,000 --> 00:13:16,000
, నేను ఈ ప్రాజెక్ట్ రూపొందించినవారు ఎలా, అందువలన ఇప్పుడు నేను ఇక్కడ ఉన్నాను

253
00:13:16,000 --> 00:13:20,000
ఈ ఫైలు వద్ద మొదటి చూద్దాం, మరియు ఇది చాలా తెలిసిన కనిపించాలి.

254
00:13:20,000 --> 00:13:24,000
నేను ఒక పూర్ణాంకానికి పేరు. నా స్నేహితుడు argc, నా ఇతర స్నేహితుని argv ఉంది.

255
00:13:24,000 --> 00:13:30,000
కాబట్టి మేము ఈ నా మొదటి లక్ష్యం-C అనువర్తనం కోసం ఎంట్రీ పాయింట్ అని చూడగలరు.

256
00:13:30,000 --> 00:13:32,000
ఇక్కడ మేము ఇప్పుడు ఈ విస్మరించవచ్చు.

257
00:13:32,000 --> 00:13:35,000
ఈ ప్రాథమికంగా కొన్ని మెమరీ నిర్వహణ అంశాలను అని మీరు నిజంగా రెడీ

258
00:13:35,000 --> 00:13:37,000
ఎప్పుడూ గురించి ఆందోళన.

259
00:13:37,000 --> 00:13:39,000
>> ఇక్కడ ఈ మొదటి బ్లాక్ చూడండి యొక్క లెట్.

260
00:13:39,000 --> 00:13:46,000
ఈ మొదటి పంక్తి, నేను స్టూడెంట్ చెప్పుకోవాలంటే * ఆలిస్ = [[స్టూడెంట్ alloc] init] ఏమి ఆ?

261
00:13:46,000 --> 00:13:50,000
ఇక్కడ ఈ మొదటి విద్యార్థి, ఈ బహుశా ఒక తరగతి ఉంది.

262
00:13:50,000 --> 00:13:54,000
ఈ Apple రాసిన ఒక తరగతి కాదు, కానీ నేను వ్రాసిన ఒక తరగతి ఉంది.

263
00:13:54,000 --> 00:13:57,000
నేను చేయాలనుకుంటున్నారా మొదటి విషయం, నేను ఒక కొత్త విద్యార్థి స్థలాన్ని కేటాయించే దీనిని చేస్తారు

264
00:13:57,000 --> 00:14:00,000
తరువాత నేను ప్రారంభించడం కావాలి, కాబట్టి ఈ నాకు మళ్లీ ఇస్తుంది

265
00:14:00,000 --> 00:14:05,000
ఈ కొత్త విద్యార్ధి వస్తువు, నేను ఆలిస్ అనే వేరియబుల్ ఈ నిల్వ చేస్తున్నాను.

266
00:14:05,000 --> 00:14:07,000
ఆ క్లాస్ ఎక్కడ నుండి వచ్చింది?

267
00:14:07,000 --> 00:14:12,000
అయితే, ఈ పైగా ఎడమ వైపు ఈ నా ప్రాజెక్టు లోపల వివిధ ఫైళ్లను అన్ని.

268
00:14:12,000 --> 00:14:16,000
మేము నేను Student.h మరియు ఒక Student.m కలిగి ఇక్కడ చూడగలరు.

269
00:14:16,000 --> 00:14:20,000
నేను అన్ని విషయాలను డిక్లేర్ పేరు. H ఫైలు, గుర్తు, ఉంది

270
00:14:20,000 --> 00:14:22,000
అదే తరగతిలోని ఉనికిలో ఉంటుంది.

271
00:14:22,000 --> 00:14:25,000
>> యొక్క ఆ పరిశీలించి చూద్దాం.

272
00:14:25,000 --> 00:14:29,000
All right, ఇక్కడ మేము ఈ @ ఇంటర్ఫేస్ కలిగి, మరియు ఈ ఇక్కడ వస్తుంది చెప్పారు

273
00:14:29,000 --> 00:14:33,000
నా తరగతి ఉండే ప్రతిదీ ప్రకటనలతో.

274
00:14:33,000 --> 00:14:36,000
అప్పుడు నేను ఒక కోలన్ ఉన్నాయి. అప్పుడు నేను ఈ NSObject విషయం ఉంది.

275
00:14:36,000 --> 00:14:40,000
ఈ పెద్దప్రేగు మేము కొద్దిగా ముందు చర్చిస్తున్నారు ఆ వారసత్వం బిట్ సూచిస్తుంది.

276
00:14:40,000 --> 00:14:43,000
ఈ చెప్పారు ఒక NSObject చేయవచ్చు ప్రతిదీ

277
00:14:43,000 --> 00:14:46,000
NSObject మరొకరి రాసిన ఈ తరగతి, ఇక్కడ

278
00:14:46,000 --> 00:14:50,000
నేను ఆ చేస్తామని మీరు ఈ NSObject చేయవచ్చు ప్రతిదీ.

279
00:14:50,000 --> 00:14:54,000
ఈ విధంగా: NSObject ఆ నిజానికి అర్థం

280
00:14:54,000 --> 00:14:58,000
మరొక తరగతి యొక్క కార్యాచరణ యొక్క అన్ని వారసత్వంగా.

281
00:14:58,000 --> 00:15:02,000
ఆ నన్ను నేను ఉపయోగించగల వేర్వేరు పద్ధతులు మరియు లక్షణాలను మొత్తం బంచ్ ఇచ్చారు.

282
00:15:02,000 --> 00:15:05,000
డౌన్ ఇక్కడ నేను 2 లక్షణాలు సృష్టించడం చేస్తున్నాను.

283
00:15:05,000 --> 00:15:08,000
ఈ ఒక struct అయితే నా విద్యార్థి అనగా, ఈ 2 విషయాలు ఉంటుంది

284
00:15:08,000 --> 00:15:11,000
లోపల నా struct యొక్క, కాబట్టి ప్రతి విద్యార్థి ఒక పేరు ఉంది

285
00:15:11,000 --> 00:15:14,000
, ఒక స్ట్రింగ్, మరియు ఒక విద్యార్ధి కూడా ఒక గ్రేడ్ ఉంది

286
00:15:14,000 --> 00:15:17,000
ఒక Int ఉంది.

287
00:15:17,000 --> 00:15:23,000
>> చివరగా, డౌన్ ఇక్కడ నేను నా విద్యార్థి ఒక పధ్ధతి తయారు వెళుతున్న.

288
00:15:23,000 --> 00:15:26,000
నేను initWithName, నా పద్ధతి అని, మరియు ఇది ఒక వాదన పడుతుంది

289
00:15:26,000 --> 00:15:31,000
మరియు ఆ వాదన ఒక స్ట్రింగ్, అది నాకు పేరు అని.

290
00:15:31,000 --> 00:15:35,000
ఇప్పుడు మేము నిజానికి ఈ తరగతి అమలు ఎలా చూద్దాం.

291
00:15:35,000 --> 00:15:38,000
ఇక్కడ, ఇప్పుడు నేను, నా. M ఫైల్ లోపల ఉన్నాను

292
00:15:38,000 --> 00:15:40,000
అమలు m, నేను ఊహిస్తున్నాను.

293
00:15:40,000 --> 00:15:44,000
నేను, నా ముగింపు నా అమలు లేదు, నాకు నిజంగా నిర్వచించు నేను ఎక్కడ ఉంది

294
00:15:44,000 --> 00:15:47,000
ఏ initWithName చేస్తుంది.

295
00:15:47,000 --> 00:15:50,000
నేను initWithName, నా పరామితి యొక్క పేరు, మరియు ఈ కలిగి

296
00:15:50,000 --> 00:15:53,000
నేను ఒక విద్యార్థి సృష్టించడం నేను ఎక్కడ ఉంది

297
00:15:53,000 --> 00:15:56,000
మరియు ఈ కొద్దిగా గుప్తమైన, కానీ ఈ బాయిలర్ ప్లేట్ రకం

298
00:15:56,000 --> 00:15:58,000
మీరు మీ తయారీదారుల లో చేర్చాలనుకుంటే ఆ.

299
00:15:58,000 --> 00:16:02,000
ఇక్కడ ఈ ప్రారంభ ఫంక్షన్ initWithName, కన్స్ట్రక్టర్ యొక్క రకం.

300
00:16:02,000 --> 00:16:05,000
మీరు ప్రాథమికంగా ఒక కొత్త విద్యార్థి వస్తువు నిర్మిస్తోంది చేస్తున్నారు

301
00:16:05,000 --> 00:16:07,000
మరియు దీనికి లోపల కొన్ని డేటాను పంపడం.

302
00:16:07,000 --> 00:16:11,000
నేను చేయాలనుకుంటున్నారా మొదటి మాట ఈ సూపర్ విషయాన్ని init కాల్ మీరు ఉంది.

303
00:16:11,000 --> 00:16:15,000
>> గుర్తుంచుకో నేను. H ఫైలు తిరిగి ఇక్కడ ఇలా చెప్పాడు

304
00:16:15,000 --> 00:16:21,000
ప్రతిదీ ఒక NSObject ఒక విద్యార్థి కూడా కలిగి ఉన్నాయి.

305
00:16:21,000 --> 00:16:24,000
నేను నేను కూడా ఏమి చేయాలి ఒక విద్యార్థి సృష్టించినప్పుడు అర్థం

306
00:16:24,000 --> 00:16:28,000
నిర్ధారించుకోండి నేను నుండి డేటా యొక్క అన్ని వారసత్వంగా కాబట్టి NSObject

307
00:16:28,000 --> 00:16:32,000
కూడా సరిగా initialized ఉంది.

308
00:16:32,000 --> 00:16:36,000
నేను ఏమి చెప్పటానికి అవసరం ఈ సూపర్ ఉంది వాస్తవానికి మాతృ తరగతి చూడండి అన్నారు

309
00:16:36,000 --> 00:16:39,000
నేను నుండి వారసత్వంగా కాబట్టి, అందువలన నేను ప్రారంభించడం నిర్ధారించుకోవాలి

310
00:16:39,000 --> 00:16:43,000
నేను ఉపయోగించడానికి ప్రయత్నిస్తున్న ముందు నేను బట్టి నేను ప్రతిదీ.

311
00:16:43,000 --> 00:16:46,000
ఆ initialized అయితే సరిగ్గా ఇది చెప్పడం వంటి ఉంటే malloc

312
00:16:46,000 --> 00:16:50,000
శూన్య చూపలేదు అప్పుడు నేను కొన్ని లక్షణాలను అమర్చే ప్రారంభించవచ్చు.

313
00:16:50,000 --> 00:16:54,000
>> JavaScript మరియు PHP లో మేము ఈ కీవర్డ్, ఈ పిలుపునిచ్చారు

314
00:16:54,000 --> 00:16:58,000
మరియు ఈ ఒక తరగతి యొక్క ప్రస్తుత ఉదాహరణకు సూచిస్తారు.

315
00:16:58,000 --> 00:17:00,000
ఆబ్జెక్టివ్-C లో మేము ఈ స్వీయ కాల్.

316
00:17:00,000 --> 00:17:04,000
నేను self.name చెప్పినప్పుడు అని వస్తువు

317
00:17:04,000 --> 00:17:07,000
నేను విద్యార్థి alloc init ఇలా చెప్పాడు నేను, రూపొందించినవారు

318
00:17:07,000 --> 00:17:09,000
ఒక వస్తువు నాకు మళ్లీ ఇవ్వాలని జరగబోతోంది.

319
00:17:09,000 --> 00:17:12,000
అనగా ఆ వస్తువు యొక్క పేరు సెట్ చేయాలనుకుంటున్నారా

320
00:17:12,000 --> 00:17:15,000
నేను సైన్ జారీ వెళ్లడానికి

321
00:17:15,000 --> 00:17:18,000
సి లో మాదిరిగా, మేము, ఈ డాట్ తో సభ్యులు యాక్సెస్

322
00:17:18,000 --> 00:17:21,000
కాబట్టి self.name విద్యార్థి వస్తువు యొక్క పేరు చెప్పారు

323
00:17:21,000 --> 00:17:24,000
ఇప్పుడు మీరు సైన్ జారీ మరేమిటి అన్నారు

324
00:17:24,000 --> 00:17:28,000
నిజానికి ఏదో తిరిగి అదే విధంగా చివరకు, నేను తిరిగి రావచ్చు.

325
00:17:28,000 --> 00:17:30,000
>> ప్రశ్నలు?

326
00:17:30,000 --> 00:17:34,000
సరే, ఈ స్వీయ = సూపర్, init

327
00:17:34,000 --> 00:17:37,000
మీరు పూర్తిగా వారసత్వం stuff అర్థం లేదు, చింతించకండి.

328
00:17:37,000 --> 00:17:40,000
జస్ట్ తెలిసిన మీరు మీ స్వంత init పద్ధతి తయారు చేయదలచుకుంటే

329
00:17:40,000 --> 00:17:42,000
అలా, మరియు మీరు అన్నిటికి ఉంటాం.

330
00:17:42,000 --> 00:17:44,000
అవును. >> [స్టూడెంట్] ఏం నేనే సగటు చేస్తుంది?

331
00:17:44,000 --> 00:17:49,000
అంటే మేము malloc అది శూన్య సమానము మేము ఎల్లప్పుడూ తనిఖీ ఏదో,

332
00:17:49,000 --> 00:17:51,000
అది శూన్య ఉంటే మరియు, అప్పుడు మేము నిష్క్రమించారు.

333
00:17:51,000 --> 00:17:55,000
ఈ రాబడి శూన్య, అప్పుడు మేము బహుశా seg లోపం చూడాలని ఎందుకంటే ఈ, అదే విషయం

334
00:17:55,000 --> 00:17:57,000
మేము అది సవరించడానికి ప్రయత్నిస్తున్న ప్రారంభం ఉంటే.

335
00:17:57,000 --> 00:18:01,000
మా విద్యార్థి తరగతి ఉంది.

336
00:18:01,000 --> 00:18:03,000
మేము రెండు విధానాలలో ఒక మా విద్యార్థులు ప్రారంభించడం దీని అర్థం అది.

337
00:18:03,000 --> 00:18:08,000
నేను విద్యార్థి alloc init చెప్పినట్టైతే నేను రాసిన పద్ధతిలో లేదు,

338
00:18:08,000 --> 00:18:11,000
మరియు బదులుగా నేను కేవలం, alice.name చెప్పగలదు

339
00:18:11,000 --> 00:18:14,000
మరియు ఇప్పుడు నేను ఆ ఆస్తి పేరు సెట్ వెళుతున్న.

340
00:18:14,000 --> 00:18:17,000
>> అదేవిధంగా, ఆ initWithName పద్ధతి ను ఉపయోగించడానికి

341
00:18:17,000 --> 00:18:20,000
నేను కేవలం alloc, మరియు అప్పుడు కాకుండా init చెప్పడం చేయవచ్చు

342
00:18:20,000 --> 00:18:24,000
నేను సృష్టించిన ఆ పద్ధతి కాల్ వెళుతున్న మరియు నేను బాబ్ లో పాస్ వెళుతున్న.

343
00:18:24,000 --> 00:18:30,000
ఈ సమయంలో, ఈ వస్తువు బాబ్ బాబ్ సమానమైన పేరు ఉంది.

344
00:18:30,000 --> 00:18:35,000
సరే, డౌన్ ఇక్కడ మనం ముందుగా చూశారు ఆ NSMutableArray ఉపయోగించి వెబ్.

345
00:18:35,000 --> 00:18:38,000
నేను ఒక కొత్త శ్రేణి ప్రారంభించడం చేస్తున్నాను space.Then పెడుతోంది చేస్తున్నాను.

346
00:18:38,000 --> 00:18:40,000
నేను దానికి 2 విషయాలు జోడించండి వెళుతున్న.

347
00:18:40,000 --> 00:18:43,000
ఈ శ్రేణి ఇప్పుడు విద్యార్థి వస్తువులు కలిగి ఉంది.

348
00:18:43,000 --> 00:18:46,000
ఎక్కడా నేను ఈ విద్యార్ధులు ఒక శ్రేణి చెప్పే అని గమనించండి.

349
00:18:46,000 --> 00:18:48,000
నేను ఒక వరుస కాలం చెప్పాడు.

350
00:18:48,000 --> 00:18:50,000
అప్పుడు నేను కావలసిన దానిని ఏ లోపల ఉంచవచ్చు.

351
00:18:50,000 --> 00:18:52,000
ఇక్కడ నేను 2 వస్తువులు ఉన్నాయి.

352
00:18:52,000 --> 00:18:56,000
>> చివరగా, నేను, ఇక్కడ ఈ TF మరొక వస్తువు ఉంది.

353
00:18:56,000 --> 00:18:59,000
ఇక్కడ TF.h లో ప్రధానంగా ఇదే.

354
00:18:59,000 --> 00:19:01,000
నేను, NSObject నుండి, మరియు ద్వారా సంక్రమించే నేను

355
00:19:01,000 --> 00:19:03,000
మీరు తరగతులు సృష్టించినప్పుడు ఈ అన్ని మీరు చేయబడుతుంది,

356
00:19:03,000 --> 00:19:06,000
ఇంటర్ఫేస్ బాయిలెర్ప్లేట్ ఈ రకమైన.

357
00:19:06,000 --> 00:19:08,000
ఇది విద్యార్థులు ఒక ఆస్తి ఉంది.

358
00:19:08,000 --> 00:19:15,000
నేను, ఒక జంట పద్ధతులు ఇక్కడ నిజంగా మొత్తం చాలా చెయ్యమని కలిగి

359
00:19:15,000 --> 00:19:18,000
నేను ఈ TF వస్తువు సృష్టించిన తర్వాత అనగా

360
00:19:18,000 --> 00:19:23,000
నేను ఈ మాదిరిగా ఈ పద్ధతి గ్రేడ్ కాల్ చేయవచ్చు.

361
00:19:23,000 --> 00:19:26,000
ఆబ్జెక్టివ్-C చూడండి ఏదైనా ప్రశ్నలు మేము కొన్ని మరింత మారడం ప్రారంభించడానికి ముందు

362
00:19:26,000 --> 00:19:30,000
ఆసక్తికరమైన Apps అభివృద్ధి stuff?

363
00:19:30,000 --> 00:19:34,000
>> సరే, నిజానికి యొక్క ఒక ఐఫోన్ అనువర్తనం తయారు చేద్దాము.

364
00:19:34,000 --> 00:19:39,000
మీ ఐఫోన్ అనువర్తనం యొక్క మీరు లోపల ఉపయోగించి వస్తుంది ప్రధాన తరగతులు, వీక్షణ కంట్రోలర్లు అని పిలుస్తారు

365
00:19:39,000 --> 00:19:42,000
మరియు ఒక అభిప్రాయం నియంత్రిక ప్రధానంగా ఒక స్క్రీన్ సూచిస్తుంది

366
00:19:42,000 --> 00:19:46,000
మీ అనువర్తనం యొక్క లోపల, నేను, ఉదాహరణకు, సంగీతం అనువర్తనంలో ఉన్నాను ఉంటే

367
00:19:46,000 --> 00:19:50,000
ఒక దృశ్యం నియంత్రిక నా iPhone లో అన్ని పాటలు వీక్షించడానికి దీనిలో వీక్షణ ప్రాతినిధ్యం వహిస్తుంది.

368
00:19:50,000 --> 00:19:53,000
నేను ఒక పాట క్లిక్ చేసి దానిని ప్లే ప్రారంభించిన ఇంకొక అభిప్రాయం నియంత్రిక ఉంటుంది

369
00:19:53,000 --> 00:19:55,000
లేదా నేను కళాకారులు దిగి తీసే నేను వంటి.

370
00:19:55,000 --> 00:19:59,000
ఆ వివిధ తెరలు ప్రతి మరొక వీక్షణ నియంత్రిక వంటి ప్రాతినిధ్యం చేయవచ్చు

371
00:19:59,000 --> 00:20:04,000
మరియు ఒక అభిప్రాయం నియంత్రిక నిజంగా ఈ స్క్రీన్ ఎలా పనిచేస్తుంది అని ఒక తరగతి ఉంది.

372
00:20:04,000 --> 00:20:07,000
ఒక దృశ్యం నియంత్రిక లోపలి థింగ్స్, మేము, లక్షణాలు చూడాలని

373
00:20:07,000 --> 00:20:10,000
కాబట్టి ఒక బటన్ వంటి వాటిని మా అభిప్రాయాలను నియంత్రిక ఒక ఆస్తి అని అన్నారు.

374
00:20:10,000 --> 00:20:13,000
>> మేము కూడా పద్ధతులు చూడాలని, మరియు ఈ ప్రాథమికంగా ఈవెంట్ నిర్వాహకులు ఉన్నారు.

375
00:20:13,000 --> 00:20:16,000
ఈ పద్ధతి మీరు ఈ బటన్ నొక్కినప్పుడు చెప్పారు

376
00:20:16,000 --> 00:20:19,000
నేను, చివరకు, మళ్ళీ చేయాలని, మరియు

377
00:20:19,000 --> 00:20:24,000
మేము ప్రస్తుత ఉదాహరణకు యాక్సెస్ ఈ స్వీయ కీవర్డ్ ఉపయోగించి చూడాలని.

378
00:20:24,000 --> 00:20:29,000
IOS లో అనుసంధానాన్ని నిర్మించవచ్చు వాస్తవానికి నిజంగా సులభం.

379
00:20:29,000 --> 00:20:32,000
వారు ఈ nice డ్రాగ్ మరియు ఇంటర్ఫేస్ బిల్డర్ అని డ్రాప్ ఇంటర్ఫేస్ కలిగి

380
00:20:32,000 --> 00:20:37,000
మరియు 2 కోర్ భావనలు మీ ఆబ్జెక్టివ్-C అప్ ఇంటర్ఫేస్ బిల్డర్ కు WIRE

381
00:20:37,000 --> 00:20:40,000
IBOutlet మరియు IBAction ఉంటాయి.

382
00:20:40,000 --> 00:20:44,000
ఒక IBOutlet కేవలం, ఒక బటన్ ఉన్న ఒక ఆస్తి డిక్లేర్ ఉంటే చెప్పారు

383
00:20:44,000 --> 00:20:47,000
మరియు మీరు, మీ వాస్తవ UI ఏదో దానిని హుక్ అప్ కావలసిన

384
00:20:47,000 --> 00:20:49,000
మీరు ఒక అవుట్లెట్ చెప్పాలి వెళుతున్న.

385
00:20:49,000 --> 00:20:51,000
అదేవిధంగా, మీరు ఒక ఈవెంట్ నిర్వహణ ప్రాతినిధ్యం అనుకుంటే

386
00:20:51,000 --> 00:20:54,000
అప్పుడు మీరు ఒక చర్య చెప్పాలి వెళుతున్న.

387
00:20:54,000 --> 00:20:57,000
>> వాస్తవానికి ఈ గ్రాఫికల్ ప్రాతినిధ్యాన్ని వైర్

388
00:20:57,000 --> 00:21:00,000
మరియు మీ కోడ్ అది నిజంగా సులభం.

389
00:21:00,000 --> 00:21:03,000
మీరు ఒక IBOutlet అటాచ్, మీరు చేయాల్సిందల్లా, మీరు క్లిక్ నియంత్రణ

390
00:21:03,000 --> 00:21:05,000
మరియు మేము ఇది నిజంగా శీఘ్ర ఒక ఉదాహరణ చూస్తారు.

391
00:21:05,000 --> 00:21:07,000
View కంట్రోలర్ అది ఎక్కడ క్లిక్ నియంత్రిస్తాయి.

392
00:21:07,000 --> 00:21:09,000
మీరు, దానికి ఇంటర్ఫేస్ లోకి డ్రాగ్ కు వెళ్ళి లేదా చేస్తున్నారు

393
00:21:09,000 --> 00:21:13,000
మీరు ఒక ఈవెంట్ నిర్వహణ హుక్ అప్ అనుకుంటే మీరు ఇంటర్ఫేస్ నుండి డ్రాగ్ చూడాలని

394
00:21:13,000 --> 00:21:15,000
ఇతర దిశలో.

395
00:21:15,000 --> 00:21:20,000
యొక్క ఒక రియల్లీ సింపుల్ iOS ఉదాహరణ పరిశీలించి చూద్దాం.

396
00:21:20,000 --> 00:21:23,000
>> యొక్క ఒక కొత్త ప్రాజెక్ట్ సృష్టించడానికి లెట్.

397
00:21:23,000 --> 00:21:25,000
నేను, అప్లికేషన్ ఇక్కడ వచ్చి వెళుతున్న

398
00:21:25,000 --> 00:21:28,000
మరియు నేను సింగిల్ అభిప్రాయాలను అప్లికేషన్ క్లిక్ వెళుతున్న.

399
00:21:28,000 --> 00:21:31,000
నేను తరువాత క్లిక్ చేయండి వెళుతున్న. నా ప్రాజెక్ట్ పేరు ఇస్తాము.

400
00:21:31,000 --> 00:21:33,000
నేను హలో పిలుస్తాను.

401
00:21:33,000 --> 00:21:36,000
ఆసక్తికరంగా, ఆపిల్ ఒక ఉత్పత్తి సృష్టిస్తున్నారు ఊహిస్తుంది

402
00:21:36,000 --> 00:21:38,000
కాబట్టి మీరు అమ్మవచ్చు మరియు వారు డబ్బు సంపాదించవచ్చు.

403
00:21:38,000 --> 00:21:41,000
డౌన్ ఇక్కడ నేను ఈ ఒక ఐఫోన్ అనువర్తనం పేర్కొన్నారు వెళుతున్న.

404
00:21:41,000 --> 00:21:44,000
మీరు ఒక ఐప్యాడ్ అనువర్తనం సృష్టించవచ్చు, లేదా ఆ అనువర్తనాల సృష్టించాలి కావాలా

405
00:21:44,000 --> 00:21:47,000
మీరు కూడా చేయవచ్చు రెండు పరికరాలకు మద్దతు ఇస్తుంది.

406
00:21:47,000 --> 00:21:49,000
ఈ మీరు మీ checkmarks లాగా ఏమి ఉన్నాయి.

407
00:21:49,000 --> 00:21:51,000
>> మీరు మేము తరువాత చూస్తారు ఇది స్టోరీబోర్డులు, ఉపయోగించాలనుకుంటున్నాను

408
00:21:51,000 --> 00:21:54,000
మరియు మీరు ఖచ్చితంగా, ఆటోమేటిక్ సూచన లెక్కింపు ఉపయోగించాలనుకుంటున్నాను

409
00:21:54,000 --> 00:21:58,000
ఇది malloc మరియు ఉచిత చెప్పడానికి కలిగి నుండి నిరోధిస్తుంది ఒక nice లక్షణం.

410
00:21:58,000 --> 00:22:03,000
మీరు malloc మరియు ఉచిత కాల్ మీరు తప్ప, నేను ఈ చూసినది వదిలిపెట్టేశాడు.

411
00:22:03,000 --> 00:22:07,000
నేను తరువాత క్లిక్ చేయండి చేస్తాము, మరియు నేను సేవ్ చోట చివరకు, ఈ నాకు చెప్పండి అన్నారు.

412
00:22:07,000 --> 00:22:14,000
నేను సృష్టించే హిట్ చేస్తాము, మరియు ఇక్కడ మేము వెళ్ళండి.

413
00:22:14,000 --> 00:22:16,000
నేను ఒక కొత్త ప్రాజెక్ట్ సృష్టించింది.

414
00:22:16,000 --> 00:22:19,000
ఇక్కడ ఎడమవైపు ఓవర్ నా ప్రాజెక్టు లోపల అన్ని ఫైళ్ళు ఉన్నాయి

415
00:22:19,000 --> 00:22:22,000
మరియు నేను మొత్తం బంచ్ వచ్చింది అని గమనించి, మరియు నేను ఏదైనా కూడా లేదు.

416
00:22:22,000 --> 00:22:24,000
IOS గొప్ప ఉంది.

417
00:22:24,000 --> 00:22:27,000
>> ఉదాహరణకు, ఇక్కడ ఈ ViewController.h,

418
00:22:27,000 --> 00:22:30,000
ఈ నా మొదటి అభిప్రాయం నియంత్రిక ప్రాతినిధ్యం అన్నారు

419
00:22:30,000 --> 00:22:32,000
నా అనువర్తనం యొక్క లోపల మొదటి తెరపై.

420
00:22:32,000 --> 00:22:34,000
ఇప్పుడు మేము ఈ చెబుతున్నారు తెలుసు.

421
00:22:34,000 --> 00:22:36,000
మేము, నేను ఈ తరగతి ViewController కాల్ చేస్తున్నాను చెబుతున్న దాన్ని

422
00:22:36,000 --> 00:22:40,000
మరియు ఒక ViewController, ఒక UIViewController చేసే ప్రతిదీ చేస్తుంది

423
00:22:40,000 --> 00:22:43,000
మరియు ఈ, మళ్ళీ, Apple మా సులభ stuff చాలా చేస్తుంది అని వ్రాసారు కొన్ని తరగతి ఉంది

424
00:22:43,000 --> 00:22:46,000
స్క్రీన్ ఇష్టం.

425
00:22:46,000 --> 00:22:50,000
నిజానికి నా అభిప్రాయం నియంత్రిక ఏమి నిర్వచించు ప్రారంభించడానికి మీకు ఇక్కడ,

426
00:22:50,000 --> 00:22:52,000
మరియు నేను నిజంగా ఈ ఏ అవసరం లేని అవుతుంది.

427
00:22:52,000 --> 00:22:55,000
ఈ Apple ఉచితంగా నాకు ఇచ్చే బాయిలెర్ప్లేట్ స్మృతి.

428
00:22:55,000 --> 00:22:59,000
నేను మొదటి లైన్ అవసరం చేశాడు, లేదా నేను క్లాస్ లేదు

429
00:22:59,000 --> 00:23:02,000
కాబట్టి మేము ఆ వదిలించుకోవటం మరియు ఈ విమోచనం పొందవచ్చు.

430
00:23:02,000 --> 00:23:05,000
సరే, ఈ నా ఖాళీ తెర ఉంది.

431
00:23:05,000 --> 00:23:08,000
>> ఇప్పుడు, ఈ యొక్క MainStoryboard.storyboard న క్లిక్ చేయండి

432
00:23:08,000 --> 00:23:11,000
అది ఆసక్తికరంగా పొందడానికి ప్రారంభిస్తారు మరియు ఈ ఉంది.

433
00:23:11,000 --> 00:23:14,000
ఈ నా అనువర్తనంలో మొదటి స్క్రీన్ సూచిస్తుంది.

434
00:23:14,000 --> 00:23:17,000
నేను ఒక బటన్ జోడించాలనుకుంటే, HTML లో నేను ఒక బటన్ ట్యాగ్ ఏర్పరచాలి.

435
00:23:17,000 --> 00:23:20,000
Android లో మీరు, ఒక బటన్ టాగ్ సృష్టించడానికి కలిగి

436
00:23:20,000 --> 00:23:23,000
కానీ iOS లో నేను క్రింద కుడి ఇక్కడికి వచ్చి ఉంటే

437
00:23:23,000 --> 00:23:27,000
నేను ఇక్కడ ఈ 3 వ ఒక క్లిక్ ఉంటే మరియు అది, Objects చెప్పారు పేరు

438
00:23:27,000 --> 00:23:31,000
మరియు నేను క్రిందికి స్క్రోల్ చేయవచ్చు, లేదా నేను బటన్ కోసం శోధించవచ్చు.

439
00:23:31,000 --> 00:23:35,000
నిజానికి అక్కడ ఈ కుడి డ్రాగ్ మరియు డ్రాప్ అయితే మరియు, ఒక బటన్ చూడండి

440
00:23:35,000 --> 00:23:38,000
నేను నా అనువర్తనంలో ఈ స్క్రీన్ బటన్ జోడించారు.

441
00:23:38,000 --> 00:23:41,000
నేను టెక్స్ట్ మార్చడానికి అనుకుంటే, నేను డబుల్, దాన్ని క్లిక్ చేయవచ్చు

442
00:23:41,000 --> 00:23:47,000
ఏదో వంటి మనోహరమైన మాట్లాడను "నా నొక్కండి."

443
00:23:47,000 --> 00:23:51,000
నేను ఈ అనువర్తనం అమలు చేస్తే సరే, ఇప్పుడు, కాబట్టి మేము, అది కంపైల్

444
00:23:51,000 --> 00:23:54,000
కాబట్టి ఇది అమలు చేయడానికి నేను ఎడమ లో ప్లే బటన్ క్లిక్ చేసి, నా అప్లికేషన్ ఉంది.

445
00:23:54,000 --> 00:23:58,000
నేను ఏమీ చేయలేదు, మరియు నేను తీపి చూస్తున్న ఐఫోన్ అనువర్తనం వచ్చింది.

446
00:23:58,000 --> 00:24:01,000
నేను ఆపడానికి, మీరు స్టాప్ బటన్ క్లిక్ చేయవచ్చు

447
00:24:01,000 --> 00:24:03,000
ఇది సరదాగా ఎందుకంటే.

448
00:24:03,000 --> 00:24:07,000
>> లెట్ యొక్క నిజానికి నేను ఈ బటన్ నొక్కండి ఏమి ఏదో కావలసిన చెప్పారు.

449
00:24:07,000 --> 00:24:09,000
నేను అవసరం అని చేయుటకు నేను సృష్టించాలి

450
00:24:09,000 --> 00:24:13,000
ఒక కొత్త సంఘటన హ్యాండ్లర్ లేదా ఒక చర్య.

451
00:24:13,000 --> 00:24:16,000
నేను అని మీరు పద్ధతి సృష్టించాలి అంటే

452
00:24:16,000 --> 00:24:18,000
నేను బటన్ నొక్కినప్పుడు, కాబట్టి యొక్క ఒక కొత్త పధ్ధతి తయారు తెలియజేయండి.

453
00:24:18,000 --> 00:24:20,000
నేను ViewController.h లోపలి ఉన్నాను.

454
00:24:20,000 --> 00:24:22,000
నేను ఒక పద్ధతి ఉందని చెప్పడానికి అవసరం.

455
00:24:22,000 --> 00:24:26,000
నేను వీక్షణ నియంత్రిక ఈ పిలుచుచున్నారు వెళుతున్న ఎందుకంటే నేను మొదటి ఒక అడ్డగీత అవసరం.

456
00:24:26,000 --> 00:24:28,000
నేను ఈ రకం ఇవ్వాలని అవసరం.

457
00:24:28,000 --> 00:24:31,000
ఈ రకం మేము ముందుగా భావించిన ఆ IBAction కాదు అన్నారు.

458
00:24:31,000 --> 00:24:35,000
ఈ కార్యక్రమం నిర్వహణ ఉంది, అది ఒక IBAction తిరిగి వెళుతున్న కాబట్టి

459
00:24:35,000 --> 00:24:38,000
మరియు ఈ అని XCode ఒక సూచనను ఉంది

460
00:24:38,000 --> 00:24:40,000
ఈ నేను ఏదో WIRE మీరు ఏదో ఉంది.

461
00:24:40,000 --> 00:24:45,000
నేను buttonPressed, సెమికోలన్ వలె, ఇది ఒక పేరు ఇస్తుంది.

462
00:24:45,000 --> 00:24:48,000
>> ఇప్పుడు నా క్లాస్ లోపల ఒక కొత్త పద్ధతి డిక్లేర్డ్ చేసిన.

463
00:24:48,000 --> 00:24:50,000
నేను ఈ పద్ధతి ఉనికిలో ఉంటుంది అన్నారు చేసాము.

464
00:24:50,000 --> 00:24:53,000
ఇప్పుడు ViewController.m వస్తాయి కదా,

465
00:24:53,000 --> 00:24:56,000
మరియు యొక్క ఈ పద్ధతి చెయ్యగలరు అని పిలవబడు.

466
00:24:56,000 --> 00:25:03,000
నేను టైప్ చెయ్యడం ప్రారంభించండి ఉంటే, ఉదాహరణకు, (తప్ప) buttonPressed

467
00:25:03,000 --> 00:25:06,000
ప్రకటన XCode నిజంగా నైస్ మరియు నాకు autocompletes.

468
00:25:06,000 --> 00:25:09,000
ఇది నిజంగా అద్భుతమైన ఉంది.

469
00:25:09,000 --> 00:25:12,000
. M ఫైల్ లోపల నేను కూడా తప్ప చెప్పగలదు ఇక్కడ గమనించండి,

470
00:25:12,000 --> 00:25:15,000
ఆ IBAction అసలైన రకం కాదు ఎందుకంటే మరియు ఈ ఉంది.

471
00:25:15,000 --> 00:25:19,000
ఇది వాస్తవానికి, ఒక చెల్లనిదనీ మరొక నిర్వచించిన హాష్ ట్యాగ్ యొక్క

472
00:25:19,000 --> 00:25:22,000
మళ్ళీ, ఈ కేవలం అని XCode ఒక సూచనను ఉంది

473
00:25:22,000 --> 00:25:25,000
నేను ఈ కార్యక్రమం నిర్వహణ ఉండాలనుకుంటున్నాను, మరియు ఎందుకు ఒక క్షణంలో మేము చూస్తారు.

474
00:25:25,000 --> 00:25:28,000
ఈ బటన్ నొక్కినప్పుడు నేను బాధించే ఏదో ఒకటి వెళుతున్న

475
00:25:28,000 --> 00:25:30,000
ఒక పాపప్ ను ప్రదర్శించడానికి ఇష్టం.

476
00:25:30,000 --> 00:25:35,000
>> నేను UIAlertView అని ఈ తరగతి యొక్క ఒక కొత్త ఉదాహరణకు సృష్టించవచ్చు ఆ చేయుటకు

477
00:25:35,000 --> 00:25:39,000
మరియు ఈ ఆపిల్ బాధించే పాప్అప్లని ప్రదర్శించడానికి జరగబోతోంది అని వ్రాసారు ఒక తరగతి ఉంది.

478
00:25:39,000 --> 00:25:43,000
మేము ఈ పాపప్ హెచ్చరిక పిలుస్తాను, మరియు నేను 2 దశలు ఉన్నాయి, ఈ వస్తువు రూపొందించటంలో గుర్తుంచుకోండి.

479
00:25:43,000 --> 00:25:46,000
నేను ఏమి చేయాలి మొదటి విషయం స్పేస్ కేటాయించాలని ఉంది.

480
00:25:46,000 --> 00:25:48,000
నేను ఒక UIAlertView కావలసిన.

481
00:25:48,000 --> 00:25:51,000
నేను స్పేస్ కేటాయించే కావలసిన. నా మొదటి పద్ధతి ఉంది.

482
00:25:51,000 --> 00:25:53,000
నా తదుపరి పద్ధతి, నేను ప్రారంభించడం దీనిని చేస్తారు

483
00:25:53,000 --> 00:25:58,000
మరియు నేను initWithTitle అని ఈ పెద్ద, దీర్ఘ పద్ధతి ఉంది.

484
00:25:58,000 --> 00:26:01,000
ప్రాథమికంగా ఈ పాపప్ చెప్పే నియంత్రించడానికి జరగబోతోంది.

485
00:26:01,000 --> 00:26:04,000
నా పాపప్ యొక్క శీర్షిక హలో ఉంటుంది.

486
00:26:04,000 --> 00:26:08,000
ఈ పాపప్ యొక్క సందేశం ఉంటుంది "ఈ iOS ఉంది."

487
00:26:08,000 --> 00:26:10,000
ప్రతినిధి విషయం, నేను ఆ ఏమి లేదు.

488
00:26:10,000 --> 00:26:13,000
లెట్ యొక్క ఇది ఏమీ మాట్లాడను.

489
00:26:13,000 --> 00:26:18,000
ఇప్పుడు కనిపించే అవకాశముంది బటన్ ", ఇది ఖచ్చితంగా" వంటి ఏదో చెప్పగలను

490
00:26:18,000 --> 00:26:24,000
మరియు నేను నిజంగా ఇతర బటన్లు ఇష్టం లేదు, కాబట్టి యొక్క ఆ తొలగించి బ్రాకెట్ దగ్గరగా తెలియజేయండి.

491
00:26:24,000 --> 00:26:27,000
>> ఓకే, నేను ఒక అదనపు ఒకటి. అక్కడ మేము వెళ్ళి.

492
00:26:27,000 --> 00:26:30,000
ఈ నేను కొత్త పాపప్ సృష్టించవచ్చు ఎలా ఉంది.

493
00:26:30,000 --> 00:26:35,000
నిజానికి పాపప్ చూపించు ఇఫ్ ఐ వాంట్ షో పద్ధతి కాల్ మీరు.

494
00:26:35,000 --> 00:26:38,000
నేను హెచ్చరిక మరియు ప్రదర్శన చెప్పగలదు ఆ చేయుటకు

495
00:26:38,000 --> 00:26:40,000
మళ్ళీ, స్వీయపూర్తి సూపర్ బాగుంది.

496
00:26:40,000 --> 00:26:42,000
నేను s లో టైప్ ఉంటే, దేని మర్చిపోయాను, ఉంటే

497
00:26:42,000 --> 00:26:45,000
నేను, ఇది ఏ గుర్తించడానికి ఇక్కడ స్క్రోలు చేయవచ్చు

498
00:26:45,000 --> 00:26:48,000
మరియు ఇది చక్కగా వేరు.

499
00:26:48,000 --> 00:26:52,000
ఇప్పుడు నేను ఈ కొత్త పాపప్ రూపొందించినవారు.

500
00:26:52,000 --> 00:26:55,000
మేము, తర్వాత ప్రతినిధి అర్థం వచ్చి చేస్తాము

501
00:26:55,000 --> 00:26:58,000
మరియు ఇప్పుడు నేను ఈ పద్ధతి ఉపయోగించవచ్చు అనుకుందాం మీరు

502
00:26:58,000 --> 00:27:01,000
నేను బటన్ నొక్కినప్పుడు, నా స్టోరీబోర్డ్ వచ్చి వెళుతున్న కాబట్టి

503
00:27:01,000 --> 00:27:04,000
ఇప్పుడు ఈ IBAction అటాచ్ కావలసిన.

504
00:27:04,000 --> 00:27:06,000
మీరు చేయాలనుకుంటున్నారా మొదటి విషయం బటన్ క్లిక్ చేయాలి.

505
00:27:06,000 --> 00:27:08,000
నేను ఈ బటన్ నొక్కినప్పుడు ఏమి ఏదో మీరు.

506
00:27:08,000 --> 00:27:10,000
నేను కంట్రోల్ తగ్గేందుకు వెళుతున్న కాదు.

507
00:27:10,000 --> 00:27:13,000
నేను క్లిక్ చేయండి మరియు బటన్ నుండి డ్రాగ్ వెళుతున్న

508
00:27:13,000 --> 00:27:15,000
ఇక్కడ పైగా ఎక్కడ అది అభిప్రాయాలను కంట్రోలర్ చెప్పారు.

509
00:27:15,000 --> 00:27:17,000
మేము ఇది చక్కగా అప్ వెలిగించే ఆ చూడగలరు.

510
00:27:17,000 --> 00:27:22,000
>> నా మౌస్ తో వెళ్ళి చేస్తే నేను కొన్ని ఎంపికలు ఉన్నాయి నేను ఎక్కడ ఇప్పుడు ఇక్కడ ఈ పాపప్ ఉన్నాయి.

511
00:27:22,000 --> 00:27:24,000
ఈ ఒకటి నేను నమోదు చేసే ఈవెంట్లను ఉంది.

512
00:27:24,000 --> 00:27:28,000
ఈ నా h ఫైలు IBActions గా ప్రకటించింది పద్ధతులను అన్ని.

513
00:27:28,000 --> 00:27:31,000
ఇది XCode ఈ చిన్న జాబితా కనిపిస్తాయి తెలుసు ఎలా ఉంది

514
00:27:31,000 --> 00:27:33,000
కాబట్టి ఇది ముందు సూచనను స్.

515
00:27:33,000 --> 00:27:37,000
నేను ఒత్తిడి బటన్ పై క్లిక్ చేస్తే, నేను ఇప్పుడు ఈవెంట్ హ్యాండ్లర్ నమోదు చేసిన.

516
00:27:37,000 --> 00:27:41,000
జావాస్క్రిప్ట్ లో మేము నేను ఈవెంట్ హ్యాండ్లర్ నమోదు కొన్ని కోడ్ ఉన్నాయి, అవి వచ్చింది.

517
00:27:41,000 --> 00:27:43,000
ఆబ్జెక్టివ్-C లో నిజంగా ఆ సులభం.

518
00:27:43,000 --> 00:27:46,000
నేను మళ్ళీ ఈ అమలు చేస్తే

519
00:27:46,000 --> 00:27:49,000
ఇప్పుడు నేను బటన్ నొక్కండి నా ఈవెంట్ నిర్వహణ, అగ్ని అన్నారు

520
00:27:49,000 --> 00:27:51,000
మరియు నేను ఈ పాపప్ పొందడానికి వెళుతున్న.

521
00:27:51,000 --> 00:27:54,000
అక్కడ సూపర్, సూపర్ సాధారణ.

522
00:27:54,000 --> 00:27:57,000
>> మీరు రిజిస్టర్ జరిగే సంఘటనలు అన్ని చూడాలనుకుంటే

523
00:27:57,000 --> 00:28:00,000
ఒక భాగంపై నేను ఈ బటన్ క్లిక్ చేస్తే

524
00:28:00,000 --> 00:28:02,000
మరియు నేను కుడివైపు ఇక్కడ పైగా వచ్చి

525
00:28:02,000 --> 00:28:05,000
మొదటి మీరు, నేను బటన్ రకం వంటి విషయాలను ఇక్కడ పైగా చూడగలరు

526
00:28:05,000 --> 00:28:08,000
ఆ నేను లేదా పరిచయాన్ని జోడించు బటన్ను ఒక అనుకుంటే

527
00:28:08,000 --> 00:28:10,000
లేదా ఏ.

528
00:28:10,000 --> 00:28:13,000
నేను ఈ బటన్ సంఘటనల యొక్క అన్ని చూడాలనుకుంటే

529
00:28:13,000 --> 00:28:16,000
నేను కుడివైపు ఇక్కడ అన్ని మార్గం వచ్చి ఉంటే

530
00:28:16,000 --> 00:28:19,000
మేము ఈ విభిన్న ఈవెంట్లలో అన్ని సందర్భాలలో ఇక్కడ చూడగలరు.

531
00:28:19,000 --> 00:28:23,000
నేను టాప్ రెట్టింపు లేదా ఎలాగైనా ఉన్నప్పుడు, బటన్ వీడలేదు, నేను, బటన్ నొక్కండి

532
00:28:23,000 --> 00:28:26,000
మరియు నేను నమోదు ఒకటి, ఈ సంఘటన ఇన్సైడ్ టచ్ పిలుస్తారు

533
00:28:26,000 --> 00:28:29,000
మరియు ఈ వెంటనే నా వేలు బటన్ ఆఫ్ వస్తుంది చెప్పారు

534
00:28:29,000 --> 00:28:32,000
ఆ సంఘటన అగ్ని అన్నారు, మరియు ఖచ్చితంగా కేవలం సంభవించి.

535
00:28:32,000 --> 00:28:36,000
ఈ డిఫాల్ట్ బటన్ ను నొక్కిన ఈవెంట్ యొక్క రకం.

536
00:28:36,000 --> 00:28:39,000
>> ఏదైనా ప్రశ్నలు ఇప్పటివరకు?

537
00:28:39,000 --> 00:28:43,000
సరే, మేము మా కోడ్ విషయాలు అప్ WIRE కు ప్రారంభించవచ్చు ఎలా

538
00:28:43,000 --> 00:28:46,000
మా ఇంటర్ఫేస్ యొక్క లోపల విషయాలు లోకి.

539
00:28:46,000 --> 00:28:49,000
మేము వచ్చింది మొదటి విషయం, కోడ్ కనుగొనేందుకు ఉంది గుర్తుంచుకో

540
00:28:49,000 --> 00:28:54,000
మరియు తర్వాత మేము, కోడ్ ఇంటర్ఫేస్ అప్ వైర్డు

541
00:28:54,000 --> 00:28:57,000
మరియు మా మొదటి అనువర్తనం లేదు.

542
00:28:57,000 --> 00:29:00,000
సరే, ఆ నిజంగా చల్లని ఉంది, మరియు మేము ఈ బటన్ సృష్టించింది.

543
00:29:00,000 --> 00:29:03,000
మేము ఉంటే లక్షణాలు కొంత సృష్టించడానికి కలిగి ఉండరాదని ఏమిటి

544
00:29:03,000 --> 00:29:05,000
ఈ బటన్ ప్రాతినిధ్యం?

545
00:29:05,000 --> 00:29:08,000
ఉదాహరణకు, ఈడ్పు టాక్ TOE లో నేను, 9 బటన్లను కలిగి

546
00:29:08,000 --> 00:29:11,000
మరియు అది 9 సార్లు డ్రాగ్ మరియు డ్రాప్ చేసుకోవడం సూపర్, సూపర్ బాధించే అంటాను

547
00:29:11,000 --> 00:29:14,000
లేదా నేను 81 తో ఈడ్పు టాక్ TOE తయారు బదులుగా 9 వచ్చింది ఉంటే

548
00:29:14,000 --> 00:29:17,000
మరియు నేను లాగి 81 సార్లు తొలగించడం వలన, మరియు ఆ మందకొడిగా ఉంది.

549
00:29:17,000 --> 00:29:20,000
మనం బదులుగా చేయవచ్చు చాలా ఒక HTML వలె ఉంటుంది

550
00:29:20,000 --> 00:29:23,000
మేము ID లు మరియు పేర్లు వంటి వాటిని కలిగి మరియు మేము విషయాలను శోధించవచ్చు ఉన్నప్పుడు

551
00:29:23,000 --> 00:29:27,000
వారి ID ద్వారా, ట్యాగ్లు అని iOS ఇదే భావన ఉంది.

552
00:29:27,000 --> 00:29:31,000
>> ఒక ట్యాగ్ కేవలం ఒక భాగం కోసం ఒక ఏకైక సంఖ్యా ఐడెంటిఫైయర్గా ఉంటుంది.

553
00:29:31,000 --> 00:29:34,000
నేను ఈ 0 యొక్క ట్యాగ్ను కలిగి ఉంటే, ఉదాహరణకు,

554
00:29:34,000 --> 00:29:38,000
నేను బటన్ను సృష్టించడానికి మరియు 0 యొక్క ట్యాగ్ను అందజేస్తారు, మరియు మేము ఒక క్షణంలో అలా ఎలా చూస్తారు ఉంటే,

555
00:29:38,000 --> 00:29:41,000
నేను బటన్ పొందాలనుకోవడం నేను కేవలం నేను కాల్ అనుకుందాం చేయవచ్చు

556
00:29:41,000 --> 00:29:45,000
ఇక్కడ పైగా వస్తువు మీద పద్ధతి viewWithTag,

557
00:29:45,000 --> 00:29:48,000
ఉదాహరణకు ప్రస్తుత స్క్రీన్ ను సూచించే self.view.

558
00:29:48,000 --> 00:29:53,000
నేను ఆ viewWithTag పద్ధతి కాల్ ఉంటే, నేను ట్యాగ్ 0 తో బటన్ పుల్ బాక్ వెళుతున్న.

559
00:29:53,000 --> 00:29:58,000
యొక్క భవనం ఈడ్పు టాక్ TOE ద్వారా ఈ పరిశీలించి చూద్దాం.

560
00:29:58,000 --> 00:30:01,000
మొదటి, ఈ నా స్టోరీబోర్డ్ ఉంది.

561
00:30:01,000 --> 00:30:05,000
నేను ఈ 10 UI బటన్లు సృష్టించారు.

562
00:30:05,000 --> 00:30:07,000
వారు ఒకే పరిమాణం ఉన్నారు గమనించండి.

563
00:30:07,000 --> 00:30:11,000
నేను ఈ ఒకదాన్ని క్లిక్ చేయండి మరియు నేను ఈ కుడివైపు ఇక్కడ పైగా తిరిగి రండి ఉంటే

564
00:30:11,000 --> 00:30:15,000
మీరు, నేను ఇక్కడ font సర్దుబాటు, నేను కొద్దిగా పెద్ద font చేసిన చూస్తారు

565
00:30:15,000 --> 00:30:19,000
కానీ నేను కూడా ఏమి నేను ఈ ట్యాగ్ సెట్ ఉంది.

566
00:30:19,000 --> 00:30:23,000
నేను ఈ 1 యొక్క ట్యాగ్ను చెప్పాడు, మరియు ఆ పైన ఎడమ ఉంది.

567
00:30:23,000 --> 00:30:26,000
>> ఇప్పుడు, నేను మరొక బటన్ను క్లిక్ చేస్తే, ఇక్కడ ఈ రెండవ విధంగా

568
00:30:26,000 --> 00:30:29,000
ఇప్పుడు మీరు నా ట్యాగ్ 2 అని చూస్తారు.

569
00:30:29,000 --> 00:30:32,000
ఈ బటన్ ప్రతి కేవలం, ఒక ఏకైక ట్యాగ్

570
00:30:32,000 --> 00:30:35,000
మరియు ఈ తరువాత ఎలా నేను పరస్పర ప్రారంభం వెళుతున్న ఉంది

571
00:30:35,000 --> 00:30:38,000
నా అనువర్తనంతో.

572
00:30:38,000 --> 00:30:40,000
ఇది ఒక అభిప్రాయం నియంత్రిక అన్ని లోపల ఉంది

573
00:30:40,000 --> 00:30:42,000
కానీ ఇక్కడ మేము చేసుకున్నది.

574
00:30:42,000 --> 00:30:44,000
మేము ఇక్కడ 3 లక్షణాలను కలిగి ఉంటాయి.

575
00:30:44,000 --> 00:30:49,000
మొదటి ఒక మరియు చివరి నా బోర్డు రాష్ట్ర ప్రాతినిధ్యం వెళ్తున్నారు.

576
00:30:49,000 --> 00:30:53,000
నిజానికి ఈ మొదటి ఒక Xs మరియు Os ఎక్కడ ప్రాతినిధ్యం వ్యూహం ఉంది.

577
00:30:53,000 --> 00:30:57,000
ఈ ఇతర దానిని ఇక్కడ దీని మలుపు ఇది మాకు చెబుతుంది.

578
00:30:57,000 --> 00:31:01,000
మీరు నేను కూడా ఇక్కడ ఈ విషయాలను కలిగి ఉండటం మీరు గమనించవచ్చు.

579
00:31:01,000 --> 00:31:05,000
ముందు మేము లక్షణాలు డిక్లేర్డ్ మేము వాటిని ఒక పేరు మరియు ఒక రకం ఇచ్చారు.

580
00:31:05,000 --> 00:31:08,000
మేము కూడా వాటిని ఇక్కడ కొన్ని అదనపు సమాచారం ఇస్తుంది.

581
00:31:08,000 --> 00:31:11,000
ఈ మొదటి nonatomic చెప్పాడు, ఇది ఏ చెప్పారు

582
00:31:11,000 --> 00:31:16,000
ప్రధానంగా మాత్రమే ఒక విషయం ఎప్పుడూ ఒక సమయంలో ఈ వేరియబుల్ యాక్సెస్ చేయడానికి ప్రయత్నిస్తున్న ఉంటుంది.

583
00:31:16,000 --> 00:31:19,000
మీరు బహుళ థ్రెడ్ అని క్లిష్టమైన అప్లికేషన్లు చేయగల

584
00:31:19,000 --> 00:31:22,000
అందువలన తిరిగి స్క్రాచ్ లో మేము వివిధ దారాలను కలిగి

585
00:31:22,000 --> 00:31:25,000
మరియు వివిధ స్ప్రిట్స్ ఒకే సమయంలో వేర్వేరు పనులను చేయవచ్చు.

586
00:31:25,000 --> 00:31:29,000
>> అది మేము చూడటం వస్తుంది ఆ ఏదైనా లేదు, ఈ సందర్భంలో,, కాకపోతే

587
00:31:29,000 --> 00:31:33,000
మేము nonatomic చెప్పుకోవాలంటే నిజానికి విషయాలు కొద్దిగా వేగంగా చేయడానికి జరగబోతోంది.

588
00:31:33,000 --> 00:31:37,000
మేము కూడా, కేటాయింపు బలమైన, బలహీనమైన లేదా అని ఈ విషయం ఉంది.

589
00:31:37,000 --> 00:31:40,000
ఈ కేటాయించి ఈ ఒక ప్రామాణిక పద్ధతి అని చెప్పాడు.

590
00:31:40,000 --> 00:31:43,000
ఈ ఒక bool ఈ, ఒక వస్తువు లేదా ఒక పాయింటర్ కాదు

591
00:31:43,000 --> 00:31:46,000
కాబట్టి bool ఆబ్జెక్టివ్-C లోనే ఉంది.

592
00:31:46,000 --> 00:31:49,000
ఈ ఇక్కడ గమనికలు తో ఫాన్సీ ఏమీ ప్రయత్నించండి లేదు అన్నారు.

593
00:31:49,000 --> 00:31:51,000
ఇది ఒక సాధారణ పాత పంటిగారను గీకి కంపనము కలిగించి నిర్మూలించి సాధనము లేదు.

594
00:31:51,000 --> 00:31:54,000
బలమైన మరియు బలహీనమైన, ఈ బలహీనమైన వాస్తవానికి చెప్పారు

595
00:31:54,000 --> 00:31:57,000
నేను ఈ అభిప్రాయాలను నియంత్రిక ఏదో సూచించే మీరు కోరుకుంటున్నారు.

596
00:31:57,000 --> 00:32:00,000
నిజానికి కేటాయించే వెళ్ళటం లేదా ఈ నాకు init లేదు.

597
00:32:00,000 --> 00:32:04,000
ఇంటర్ఫేస్ బిల్డర్, నేను అనువర్తనం అమలు చేసినప్పుడు, ఆ ప్రారంభ నిర్వహించడానికి అన్నారు.

598
00:32:04,000 --> 00:32:07,000
నేను బలహీనమైన చెప్పుకోవాలంటే, ఆ ఎవరో ఈ సృష్టించడం కావడం చెప్పారు.

599
00:32:07,000 --> 00:32:09,000
నేను బలమైన చెప్పుకోవాలంటే, ఈ నేను ఒకటిగా వెళుతున్న చెప్పారు

600
00:32:09,000 --> 00:32:12,000
ఆ, ఈ బోర్డు వస్తువు సృష్టించడం యొక్క

601
00:32:12,000 --> 00:32:14,000
మరియు ఇక్కడ నేను ఇక్కడ కొన్ని ఎక్కువ పద్ధతులు ఉన్నాయి

602
00:32:14,000 --> 00:32:18,000
ఉదాహరణకు, కొత్త గేమ్ బటన్ నొక్కినప్పుడు ఒక చర్య,

603
00:32:18,000 --> 00:32:20,000
ఇతర బటన్ల ఏ ఒత్తిడి చేసినప్పుడు ఒక చర్య,

604
00:32:20,000 --> 00:32:23,000
మరియు ఎట్ సెటేరా.

605
00:32:23,000 --> 00:32:26,000
>> మేము, ఈడ్పు టాక్ TOE యొక్క తర్కం యొక్క చాలా లోకి పొందరు

606
00:32:26,000 --> 00:32:30,000
అది చాలా ఉద్వేగాన్ని కలిగిస్తోంది, కానీ లెట్స్ పరిశీలించి అయితే

607
00:32:30,000 --> 00:32:33,000
మేము iOS లోపలి చేసే కొన్ని విషయాలను.

608
00:32:33,000 --> 00:32:35,000
ఈ కొత్త గేమ్ పద్ధతి ఉపయోగించవచ్చు అన్నారు

609
00:32:35,000 --> 00:32:37,000
నేను కొత్త ఆట బటన్ నొక్కండి చేసినప్పుడు.

610
00:32:37,000 --> 00:32:41,000
అప్ I కేవలం నా స్టోరీబోర్డు మీద వచ్చిన హుక్.

611
00:32:41,000 --> 00:32:43,000
నేను కొత్త ఆట క్లిక్.

612
00:32:43,000 --> 00:32:47,000
నేను ఇక్కడ పైగా వచ్చి ఉంటే నేను చూడగలరు

613
00:32:47,000 --> 00:32:50,000
NewGame పద్దతి వైర్డు ఉంది ఇన్సైడ్ అప్ తాకండి.

614
00:32:50,000 --> 00:32:53,000
ఈ తొలగించారు అన్నారు ఎందుకు పేర్కొంది.

615
00:32:53,000 --> 00:32:56,000
newGame పద్ధతి కొన్ని సెట్ అప్ చేయండి అన్నారు.

616
00:32:56,000 --> 00:32:59,000
నేను మీరు బోర్డు రాష్ట్ర క్లియర్ అనుకుందాం చెప్పారు.

617
00:32:59,000 --> 00:33:01,000
ఈ మ్యూట్ చేయగల శ్రేణులపై ఒక nice పద్ధతి.

618
00:33:01,000 --> 00:33:03,000
ఇది, ఇప్పుడు X యొక్క టర్న్ చెప్పడానికి అన్నారు

619
00:33:03,000 --> 00:33:07,000
మరియు ఇప్పుడు నేను ఈ viewWithTag విషయం యొక్క ప్రయోజనాన్ని వెళుతున్న.

620
00:33:07,000 --> 00:33:11,000
>> నేను, నా బటన్లు టాగ్లు 1-9 ఉందని మీకు

621
00:33:11,000 --> 00:33:13,000
మరియు నేను ఏకపక్ష ఎంపిక ఏదో ఉంది.

622
00:33:13,000 --> 00:33:15,000
నేను ఖాళీగా ప్రతి బటన్ టెక్స్ట్ సెట్ చేయాలనుకుంటే

623
00:33:15,000 --> 00:33:17,000
నేను ఒక కొత్త ఆట మొదలు మరియు నేను ఏ అనుకుంటున్న ఎందుకంటే

624
00:33:17,000 --> 00:33:20,000
నేను చేయవచ్చు పైగా Xs లేదా Os విడిచిపెట్టడం.

625
00:33:20,000 --> 00:33:24,000
నేను ట్యాగ్ తో వీక్షణ, 1, 2, 3, 4 et సెటేరా అనుకుందాం చేయవచ్చు.

626
00:33:24,000 --> 00:33:27,000
ఈ విభిన్న బటన్ ప్రతి సమయం పుల్ కనిపిస్తుంది.

627
00:33:27,000 --> 00:33:30,000
ఇక్కడ నేను UIButton దానిని తారాగణం వెళుతున్న.

628
00:33:30,000 --> 00:33:33,000
మేము తేలియాడుతున్న పక్కకు ints తారాగణం కాలేదు వలె

629
00:33:33,000 --> 00:33:37,000
ఈ నేను UIButton ఈ నటింపచేయాలని కావలసిన చెప్పారు.

630
00:33:37,000 --> 00:33:40,000
అనగా ఈ రకం ఒక UIButton * ఉంటుంది

631
00:33:40,000 --> 00:33:43,000
ఎందుకంటే గమనికలు యొక్క, అయితే చింతించకండి, వారు ఇకపై స్కేరీ లేదు.

632
00:33:43,000 --> 00:33:47,000
>> ఒకసారి నేను ఒక పద్ధతి కాల్ వెళుతున్న ఈ బటన్.

633
00:33:47,000 --> 00:33:50,000
ఈ పద్ధతి setTitle forState అని, అందువలన ఈ చెప్పారు ఉంది

634
00:33:50,000 --> 00:33:53,000
నేను, ఖాళీ స్ట్రింగ్ అయి బటన్ యొక్క టెక్స్ట్ సెట్ చేయాలనుకుంటున్నారా

635
00:33:53,000 --> 00:33:57,000
మరియు నేను దానిని నొక్కినప్పుడు కాదు ఉన్నప్పుడు ఖాళీ స్ట్రింగ్ ఉండాలనుకుంటున్నాను.

636
00:33:57,000 --> 00:34:01,000
నేను ఈ పద్ధతిని ఉపయోగించి, నేను బటన్ టెక్స్ట్ మార్చవచ్చు

637
00:34:01,000 --> 00:34:04,000
ఎవరైనా దానిని తాకిన, కాని మేము బటన్ అక్కడే కూర్చొని ఉన్నప్పుడు చెప్పాలనుకోవడం వెంటనే

638
00:34:04,000 --> 00:34:07,000
నేను టెక్స్ట్ ఖాళీ ఉండాలనుకుంటున్నాను.

639
00:34:07,000 --> 00:34:10,000
చివరగా, మేము, నా బోర్డు ప్రారంభించడం వెళుతున్న

640
00:34:10,000 --> 00:34:12,000
మరియు నేను, ప్రతిదీ 0 వద్ద ప్రస్తుతం పేర్కొన్నారు వెళుతున్న

641
00:34:12,000 --> 00:34:15,000
ఈ బోర్డు కాబట్టి సభ్యులు శాశ్వతమని, ఒక మ్యూట్ చేయగల శ్రేణి

642
00:34:15,000 --> 00:34:21,000
ఇది నేను addObject పద్ధతి మరియు ఇది కేవలం ఒక 0 లోపల కాల్ దీని అర్థం.

643
00:34:21,000 --> 00:34:23,000
నేను ఒక కొత్త గేమ్ ను ఏర్పరచటంలో ఏమి జరుగుతుంది ఉంది.

644
00:34:23,000 --> 00:34:25,000
>> యొక్క మరొక ఒక పరిశీలించి చూద్దాం.

645
00:34:25,000 --> 00:34:28,000
ఇక్కడ ఈ పద్ధతి ఒత్తిడి చేస్తాడు ఆ IBAction ఉంది

646
00:34:28,000 --> 00:34:31,000
ప్రతిసారీ ఆ కూడళ్లలో ఒకటి నొక్కినప్పుడు.

647
00:34:31,000 --> 00:34:33,000
ఇప్పుడు మేము కొన్ని ఈడ్పు టాక్ TOE ఇక్కడ లాజిక్ ఉంది.

648
00:34:33,000 --> 00:34:36,000
మేము, దీని మలుపు ఇది గుర్తించడానికి

649
00:34:36,000 --> 00:34:39,000
మరియు, మేము గాని ఒక X లేదా ఒక O సెట్ మీద ఆధారపడి

650
00:34:39,000 --> 00:34:43,000
కానీ మేము ఈ ఒకే ఈవెంట్ను హ్యాండ్లర్ తిరిగి చేస్తున్న గమనించి

651
00:34:43,000 --> 00:34:45,000
ఆ బటన్ల ప్రతి ఒకటి.

652
00:34:45,000 --> 00:34:49,000
నేను పైన ఎడమ బటన్ కొరకు పద్ధతి లేదు అని,

653
00:34:49,000 --> 00:34:52,000
నేను కుడి దిగువన బటన్ కోసం వేరొక పద్ధతి, ఆ పని కాలేదు కలిగి ఉంటాయి.

654
00:34:52,000 --> 00:34:54,000
ఆ మంచి డిజైన్ కాదు.

655
00:34:54,000 --> 00:34:57,000
నేను ఇక్కడ చేస్తున్నదాన్ని నిజానికి గుర్తించేందుకు వెళుతున్న ఉంది

656
00:34:57,000 --> 00:35:00,000
ఒత్తిడి చేశారు బటన్ ట్యాగ్ ఏమిటి.

657
00:35:00,000 --> 00:35:04,000
మీరు ఈ ఆట పద్ధతి ఒక వాదన సమయం పడుతుంది.

658
00:35:04,000 --> 00:35:07,000
ఇది పంపినవారు అని, మరియు సెండర్ పంపినవారు అన్నారు ఉంది ఉంది

659
00:35:07,000 --> 00:35:10,000
సరిగ్గా మీద చర్య తీసుకోలేదు ఏమి సూచిస్తాయి.

660
00:35:10,000 --> 00:35:15,000
నేను ఒక బటన్ నొక్కండి, ఈ సెండర్ ఆ UIButton అవతరిస్తుంది

661
00:35:15,000 --> 00:35:18,000
నిజానికి ఒత్తిడి, అందుచే అని ఆ UIButton

662
00:35:18,000 --> 00:35:20,000
నేను ఒక ట్యాగ్ రూపొందించినవారు ఎందుకంటే ఒక ట్యాగ్.

663
00:35:20,000 --> 00:35:23,000
>> నేను ట్యాగ్ తెలుసుకొనుట ఇఫ్ ఐ వాంట్ కేవలం చెప్పగలదు

664
00:35:23,000 --> 00:35:26,000
నేను, పంపినవారి ట్యాగ్ కావలసిన

665
00:35:26,000 --> 00:35:28,000
మళ్ళీ, నేను UIButton దానిని casted చేసిన.

666
00:35:28,000 --> 00:35:32,000
నేను పంపిన UIButton అని తెలుసుకోవటానికి పొందుతున్నారు.

667
00:35:32,000 --> 00:35:34,000
ఇది ఎల్లప్పుడూ ఒక UIButton అని లేదు.

668
00:35:34,000 --> 00:35:36,000
నేను, ఉదాహరణకు, ఒకే సంఘటన హ్యాండ్లర్ నమోదు కాలేదు

669
00:35:36,000 --> 00:35:38,000
 ఒక బటన్, ఒక స్లయిడర్ ఒక ఒక కోసం.

670
00:35:38,000 --> 00:35:40,000
ఈ సందర్భంలో, నేను వారు అన్ని బటన్లు కాదని మాకు తెలుసు, కాబట్టి నేను వెళుతున్నాను

671
00:35:40,000 --> 00:35:43,000
నేను ఈ బటన్ ఉండాలనుకుంటున్నాను, మరియు అప్పుడు నేను, ట్యాగ్ పొందవచ్చు

672
00:35:43,000 --> 00:35:48,000
మరియు ట్యాగ్ నుండి నేను ఇప్పుడు నేను బోర్డు యొక్క లోపల ఎక్కడ తెలుసు.

673
00:35:48,000 --> 00:35:51,000
అప్పుడు నేను కేవలం X లేదా O, మలుపు ఫ్లిప్, గాని సెట్ చేయవచ్చు

674
00:35:51,000 --> 00:35:54,000
, et సెటేరా గెలుచుకున్న తనిఖీ.

675
00:35:54,000 --> 00:35:59,000
>> ఈ ఇప్పటివరకు ఏ ప్రశ్నలు?

676
00:35:59,000 --> 00:36:02,000
సరే, మేము ఆన్లైన్-మేము చాలా పొందడానికి అనుకుంటున్న పోస్ట్ అన్ని కోడ్

677
00:36:02,000 --> 00:36:06,000
ఈడ్పు టాక్ TOE తర్కం యొక్క, కానీ ఇప్పుడు మీరు ఆ నిజంగా చూడగలరు

678
00:36:06,000 --> 00:36:09,000
మేము చేస్తున్నా అన్ని, మేము ఈ శ్రేణి మీద మళ్ళీ వెతికినా చేస్తున్న ఉంది

679
00:36:09,000 --> 00:36:13,000
కాబట్టి మేము ఇక్కడ ఉచ్చులు కోసం ఒక జంట కలిగి, మరియు మేము కేవలం చూడటానికి పోల్చడం చేస్తున్నారు

680
00:36:13,000 --> 00:36:18,000
మేము అన్ని వరుసలు, ఆ వంటి కాలమ్ లేదా ఏదైనా ఒక మ్యాచ్కు ఉన్నాయి.

681
00:36:18,000 --> 00:36:21,000
నేను ఈ బటన్ల ఒక నొక్కండి ఉంటే వాస్తవానికి, ఈ అనువర్తనం అమలు

682
00:36:21,000 --> 00:36:24,000
ఆ ఆట పద్ధతి తొలగించారు, నేను సెట్ అనగా కాబట్టి

683
00:36:24,000 --> 00:36:31,000
బటన్ ఒక X అని, కాబట్టి ఇప్పుడు ఈ బటన్, ఒక O ఆ విధంగా ఉంటుంది

684
00:36:31,000 --> 00:36:35,000
అందువలన, మేము ఈ సింగిల్ పేజీ అనువర్తనం సంప్రదించుటకు మొదలు పెడుతున్నారు ఎలా.

685
00:36:35,000 --> 00:36:38,000
>> మేము కోడ్ పోస్ట్ చేస్తాము, కాబట్టి ఆ పరిశీలనగా సంకోచించకండి,

686
00:36:38,000 --> 00:36:43,000
కానీ ప్రస్తుతం కేవలం ఒక పేజీ కంటే కొన్ని Apps గురించి మాట్లాడేందుకు అనుమతిస్తాయి.

687
00:36:43,000 --> 00:36:47,000
ఈడ్పు టాక్ TOE గా అద్భుతమైన iOS లోపలి Apps చాలా ఉంది

688
00:36:47,000 --> 00:36:50,000
ఈ డ్రిల్ రకం బహుళ తెరలు తో విషయాలు ఉండవు.

689
00:36:50,000 --> 00:36:54,000
మేము మాట్లాడటానికి అవసరం మొదటి భావన, ప్రోటోకాల్లు

690
00:36:54,000 --> 00:36:57,000
మరియు ఒక ప్రోటోకాల్ కేవలం పద్ధతులు సమితి

691
00:36:57,000 --> 00:36:59,000
మీరు నిర్వచించడానికి హామీ ఆ.

692
00:36:59,000 --> 00:37:02,000
నేను 2 విధానాలతో ఈ కొత్త ప్రోటోకాల్, ఈ మొదటి ఒకటి, సృష్టిస్తే

693
00:37:02,000 --> 00:37:05,000
తిరిగి టైప్ తప్ప ఉంటే, నేను foo అని.

694
00:37:05,000 --> 00:37:07,000
ఇది ఎటువంటి వాదనలూ లేవు పడుతుంది. నేను మరొక పద్ధతి ఉంది.

695
00:37:07,000 --> 00:37:11,000
ఇది ఒక పూర్ణాంకానికి తిరిగి. నేను ఆడడానికి అని, మరియు ఇది ఒక వాదన పడుతుంది.

696
00:37:11,000 --> 00:37:14,000
ఈ ప్రోటోకాల్, ఇక్కడ SomeProtocol అప్ అని ఉంది

697
00:37:14,000 --> 00:37:19,000
ఈ ఎవరైనా అమలు చేసే విషయాలను సమితి.

698
00:37:19,000 --> 00:37:22,000
నేను లోపల ఈ ప్రోటోకాల్ యొక్క foo ఏమి చెప్పాడు లేదు.

699
00:37:22,000 --> 00:37:26,000
బదులుగా, నేను మీరు అనుకుంటే మీరు foo నిర్వచించే కాలేదు మాట్లాడుతూ నేను.

700
00:37:26,000 --> 00:37:30,000
నేను వీక్షణ నియంత్రిక సృష్టించడానికి ఒక తరగతి సృష్టించడం నేను ఉంటే

701
00:37:30,000 --> 00:37:33,000
నేను లోపల తరగతి ప్రామిస్ అమలు చేయవచ్చు

702
00:37:33,000 --> 00:37:40,000
వీటిలో కొన్ని పద్దతులు, కాబట్టి, ఉదాహరణకు, <SomeProtocol> సే

703
00:37:40,000 --> 00:37:43,000
ఈ ఇప్పుడు నేను మీరు ప్రతిజ్ఞ చేయడం చేసాను అని లోపల

704
00:37:43,000 --> 00:37:50,000
ఈ అభిప్రాయాలను నియంత్రిక తరగతి నేను foo మరియు బార్ రెండు కోసం నిర్వచనాలు ఉంటుంది.

705
00:37:50,000 --> 00:37:52,000
>> ఎందుకు ఆ ఉపయోగపడుతుంది?

706
00:37:52,000 --> 00:37:55,000
IOS లోపలి భాగాలు చాలా ఈ ప్రయోజనాన్ని

707
00:37:55,000 --> 00:37:58,000
రూపకల్పన నమూనా బృందంతో అని, ప్రతినిధుల్లో ఏమి చెప్పారు

708
00:37:58,000 --> 00:38:01,000
అంటే, ఉదాహరణకు, నేను ఒక టెక్స్ట్ బాక్స్ ఉంటే

709
00:38:01,000 --> 00:38:04,000
మరియు నా టెక్స్ట్ బాక్స్ లోపల నమోదు అని కొన్ని సంఘటనలు ఉన్నాయి

710
00:38:04,000 --> 00:38:07,000
బదులుగా నేను చెయ్యగలరు ప్రత్యేక సంఘటనలు కంటే నేను చెప్పగలను ఉంది

711
00:38:07,000 --> 00:38:10,000
ఈ టెక్స్ట్ బాక్స్ ప్రతినిధి కొన్ని వస్తువు ఉంటుంది.

712
00:38:10,000 --> 00:38:13,000
నేను ఈ ఇప్పుడు ఒక ప్రతినిధి అని చెప్పినప్పుడు ఆ అర్థం

713
00:38:13,000 --> 00:38:16,000
కొన్ని ఈవెంట్ టెక్స్ట్ బాక్స్ లో ఎక్కడ ఉండేది చేసినప్పుడు

714
00:38:16,000 --> 00:38:18,000
కంటే లేదా అలాంటిదే ఏదైనా నమోదు అవసరం

715
00:38:18,000 --> 00:38:21,000
ఇది ప్రతినిధి ఒక పద్ధతి కాల్ చెప్పారు.

716
00:38:21,000 --> 00:38:24,000
ఉదాహరణకు, లోపల నా టెక్స్ట్ బాక్స్ నేను నొక్కినప్పుడు ఒక పద్ధతి కలిగి

717
00:38:24,000 --> 00:38:27,000
ఆ, క్రింద కుడి బటన్ పూర్తి

718
00:38:27,000 --> 00:38:30,000
అందువలన కాకుండా నేను చెప్పగలను ఏమి ఈవెంట్ నిర్వహణ ఉంది నమోదు

719
00:38:30,000 --> 00:38:34,000
టెక్స్ట్ బాక్స్, ఇక్కడ నేను మీరు ఒక పద్ధతి కాల్ చేయదలిచిన ఒక వస్తువు

720
00:38:34,000 --> 00:38:37,000
అయినా ఎవరో ఒకరు యంత్రాలపై చేసిన బటన్

721
00:38:37,000 --> 00:38:40,000
మరియు ఆ వస్తువు కొన్ని ప్రోటోకాల్ అమలు ఉంటుంది అర్థం

722
00:38:40,000 --> 00:38:45,000
ఆ నేను, ఆ పని బటన్ చర్య నిర్వచించడానికి హామీ చెప్పారు

723
00:38:45,000 --> 00:38:47,000
ఎందుకంటే ఆ పద్ధతి నిర్వచించలేదు మరియు మీరు పూర్తి ప్రెస్ ఉంటే,

724
00:38:47,000 --> 00:38:49,000
అప్పుడు కంగారు చేస్తాడు.

725
00:38:49,000 --> 00:38:55,000
>> యొక్క ఒక ఉదాహరణ పరిశీలించి చూద్దాం.

726
00:38:55,000 --> 00:38:58,000
ఇక్కడ నేను కేవలం, ఒక టెక్స్ట్ బాక్స్

727
00:38:58,000 --> 00:39:04,000
మరియు ఈ కుడివైపు ఇక్కడ ఈ టెక్స్ట్ బాక్స్ లక్షణాలను ఒకటి ప్రతినిధి ఉంది.

728
00:39:04,000 --> 00:39:06,000
ఈ తరగతి యొక్క ఒక లక్షణం ఉంది.

729
00:39:06,000 --> 00:39:09,000
నేను ఇక్కడ చేశాడు నేను క్లిక్ నియంత్రించడానికి, నేను ఇక్కడ ఈ ప్రదేశం నుండి లాగారు

730
00:39:09,000 --> 00:39:13,000
అభిప్రాయం నియంత్రిక, మరియు ఇప్పుడు ఈ టెక్స్ట్ బాక్స్ ప్రతినిధి చెప్పారు

731
00:39:13,000 --> 00:39:18,000
వీక్షణ నియంత్రిక అని అన్నారు.

732
00:39:18,000 --> 00:39:20,000
కొన్ని చర్యలు జరిగే కాకుండా నమోదు చేయకుండా అని

733
00:39:20,000 --> 00:39:25,000
నేను మీరు ప్రతినిధి వాటిని పంపాలని ప్రత్యేక కార్యక్రమం నిర్వాహకులు.

734
00:39:25,000 --> 00:39:28,000
ఇప్పుడు నా అభిప్రాయం నియంత్రిక పరిశీలించి అనుమతిస్తుంది.

735
00:39:28,000 --> 00:39:32,000
. H ఫైల్ లోపల నేను ప్రతిజ్ఞ చేసిన.

736
00:39:32,000 --> 00:39:36,000
నేను ఈ ప్రోటోకాల్ యొక్క లోపల కొన్ని పద్ధతులు అమలు వాగ్దానం చేసిన

737
00:39:36,000 --> 00:39:38,000
UITextFieldDelegate, మరియు తిరిగి, అని

738
00:39:38,000 --> 00:39:42,000
ఇది నేను అమలు ఎంచుకోవచ్చు కొన్ని కొన్ని విషయాలు జాబితా ఉంది.

739
00:39:42,000 --> 00:39:46,000
>> నా. M ఫైలు ఇక్కడ వచ్చి ఉంటే, నేను అలాంటి విధానం అమలు చేశారు.

740
00:39:46,000 --> 00:39:49,000
నేను textFieldShouldReturn అని చేసిన

741
00:39:49,000 --> 00:39:52,000
అది ప్రోటోకాల్ యొక్క లోపల అని పిలిచారు ఎందుకంటే.

742
00:39:52,000 --> 00:39:57,000
ఇప్పుడు నేను ఆ టెక్స్ట్ ఫీల్డ్ యొక్క పూర్తి బటన్ నొక్కండి లోపల చేసినప్పుడు

743
00:39:57,000 --> 00:40:00,000
ఈ అనే పెట్టడానికి ఏమి ఉంది, నేను ఒక సంఘటన హ్యాండ్లర్ నమోదు చేయలేదు.

744
00:40:00,000 --> 00:40:03,000
నేను ప్రతినిధి అనుసంధానం మరియు ఈ సంఘటన తొలగించి చేసినప్పుడు

745
00:40:03,000 --> 00:40:08,000
ఈ నా స్టోరీబోర్డ్ ఇక్కడ పైగా వచ్చి అమలు అయితే, అని పొందుతాయి పద్ధతి అది-

746
00:40:08,000 --> 00:40:11,000
ఆ లోడ్ సమయంలో మేము ఈ ఏమి చూడగలరు.

747
00:40:11,000 --> 00:40:13,000
నా తెరపై నేను 2 విషయాల్లో.

748
00:40:13,000 --> 00:40:16,000
నేను ఈ టెక్స్ట్ ఫీల్డ్ లేదు, నాకు ఈ లేబుల్ ఉంది.

749
00:40:16,000 --> 00:40:19,000
నేను కేవలం నేను ఈ లేబుల్ యొక్క టెక్స్ట్ మాట్లాడుతూ నేను

750
00:40:19,000 --> 00:40:23,000
యూజర్ టెక్స్ట్ ఫీల్డ్ లోపల లో టైప్ ఏ కు సమానమైనది.

751
00:40:23,000 --> 00:40:26,000
ఇక్కడ ఈ తదుపరి లైన్ కేవలం నేను కాల్ చేస్తున్నాను ఒక పద్ధతి

752
00:40:26,000 --> 00:40:29,000
నేను మీరు కీబోర్డ్ దాచాలనుకుంటున్నారా అని టెక్స్ట్ ఫీల్డ్ లో.

753
00:40:29,000 --> 00:40:33,000
ఇది ఆపిల్ యెంచుకొనిన ఏకపక్ష పద్ధతి.

754
00:40:33,000 --> 00:40:38,000
>> నేను ప్రతిదీ అప్ WIRE వచ్చింది ఏదీ ముందు, నేను మొదటి ఇక్కడ పైగా వచ్చింది.

755
00:40:38,000 --> 00:40:42,000
వీక్షణ నియంత్రిక నేను టెక్స్ట్ బాక్స్ కు లాగండి.

756
00:40:42,000 --> 00:40:46,000
నేను ఈ టెక్స్ట్ ఫీల్డ్ ఆస్తి చేసే నేను వీడలేదు, మరియు నేను ఇక్కడ చూడగలరు

757
00:40:46,000 --> 00:40:49,000
పైగా ఇక్కడ వీక్షణ నియంత్రిక లో నుండి నేను ఒక ఆస్తిని నిర్వచించిన చేసిన

758
00:40:49,000 --> 00:40:52,000
ఒక టెక్స్ట్ ఫీల్డ్ ఒక IBOutlet ఉంది.

759
00:40:52,000 --> 00:40:55,000
ఈ నేను ఈ ఆస్తి అప్ WIRE చేయవచ్చు చెప్పారు

760
00:40:55,000 --> 00:40:59,000
నా UI లో ఒక టెక్స్ట్ ఫీల్డ్ కు.

761
00:40:59,000 --> 00:41:03,000
ఇప్పుడు నేను ఈ క్లిక్ చేసినప్పుడు నేను టైప్ చెయ్యవచ్చు.

762
00:41:03,000 --> 00:41:06,000
నేను చేసిన బటన్ను క్లిక్ చేస్తే ఇప్పుడు ఈ కాల్పులు అన్నారు

763
00:41:06,000 --> 00:41:08,000
నేను ఇప్పుడు స్పందించడం చేసే కార్యక్రమం.

764
00:41:08,000 --> 00:41:10,000
ఏ పరిస్థితుల్లోనూ హ్యాండ్లర్లు.

765
00:41:10,000 --> 00:41:13,000
నేను ఆ పని బటన్ స్పందించింది ఎలా.

766
00:41:13,000 --> 00:41:15,000
సమంజసం?

767
00:41:15,000 --> 00:41:20,000
>> ఇది మీరు ఆ ఎప్పుడూ మీరే లభించకపోవచ్చు ఒక నమూనా నమూనా కాదు

768
00:41:20,000 --> 00:41:23,000
మీ స్వంత ప్రోటోకాల్ సృష్టించడం, కానీ తెలిసిన కొన్ని

769
00:41:23,000 --> 00:41:27,000
వివిధ iOS భాగాలు వివిధ మార్గాల్లో ఈవెంట్స్ నమోదు.

770
00:41:27,000 --> 00:41:29,000
బటన్లు, ఉదాహరణకు, ఆ IBActions ఉపయోగించండి.

771
00:41:29,000 --> 00:41:32,000
టెక్స్ట్ ఖాళీలను, మరోవైపు, ప్రతినిధులు ఉపయోగించడానికి వెళ్తున్నారు.

772
00:41:32,000 --> 00:41:36,000
మేము చూడగలరు మరియు మీరు పత్రికీకరణ యొక్క అప్ లోపల అన్ని చూడవచ్చు.

773
00:41:36,000 --> 00:41:41,000
మార్గం ద్వారా, మీరు కోసం iOS నిర్మించారు UI stuff ఒక టన్ను, వాస్తవానికి ఉంది

774
00:41:41,000 --> 00:41:46,000
కాబట్టి, ఉదాహరణకు విధంగా నేను కుడి దిగువన జరుగుతుంది పేర్కొన్నట్లు చేసిన

775
00:41:46,000 --> 00:41:48,000
నేను ఈ టెక్స్ట్ ఫీల్డ్ ఎంపిక.

776
00:41:48,000 --> 00:41:50,000
నేను ఇక్కడ పైగా వచ్చింది.

777
00:41:50,000 --> 00:41:53,000
నేను, కీ తిరిగి కొంచెం నెమ్మదిగా scrolled

778
00:41:53,000 --> 00:41:56,000
నేను ఆ అనుకుంటే ఇష్టం వాస్తవానికి, ఈ విషయాలను మొత్తం బంచ్ చేయవచ్చు

779
00:41:56,000 --> 00:42:00,000
అత్యవసర బదులుగా నేను, పూర్తిగా రాండమ్ ఇది ఆ చేయవచ్చు కాల్

780
00:42:00,000 --> 00:42:02,000
ఒక అంతర్నిర్మిత అత్యవసర కాల్ బటన్ ఉంది ఎందుకు నేను, తెలియదు

781
00:42:02,000 --> 00:42:06,000
అయితే, నిజంగా చిన్న అక్షరాలు అత్యవసర కాల్ అది.

782
00:42:06,000 --> 00:42:08,000
అక్కడ మీరు వెళ్ళండి.

783
00:42:08,000 --> 00:42:12,000
>> ఖచ్చితంగా iOS ఈ వివిధ ఎంపికలు అన్ని అన్వేషించండి.

784
00:42:12,000 --> 00:42:14,000
ప్రతినిధులు ఏ ప్రశ్నలు?

785
00:42:14,000 --> 00:42:18,000
మరలా, మీరు తెలిసి ఉండాలి ఒక ఆసక్తికరమైన రూపకల్పన నమూనా.

786
00:42:18,000 --> 00:42:22,000
సరే, తరువాత పట్టిక అభిప్రాయాలు పరిశీలించి అనుమతిస్తుంది.

787
00:42:22,000 --> 00:42:26,000
ఒక పట్టిక వీక్షణ ప్రధానంగా అన్ని iOS లో కంటే వస్తువుల జాబితా ఉంది.

788
00:42:26,000 --> 00:42:29,000
మీరు మీ అన్ని పరిచయాలు ద్వారా వేగంగా కదలటం చేసిన తర్వాత, మీరు శోధిస్తున్న

789
00:42:29,000 --> 00:42:34,000
సెట్ పేజీ, మరియు విషయాల జాబితా అటువంటి ఒక పట్టిక వీక్షణ అంటారు.

790
00:42:34,000 --> 00:42:37,000
IOS ఒక పట్టిక వీక్షణ అమలు అందంగా సులభం.

791
00:42:37,000 --> 00:42:41,000
బదులుగా ఆ UIViewController వారసత్వం నుండి ఉద్భవించింది ఒక తరగతి చేయడానికి

792
00:42:41,000 --> 00:42:44,000
మేము కేవలం చెప్పడానికి కాకుండా అవసరం ముందు మేము చేసిన వంటి

793
00:42:44,000 --> 00:42:46,000
ఒక UIViewController నేను చేయాలనుకుంటున్నారా చేసిన ప్రతిదీ,

794
00:42:46,000 --> 00:42:50,000
నేను, ఒక UITableViewController నేను చేయాలనుకుంటున్నారా చేసిన ప్రతిదీ సే

795
00:42:50,000 --> 00:42:54,000
తద్వారా కేవలం పూర్తిగా మాకు చేసిన కొన్ని అదనపు విషయాలను జతచేస్తుంది.

796
00:42:54,000 --> 00:42:58,000
మేము ప్రధానంగా పట్టిక లోపల ఖాళీలను పూరించడానికి చాలా తక్కువగా వుంటుంది.

797
00:42:58,000 --> 00:43:02,000
>> నేను కొన్ని ప్రశ్నలకు సమాధానం అవసరం పట్టిక ప్రదర్శించడానికి వీలుగా.

798
00:43:02,000 --> 00:43:06,000
నేను సమాధానం ఇవ్వాలి మొదటి ప్రశ్న పట్టిక లో ఎన్ని విభాగాలు ఉంది?

799
00:43:06,000 --> 00:43:08,000
మీరు మీ పరిచయాలను అప్లికేషన్ ద్వారా వేగంగా కదలటం చేసిన తర్వాత మీరు రకమైన అని మీరు గమనించవచ్చు

800
00:43:08,000 --> 00:43:12,000
నాటికి నిర్వహించిన, అప్పుడు మీరు Bs ఉన్నాయి, మరియు మీరు ఆ చిన్న ఉప శీర్షిక ఉన్నాయి.

801
00:43:12,000 --> 00:43:14,000
ఆ ప్రతి ఒక విభాగం అంటారు.

802
00:43:14,000 --> 00:43:16,000
మీరు లేదా ఈ అవసరములేదు.

803
00:43:16,000 --> 00:43:19,000
మీరు చెయ్యాల్సిన మొదటి విషయం ఒక పద్ధతి అమలు ఉంది

804
00:43:19,000 --> 00:43:22,000
numberOfSectionsInTableView: టేబుల్ వ్యూ అని.

805
00:43:22,000 --> 00:43:25,000
ఊరికే, మీరు ఎన్ని విభాగాలు తిరిగి

806
00:43:25,000 --> 00:43:29,000
ఈ మీరు ఒక పెద్ద పట్టిక వీక్షణ ఉంటే ఒక తిరిగి చెప్పొచ్చు.

807
00:43:29,000 --> 00:43:33,000
iOS తెలుసుకోవాలి ఆ తదుపరి ప్రశ్నకు మీరు ఎన్ని వరుసలు ఉన్నాయి ఉంది?

808
00:43:33,000 --> 00:43:36,000
ఉదాహరణకు, మీరు ఒక పట్టిక వీక్షణ ద్వారా నొక్కి పెట్టటం చేస్తున్నారు.

809
00:43:36,000 --> 00:43:39,000
మీరు మీరు శోధిస్తున్న పాటలు ఒక స్థిర సంఖ్యలో లేదా పరిచయాలను ఒక స్థిర సంఖ్యలో ఉన్నాయి.

810
00:43:39,000 --> 00:43:41,000
మీరు,, కోర్సు యొక్క, అనేక లేదు నాకు ఉన్నాము

811
00:43:41,000 --> 00:43:44,000
అందువలన, iOS ప్రదర్శించడానికి ఎన్ని కణాలు తెలుసు ఎలా.

812
00:43:44,000 --> 00:43:46,000
>> మళ్ళీ, ఈ తిరిగి 3 లాగ చెప్పొచ్చు.

813
00:43:46,000 --> 00:43:49,000
నా పట్టిక వీక్షణ 3 వరుసలు కలిగి ఉంది.

814
00:43:49,000 --> 00:43:52,000
చివరగా, iOS, ప్రతి కణ ఎలా తెలుసుకోవాలి

815
00:43:52,000 --> 00:43:54,000
సో వాట్ నిజానికి ఏమి జరగబోతోంది, డౌన్ ఇక్కడ ఈ పద్ధతి పిలుపు

816
00:43:54,000 --> 00:43:57,000
ఈ టేబుల్ వ్యూ: cellForRowAtIndexPath.

817
00:43:57,000 --> 00:44:01,000
మీ పట్టిక లోపల ప్రతి కణం ఈ పద్ధతి కాల్ చెప్పారు.

818
00:44:01,000 --> 00:44:03,000
ఎలా దీన్ని పిలువాలని ఎన్ని సార్లు తెలుసా?

819
00:44:03,000 --> 00:44:06,000
సరే, మీరు విభాగంలో వరుసలను సంఖ్య లోపల చెప్పారు.

820
00:44:06,000 --> 00:44:08,000
మేము, మా కణాలు ప్రతి ఈ కాల్ చూడాలని

821
00:44:08,000 --> 00:44:11,000
మీరు నిజంగా వంటి విషయాలను ఇక్కడ మరియు లోపల ఈ ఉంది

822
00:44:11,000 --> 00:44:16,000
టెక్స్ట్ సెట్ లేదా కుడి వైపున ఉండే చిన్న నీలం బటన్ ఏమి తెలుస్తుంది.

823
00:44:16,000 --> 00:44:19,000
ఈ కణాలు పొందడానికి నమూనా, మేము ఈ పద్ధతిని ఉపయోగిస్తారు వెళుతున్న

824
00:44:19,000 --> 00:44:22,000
dequeueReusableCellWithIdentifier అని.

825
00:44:22,000 --> 00:44:29,000
>> ఆబ్జెక్టివ్-C, వారి పద్ధతి పేర్లు హాస్యాస్పదంగా పొడవు కోసం బాగా తెలిసిన నిజానికి ఉంది

826
00:44:29,000 --> 00:44:32,000
మరియు ఈ నిజంగా పాయింట్ ఉదాహరణకు ఒక నైస్ విషయం.

827
00:44:32,000 --> 00:44:37,000
ఈ ఈ పద్ధతి ఉండదు కేవలం నాకు ఒక సెల్ ఇవ్వాలని అన్నారు.

828
00:44:37,000 --> 00:44:39,000
జస్ట్ ఒక iOS విషయం.

829
00:44:39,000 --> 00:44:41,000
మీరు మీ ఐపాడ్ న 100,000 పాటలు లాగ ఉంటే

830
00:44:41,000 --> 00:44:45,000
ఏ iOS చేయాలనుకుంటున్నారా లేదు, 100,000 సెల్స్ కేటాయించాలని ఉంది

831
00:44:45,000 --> 00:44:48,000
మీ జాబితా ఎగువన, మీరు నిజంగా మెమరీని కేటాయించాల్సిన అవసరం ఎందుకంటే

832
00:44:48,000 --> 00:44:51,000
డౌన్ 99,000 వరుసలు అని సెల్ కోసం?

833
00:44:51,000 --> 00:44:55,000
లేదు, మీరు స్క్రోలింగ్ చేస్తున్నపుడు మీరు సహకరించు వంటి కేటాయించాలని రకం ఎందుకంటే.

834
00:44:55,000 --> 00:44:57,000
మీరు చేయబడుతుంది.

835
00:44:57,000 --> 00:44:59,000
మీరు ఆ స్టుపిడ్ ప్రదర్శన విషయాల గురించి ఆందోళన లేదు.

836
00:44:59,000 --> 00:45:02,000
మీరు చెప్పే అన్ని మీరు, ఈ పద్ధతి dequeueReusableCellWithIdentifier పిలుస్తారు

837
00:45:02,000 --> 00:45:06,000
మీరు మీ కోసం నేను ఒక కొత్త సెల్ సృష్టించడానికి వెళుతున్న అవసరం ఉంటే ఈ, సరే అన్నారు.

838
00:45:06,000 --> 00:45:09,000
>> మీరు పట్టిక దిగువన ఉన్నారు మరియు అయితే మీరు ఇప్పటికే కొన్ని కణాలు కేటాయించింది చేసిన

839
00:45:09,000 --> 00:45:12,000
మీరు నిజంగా ఎప్పుడైనా వెంటనే అవసరం ఉండదు చేస్తున్న పట్టిక వద్ద

840
00:45:12,000 --> 00:45:15,000
నేను, మీరు బదులుగా ఒక కొత్త పెడుతోంది వెనుక ఆ ఒకదాన్ని ఇవ్వండి వెళుతున్న

841
00:45:15,000 --> 00:45:17,000
మరియు ఈ ఒక నైస్ ప్రదర్శన ఆందోళన ఉంది.

842
00:45:17,000 --> 00:45:21,000
మీరు కణాలు మీరే కేటాయించే లేదు.

843
00:45:21,000 --> 00:45:23,000
ఒక ఘటం మీరు తిరిగి ఇవ్వాలని జరగబోతోంది.

844
00:45:23,000 --> 00:45:25,000
మీరు ఒక సెల్ వస్తువు తిరిగి వెళుతున్న.

845
00:45:25,000 --> 00:45:28,000
ఒకసారి మీరు అంశాన్ని చేయవచ్చు సెల్ వస్తువు ఉంది.

846
00:45:28,000 --> 00:45:32,000
మీరు text label అని ఈ ఆస్తిని సెల్ టెక్స్ట్ను సెట్ చేయవచ్చు.

847
00:45:32,000 --> 00:45:36,000
మీరు కుడి లేదా కొన్ని ఇతర యాదృచ్ఛిక stuff ఆ బాణం జోడించవచ్చు

848
00:45:36,000 --> 00:45:41,000
ఈ ఇతర ఆస్తి తో accessoryType అని, అందువలన మరియు మొదలైనవి.

849
00:45:41,000 --> 00:45:46,000
>> యొక్క వాస్తవానికి ఇప్పుడు ఒక పట్టిక వీక్షణ అమలు పరిశీలించి చూద్దాం.

850
00:45:46,000 --> 00:45:49,000
నేను ఈ ప్రాజెక్ట్ సృష్టించినప్పుడు

851
00:45:49,000 --> 00:45:53,000
బదులుగా ఒకే అభిప్రాయం అప్లికేషన్ చెప్పడం కంటే నిజానికి ఇక్కడ పైగా వచ్చింది

852
00:45:53,000 --> 00:45:57,000
మాస్టర్ వివరాలు అనువర్తనం, అందుచే ప్రధానంగా ఈ మెయిల్ అనువర్తనానికి సంబంధించిన

853
00:45:57,000 --> 00:46:01,000
ఎడమవైపు పట్టిక వీక్షణ మరియు అప్పుడు కుడివైపు కంటెంట్ ఐప్యాడ్ న.

854
00:46:01,000 --> 00:46:07,000
ఐప్యాడ్ లేదా ఐఫోన్ ఈ ఒక పట్టిక వీక్షణ అనుగుణంగా అన్నారు.

855
00:46:07,000 --> 00:46:10,000
నా స్టార్టర్ కోడ్ వచ్చింది పేర్కొంది.

856
00:46:10,000 --> 00:46:13,000
>> యొక్క మొట్టమొదటి స్టోరీబోర్డు పరిశీలించి చూద్దాం.

857
00:46:13,000 --> 00:46:15,000
ఈ అన్ని ప్రధానంగా రూపొందించినవారు, నాకు జరిగింది.

858
00:46:15,000 --> 00:46:18,000
ఈ పేజీకి సంబంధించిన లింకులు బార్, ఒక ఉదాహరణ సెల్ ఎలా అనే దాని నాకు చూపించింది

859
00:46:18,000 --> 00:46:22,000
మరియు నేను డబుల్, ఈ క్లిక్ శీర్షిక మార్చవచ్చు.

860
00:46:22,000 --> 00:46:25,000
ఏదైనా ఇతర UI ఆందోళనలు నేను అక్కడ నిర్వహించగలుగుతుంది.

861
00:46:25,000 --> 00:46:27,000
శీర్షికా ఫైలును రియల్లీ సింపుల్ కనిపిస్తోంది.

862
00:46:27,000 --> 00:46:30,000
అయితే ఈ UIViewController తనకు కంటే మేము ఇప్పుడు ఈ ఒక ఉంది చెబుతున్న దాన్ని

863
00:46:30,000 --> 00:46:35,000
TableViewController, కనుక మేము అన్ని పట్టిక పద్ధతులు కాల్ చేయదలిచిన తెలుసు.

864
00:46:35,000 --> 00:46:38,000
నేను వెళుతున్న ఒక ఆస్తి సృష్టించడానికి కావలసిన తదుపరి

865
00:46:38,000 --> 00:46:40,000
నా పట్టిక లోపల విషయాలు.

866
00:46:40,000 --> 00:46:43,000
ఈ పట్టిక ఏకపక్ష ప్రదర్శించడానికి అన్నారు

867
00:46:43,000 --> 00:46:46,000
పండు జాబితా, మరియు నేను కొన్ని శ్రేణి సృష్టించాలి

868
00:46:46,000 --> 00:46:49,000
దీనిలో నేను పండు ఇన్సర్ట్ చేయవచ్చు.

869
00:46:49,000 --> 00:46:52,000
నా అమలు ఫైలు మొదటి విషయం యొక్క ఇన్సైడ్ నేను చేయాలనుకుంటున్నారా

870
00:46:52,000 --> 00:46:55,000
నేను ఈ శ్రేణి ప్రారంభించడం నిర్ధారించుకోవాలి ఉంది.

871
00:46:55,000 --> 00:46:58,000
>> నేను, alloc init చెప్పారు నా పండు శ్రేణి రూపొందించినవారు,

872
00:46:58,000 --> 00:47:03,000
మరియు నేను, అది ఇతర 3 కంటే ఎక్కువ వివాదాస్పదమైన ఒకటి 4 విషయాలు జోడించి ఉన్నది.

873
00:47:03,000 --> 00:47:06,000
ఇప్పుడు నేను పరిమాణం 4 యొక్క వ్యూహం ఉంది.

874
00:47:06,000 --> 00:47:08,000
మేము CS50 దాన్ని పైకి వణుకు చేస్తున్నారు.

875
00:47:08,000 --> 00:47:11,000
నేను ఇప్పుడు పరిమాణం 4 యొక్క వ్యూహం ఉంది.

876
00:47:11,000 --> 00:47:13,000
ఇప్పుడు నేను, వాస్తవానికి ఈ ప్రశ్నలకు ఆరంభమవుతుంది, మరియు నేను

877
00:47:13,000 --> 00:47:16,000
నేను ఈ అనువర్తనం సృష్టించినప్పుడు ఈ అన్ని ఇప్పటికే నాకు జరిగింది.

878
00:47:16,000 --> 00:47:19,000
నేను పట్టిక వీక్షణ లో విభాగాల సంఖ్య అవుట్ టైప్ లేదు.

879
00:47:19,000 --> 00:47:22,000
ఇది ఇప్పటికే, మరియు నేను ఖాళీలను పూరించి చేస్తున్నాను.

880
00:47:22,000 --> 00:47:24,000
నేను ఎన్ని విభాగాలు ఉన్నాయి?

881
00:47:24,000 --> 00:47:26,000
ఒక. పూర్తి.

882
00:47:26,000 --> 00:47:28,000
నేను ఎన్ని వరుసలు ఉన్నాయి?

883
00:47:28,000 --> 00:47:31,000
Well, నేను ప్రతి పండు ఒక వరుస కలిగి ఉంటాయి, కాబట్టి ఈ సంఖ్య

884
00:47:31,000 --> 00:47:34,000
అది ఎలా పెద్దది అని ఏ శ్రేణి యొక్క లక్షణాన్ని?

885
00:47:34,000 --> 00:47:36,000
నేను ఎన్ని వరుసలు ఉంది.

886
00:47:36,000 --> 00:47:42,000
చివరగా, నేను ఏమి ప్రతి సెల్ ఎలా చెబుతున్నారు అవసరం?

887
00:47:42,000 --> 00:47:46,000
నేను dequeueReusableCellWithIdentifier చెప్పడానికి వెళుతున్నాను.

888
00:47:46,000 --> 00:47:48,000
>> మళ్ళీ, ఈ అప్పటికే నాకు రాశారు.

889
00:47:48,000 --> 00:47:51,000
నేను ఈ నాకు ఏమి లేదు, మరియు నేను తిరిగి పొందడానికి కావలసిన

890
00:47:51,000 --> 00:47:54,000
ఈ స్థానంలో ఈ సెల్.

891
00:47:54,000 --> 00:47:57,000
మేము ప్రతి కణం ఈ అదే పద్ధతిగా పేర్కొన్నాడు చేస్తున్న గుర్తుంచుకో,

892
00:47:57,000 --> 00:48:01,000
మరియు ఇక్కడ ఈ వాదన, ఈ indexPath వాదన,

893
00:48:01,000 --> 00:48:03,000
నేను సైన్ నేను ఏమి వరుస చెప్పారు

894
00:48:03,000 --> 00:48:05,000
నేను ఇక్కడ indexPath.row డౌన్ చెప్పినట్టైతే

895
00:48:05,000 --> 00:48:09,000
ఈ 0 ఉంటుంది, అది 1 ఉంటుంది, అది 2 ఉంటుంది, మరియు నాకు తెలుసు కాబట్టి ఈ ఉంది

896
00:48:09,000 --> 00:48:11,000
నేను ప్రస్తుతం ప్రదర్శించడం నేను ఏమి సెల్.

897
00:48:11,000 --> 00:48:15,000
నేను ఈ textLabel ఆస్తి ఉపయోగించి సెల్ టెక్స్ట్ను సెట్ చేయాలనుకుంటున్నారా

898
00:48:15,000 --> 00:48:19,000
నా పండు శ్రేణిలో వెళ్ళి పొందడానికి

899
00:48:19,000 --> 00:48:21,000
ప్రతి వరుస సంబంధిత వస్తువు.

900
00:48:21,000 --> 00:48:24,000
ఈ స్ట్రింగ్ ఉంటే, నేను ఇప్పుడు సెట్ చేస్తున్నాను

901
00:48:24,000 --> 00:48:28,000
ఒక స్ట్రింగ్ టెక్స్ట్ ఆస్తి.

902
00:48:28,000 --> 00:48:30,000
నేను ఒక విషయం ఇతర చేయవచ్చు.

903
00:48:30,000 --> 00:48:32,000
నేను కూడా, కణాలు ప్రతి కార్యక్రమం హ్యాండ్లర్ నమోదు చేసుకోవచ్చు

904
00:48:32,000 --> 00:48:35,000
నేను ఈ కణాలు ప్రతి నొక్కండి, అప్పుడు

905
00:48:35,000 --> 00:48:39,000
ఈ didSelectRowAtIndexPath, ఈ, నాకు అని అన్నారు

906
00:48:39,000 --> 00:48:42,000
కాబట్టి కేవలం ఈ నిర్వచించడం ద్వారా నేను ఇప్పుడు ఏమి నిర్వహించగలుగుతుంది

907
00:48:42,000 --> 00:48:46,000
మీరు మళ్ళీ ఒక సెల్ నొక్కండి, మరియు, సెల్ టాప్ ఇది అక్కడ చేస్తున్నారు

908
00:48:46,000 --> 00:48:50,000
కాబట్టి మేము మా కణాలు అన్ని ఈ ఒకే ఈవెంట్ను హ్యాండ్లర్ తిరిగి చేయవచ్చు.

909
00:48:50,000 --> 00:48:53,000
>> మళ్ళీ, ఈ iOS నాకు చేస్తున్న విషయం.

910
00:48:53,000 --> 00:48:55,000
మరొక బాధించే పాపప్ ను ప్రదర్శించడానికి లెట్ యొక్క

911
00:48:55,000 --> 00:48:59,000
ఆ కేవలం మీరు పేరు ఏదో ఏదో ఎంపిక చెప్పారు

912
00:48:59,000 --> 00:49:04,000
వరుస వస్తువు అని అన్నారు.

913
00:49:04,000 --> 00:49:10,000
నేను ఈ అమలు చేసినప్పుడు, నేను ఈ nice పట్టిక వీక్షణ కలిగి వెళుతున్న

914
00:49:10,000 --> 00:49:14,000
ఈ పండు ప్రతి ఒక వరుస, మరియు నేను ఒక నొక్కండి

915
00:49:14,000 --> 00:49:16,000
అది ఏమి నాకు చెబుతుంది.

916
00:49:16,000 --> 00:49:21,000
సమంజసం?

917
00:49:21,000 --> 00:49:24,000
యొక్క ఒక అనువర్తనం యొక్క కొద్దిగా క్లిష్టమైన నిర్మించడానికి లెట్

918
00:49:24,000 --> 00:49:28,000
మీరు టమోటా ఎంపిక క్లిక్ మాదిరిగా ఉంది.

919
00:49:28,000 --> 00:49:31,000
స్టోరీబోర్డింగ్ గురించి nice భాగంగా

920
00:49:31,000 --> 00:49:35,000
అది మాత్రమే, వ్యక్తిగతంగా మాకు డిజైన్ తెరలు సహాయం మాత్రం కాదు ఉంది

921
00:49:35,000 --> 00:49:38,000
అది కూడా, మా మొత్తం అనువర్తనం కలిసి టై సహాయం జరగబోతోంది

922
00:49:38,000 --> 00:49:42,000
కాబట్టి మేము భవనం ఉంటుంది చివరి అనువర్తనం, ఇది నీస్ క్రీడా వార్తలు రీడర్ ఉంది

923
00:49:42,000 --> 00:49:45,000
మరియు కనుక ఇది బహుళ తెరలను కలిగి అవకాశముంది, మరియు నేను నిజంగా సూచిస్తుంది

924
00:49:45,000 --> 00:49:48,000
స్టోరీబోర్డ్ ఈ బహుళ తెరలను ప్రతి,

925
00:49:48,000 --> 00:49:52,000
మరియు నేను దూరంగా మరియు ఒక ఉన్నత స్థాయి నుండి నా అనువర్తనం చూడగలరు.

926
00:49:52,000 --> 00:49:55,000
>> నా స్టోరీబోర్డ్ ఒక కొత్త మూలకం లోపల సృష్టించడానికి

927
00:49:55,000 --> 00:49:59,000
ఇది ఇంటర్ఫేస్ బిల్డర్ లోపలి నిజంగా సులభం.

928
00:49:59,000 --> 00:50:01,000
నేను ఈ మరొక స్క్రీన్ జోడించాలనుకుంటే, ఉదాహరణకు,

929
00:50:01,000 --> 00:50:06,000
నేను మొదటి, Apple చాలా ప్రేమిస్తున్నట్లు చిటికెడు జూమ్ తో జూమ్ చేయవచ్చు

930
00:50:06,000 --> 00:50:09,000
మరియు డౌన్ ఇక్కడ నేను ఒక బటన్ కోసం అన్వేషణ ముందు

931
00:50:09,000 --> 00:50:12,000
మరియు నేను ఒక బటన్ డ్రాగ్ మరియు డ్రాప్

932
00:50:12,000 --> 00:50:15,000
నేను ఒక కొత్త స్క్రీన్ సృష్టించాలని మీరు అనుకుంటే నేను నిజానికి డ్రాగ్ మరియు డ్రాప్ చెయ్యవచ్చు

933
00:50:15,000 --> 00:50:19,000
మొత్తం వీక్షణ నియంత్రిక, నేను ఈ పిక్ అయితే, ఇక్కడ దాని పై పుల్

934
00:50:19,000 --> 00:50:23,000
హేయ్, అక్కడ మరొక స్క్రీన్ యొక్క, మరియు అందువలన ఇప్పుడు అదే స్టోరీబోర్డ్ ఫైల్ని ఉపయోగించి

935
00:50:23,000 --> 00:50:26,000
నా అనువర్తనం యొక్క లోపల తెరలు అన్ని ఉండవచ్చు, నేను జూమ్ చేయవచ్చు

936
00:50:26,000 --> 00:50:28,000
మరియు వారు ఎలా పరస్పర చర్యను.

937
00:50:28,000 --> 00:50:32,000
ఈ ఇంకా మాట్లాడకుండా చేస్తుంది.

938
00:50:32,000 --> 00:50:36,000
ఈ 2 తెరలు సంకర్షణ మార్గాన్ని మీరు సంబంధాలు నిర్వచించే ఉంది.

939
00:50:36,000 --> 00:50:39,000
మీరు ప్రాథమికంగా, మీరు ఈ బటన్ నొక్కండి, ఈ తెర చెప్పగలదు

940
00:50:39,000 --> 00:50:42,000
నేను మీరు ఈ కొత్త స్క్రీన్ కు స్లయిడ్ మీరు.

941
00:50:42,000 --> 00:50:44,000
అనగా మధ్య సంబంధం ఈ రకమైన లేదు

942
00:50:44,000 --> 00:50:46,000
 మొదటి తెర మరియు రెండవ తెర.

943
00:50:46,000 --> 00:50:49,000
మీరు ప్రధానంగా బటన్ నుండి రెండవ స్క్రీన్ ఒక బాణం ఉంటుంది

944
00:50:49,000 --> 00:50:53,000
నేను ఎక్కడ మీరు ఈ బటన్ నొక్కినప్పుడు ఆ చెప్పాడు.

945
00:50:53,000 --> 00:50:57,000
మేము క్లిక్ మరియు ఆ అవుట్లెట్లు నిర్వచించడానికి లాగారు కంట్రోల్ వలె

946
00:50:57,000 --> 00:51:01,000
మేము ఈ జారుకుంటారు నిర్వచించడానికి ఇదే చేయబోతున్నామని.

947
00:51:01,000 --> 00:51:05,000
>> మేము ఆ కోసం ఒక ఉదాహరణ చూడండి, మరియు మేము నిజంగా మార్పు ముందు మీరు

948
00:51:05,000 --> 00:51:08,000
ఒక స్క్రీన్ నుండి మరొక iOS ఈ పద్ధతి కాల్ తగినంత nice ఉంది

949
00:51:08,000 --> 00:51:11,000
prepareForSegue అని, మరియు మేము ప్రారంభించడానికి మీకు ఈ ఉంది

950
00:51:11,000 --> 00:51:14,000
ఒక అనువర్తనం నుండి మరొక డేటాను పంపడం.

951
00:51:14,000 --> 00:51:17,000
ఉదాహరణకు మనం అది కు చేయబోతున్నారు ప్రధానంగా మాకు అనుమతిస్తుంది

952
00:51:17,000 --> 00:51:20,000
లీగ్లు మరియు విభాగాలలో బేస్బాల్ జట్లు ఫిల్టర్.

953
00:51:20,000 --> 00:51:23,000
నేను ఒక లీగ్ ఎంపిక, ఉదాహరణకు, నేను మార్పు మీరు

954
00:51:23,000 --> 00:51:25,000
నేను విభాగాలు అన్ని ప్రదర్శిస్తుంది పేరు నా తదుపరి స్క్రీన్ కు

955
00:51:25,000 --> 00:51:27,000
ఆ లీగ్ లేదా అన్ని వివిధ జట్లలో.

956
00:51:27,000 --> 00:51:31,000
ఏమి జట్లు మీరు ప్రదర్శించాలి తెరపై పంపాలి.

957
00:51:31,000 --> 00:51:35,000
నేను ఇక్కడ ఈ పద్ధతి యొక్క ప్రయోజనాన్ని వెళుతున్న ఆ చేయుటకు.

958
00:51:35,000 --> 00:51:39,000
>> చివరగా, iOS కేవలం ఒక యాదృచ్చిక పాయింట్.

959
00:51:39,000 --> 00:51:41,000
మీరు డేటాను నిల్వ చేయాలనుకుంటే కోర్ డేటా అనే ఈ విషయం, లేదు

960
00:51:41,000 --> 00:51:44,000
ఇది వాస్తవానికి పని క్లిష్టమైన యొక్క రకం.

961
00:51:44,000 --> 00:51:47,000
మీరు, సమాచారాన్ని నిల్వచేయటానికి SQL ఉపయోగించవచ్చు

962
00:51:47,000 --> 00:51:51,000
ఇది మళ్ళీ, పని ఎక్కువ క్లిష్టమైన వైపు nice కానీ రకమైన ఉంది

963
00:51:51,000 --> 00:51:55,000
కానీ iOS కూడా, ఆస్తి జాబితాలు అని ఈ నిజంగా మంచి విషయాలు మద్దతు

964
00:51:55,000 --> 00:52:00,000
మరియు ఒక ఆస్తి జాబితా కేవలం కీ విలువ జతలను ప్రాతినిధ్యం ఫైలు.

965
00:52:00,000 --> 00:52:03,000
మీరు కీలు జాబితా పేర్కొనండి మరియు మీరు ఈ కీ వ్యూహం మాత్రం చెప్పారు.

966
00:52:03,000 --> 00:52:06,000
ఈ కీ ప్రధానంగా మీరు చేయవచ్చు ఏదైనా ఒక స్ట్రింగ్ మాత్రం, మరియు

967
00:52:06,000 --> 00:52:10,000
JSON లో మీరు, ఒక ఆస్తి జాబితా లోపల చేయవచ్చు

968
00:52:10,000 --> 00:52:14,000
మరియు ఈ నిజంగా చక్కగా మాకు కొన్ని డేటా పని అనుమతిస్తుంది.

969
00:52:14,000 --> 00:52:18,000
ఉదాహరణకు, నేను సృష్టించిన ఈ Teams.plist ఉన్నాయి.

970
00:52:18,000 --> 00:52:22,000
నేను ఒక కొత్త plist ఫైలు రూపొందించినవారు, మరియు నేను క్రింద రంధ్రములు చేసే పరికరము చేయవచ్చు.

971
00:52:22,000 --> 00:52:26,000
ఈ నిఘంటువు, ఈ నిఘంటువు ఉంటుంది, ఈ, తీగలు ఉంటాయి

972
00:52:26,000 --> 00:52:30,000
మరియు ఈ ఒక JSON పత్రం యొక్క ఒక నైస్ గ్రాఫికల్ ప్రాతినిథ్యం

973
00:52:30,000 --> 00:52:33,000
లేదా కీ విలువ జతలను ఒక సెట్,

974
00:52:33,000 --> 00:52:37,000
మరియు ఈ నా అనువర్తనం యొక్క లోపలి కృషి చేస్తాము సమాచారం.

975
00:52:37,000 --> 00:52:40,000
>> మొదటి ఇక్కడ పైగా వచ్చి లెట్. మేము ఇప్పుడు చాలా ఫైళ్ళను ఉన్నాయి.

976
00:52:40,000 --> 00:52:44,000
కానీ యొక్క మొట్టమొదటి స్టోరీబోర్డు ఇక్కడ పైగా వచ్చి తెలియజేయండి.

977
00:52:44,000 --> 00:52:48,000
స్టోరీబోర్డ్ ఇక్కడ నేను జూమ్ చేయవచ్చు అవుట్

978
00:52:48,000 --> 00:52:51,000
మేము ఇప్పుడు ఈ నా అనువర్తనం యొక్క ప్రవాహం అని చూడగలరు.

979
00:52:51,000 --> 00:52:53,000
నేను మొదటి ఈ తెరపై ప్రారంభం వెళుతున్న.

980
00:52:53,000 --> 00:52:55,000
నేను, ఈ స్క్రీన్ క్రిందికి రంధ్రములు చేసే పరికరము వెళుతున్న

981
00:52:55,000 --> 00:52:58,000
మరియు నేను ఈ స్క్రీన్ క్రిందికి రంధ్రములు చేసే పరికరము వెళుతున్న మరియు మేము ఇక్కడ చూడగలరు నేను రకమైన ఉంటే

982
00:52:58,000 --> 00:53:04,000
మేము ఈ బాణాలు ఇక్కడ నుండి ఇక్కడ వెళ్లి చేసిన వీటిలో సుమారు ఒక తరలించాలని,

983
00:53:04,000 --> 00:53:08,000
నేను కొద్దిగా దగ్గరికి జూమ్ ఉంటే మరియు ఆ బాణం నిర్వచించే మార్గం ఉంది

984
00:53:08,000 --> 00:53:12,000
మరియు నేను ఈ అభిప్రాయాలను నియంత్రిక కు వచ్చి ఉంటే,

985
00:53:12,000 --> 00:53:16,000
మరియు ఇక్కడ సెల్, మరియు మీరు ఒక సెల్ నొక్కండి నేను ఆ చెప్పాలనుకోవడం

986
00:53:16,000 --> 00:53:18,000
నేను మీరు ఇంకొక కు పైగా స్లయిడ్ మీరు.

987
00:53:18,000 --> 00:53:21,000
నేను కేవలం, నియంత్రణ డౌన్ జరపవచ్చని

988
00:53:21,000 --> 00:53:26,000
కొద్దిగా మీద స్క్రోల్, నియంత్రణ తగ్గేందుకు ఈ సెల్ పైగా లాగి వీడలేదు.

989
00:53:26,000 --> 00:53:30,000
>> మరియు ఇక్కడ పైగా మేము మీరు కావలసిన మార్పు ఏమి చెబుతారు?

990
00:53:30,000 --> 00:53:32,000
మీరు పుష్ అని ఆ స్లయిడ్ విషయం ఉపయోగించడానికి మీరు అనుకుంటున్నారా?

991
00:53:32,000 --> 00:53:34,000
మీరు దిగువ నుండి పైకి మీరు అనుకుంటున్నారా?

992
00:53:34,000 --> 00:53:36,000
ఆ మోడల్ అని.

993
00:53:36,000 --> 00:53:40,000
మరియు ఒకసారి నేను ఈ ఒకదాన్ని క్లిక్ చేయండి, ఇది నాకు ఈ బాణం డ్రా జరగబోతోంది

994
00:53:40,000 --> 00:53:44,000
మరియు ఆ నిజానికి నేను ప్రత్యక్షముగా ఈ బటన్ నొక్కండి ఏమి జరుగుతుంది నిర్వహించింది చేసిన అర్థం.

995
00:53:44,000 --> 00:53:48,000
నిజానికి ఒక స్క్రీన్ నుండి తదుపరి కు స్లయిడ్ ఏ కోడ్ వ్రాయడానికి లేదు.

996
00:53:48,000 --> 00:53:51,000
నేను ఇంటర్ఫేస్ బిల్డర్ ఈ దృశ్యపరంగా లోపల నిర్వచించవచ్చు.

997
00:53:51,000 --> 00:53:55,000
నేను ఈ బాణం క్లిక్ ఉంటే, మేము ఈ విషయం ఒక పేరు ఇచ్చిన చూడగలరు.

998
00:53:55,000 --> 00:53:59,000
నేను showDivisions అని, మరియు ఈ నాకు తెలుసు కనుక ఉంది

999
00:53:59,000 --> 00:54:03,000
ఏ మార్పు గురించి సంభవించే, మరియు ఎందుకు కేవలం క్షణ లో మేము చూస్తారు.

1000
00:54:03,000 --> 00:54:06,000
నేను నా అనువర్తనం వివిధ తెరలు అప్ వైర్డు చేసిన ఎలా.

1001
00:54:06,000 --> 00:54:09,000
ఈ బటన్, ఉదాహరణకు, కాకుండా పట్టిక వీక్షణ ఉంటే,

1002
00:54:09,000 --> 00:54:11,000
నేను, తదుపరి స్క్రీన్ కి డ్రాగ్ బటన్ క్లిక్ నియంత్రించేవారు

1003
00:54:11,000 --> 00:54:16,000
మరియు నేను పేజీకి సంబంధించిన లింకులు విధంగా చేయవచ్చు ఎలా.

1004
00:54:16,000 --> 00:54:19,000
>> రియల్లీ త్వరగా, మేము MasterViewController వస్తాయి ఉంటే,

1005
00:54:19,000 --> 00:54:22,000
మళ్ళీ, మేము కేవలం విషయాలను జాబితా నిర్వచించడానికి వెళుతున్న

1006
00:54:22,000 --> 00:54:26,000
ఆ పట్టిక వీక్షణ ప్రదర్శించబడుతుంది.

1007
00:54:26,000 --> 00:54:29,000
ఇక్కడ నేను మీరు ఆ plist ఫైలు తీసుకొవాలనుకోవటము మాట్లాడుతూ నేను

1008
00:54:29,000 --> 00:54:32,000
మరియు నేను మీరు, ఒక నిఘంటువు దానిని అప్ లోడు చేయాలనుకుంటే

1009
00:54:32,000 --> 00:54:35,000
మరియు ఒకసారి మీరు ఆ నిఘంటువు కలిగి, నేను మళ్ళీ ఆ అదే ప్రశ్నలకు సమాధానం వెళుతున్న.

1010
00:54:35,000 --> 00:54:37,000
ఇక్కడ విభాగాల సంఖ్య.

1011
00:54:37,000 --> 00:54:41,000
ఒకటి, ప్రతి లీగ్ కోసం వరుస, మరియు ప్రతి ఒక్క సెల్ టెక్స్ట్ ఉంది

1012
00:54:41,000 --> 00:54:46,000
కాబట్టి మొదటి ఒకటి, మొదటి లీగ్, రెండవ లీగ్, మరియు గాని ఉండాలి.

1013
00:54:46,000 --> 00:54:51,000
చివరగా, నేను, మేము prepareForSegue అని భావించారు ఈ పద్ధతిని ఉపయోగిస్తారు వెళుతున్న

1014
00:54:51,000 --> 00:54:54,000
మరియు ఈ నేను క్లిక్ చేసినప్పుడు కాల్పులు చేస్తాడు ఆ పద్ధతి

1015
00:54:54,000 --> 00:54:57,000
ఆ వరుసలు ఒకటి మరియు అందువల్ల ఆ మార్పు ఆక్టివేట్

1016
00:54:57,000 --> 00:54:59,000
నేను బాణాలు తో ఏర్పాటు చేసే.

1017
00:54:59,000 --> 00:55:02,000
ఈ నేను బహుళ కలిగి అని

1018
00:55:02,000 --> 00:55:05,000
ఒక స్క్రీన్ నుండి మరొక సంబంధాలు.

1019
00:55:05,000 --> 00:55:08,000
నేను 2 బటన్లను కలిగి మరియు ప్రతి బటన్ వేరే తెరకి తీసుకుని వెళ్తుంది ఉంటే

1020
00:55:08,000 --> 00:55:10,000
నేను ప్రతి బటన్ 2 జారుకుంటారు, 1 కలిగి వెళుతున్న.

1021
00:55:10,000 --> 00:55:14,000
కానీ ఈ prepareForSegue తిరిగి వాడరాదు కు వెళ్ళి మళ్ళీ ఉంది

1022
00:55:14,000 --> 00:55:17,000
వివిధ సంబంధాలు ప్రతి, తద్వారా నేను ఒక మార్గం ఉండాలి

1023
00:55:17,000 --> 00:55:21,000
మీరు మొదటి బటన్ నొక్కండి లేదా మీరు రెండవ బటన్ నొక్కండి ఉంటే గుర్తించడం.

1024
00:55:21,000 --> 00:55:25,000
>> నేను ఆ segue ఒక పేరు, ఈ showDivisions, ఇచ్చినపుడు గుర్తుంచుకో

1025
00:55:25,000 --> 00:55:29,000
ఆ ఇప్పుడు ఈ యాక్టివేట్ చేస్తారు segue అని తెలుసు ఎలా.

1026
00:55:29,000 --> 00:55:32,000
నేను అన్ని నేను చెప్పాలనుకోవడం లేదు

1027
00:55:32,000 --> 00:55:35,000
నేను, నేను ఏది గుర్తించడానికి కావలసిన

1028
00:55:35,000 --> 00:55:38,000
అందువలన, పొందడానికి, నేను ఎంచుకున్న వరుస కోసం indexPath అనుకుందాం చేయవచ్చు

1029
00:55:38,000 --> 00:55:42,000
నేను క్లిక్ పేరు indexPath గుర్తు కేవలం అన్నారు

1030
00:55:42,000 --> 00:55:47,000
తరువాత నేను వెళుతున్నాను పేరు గుర్తించడానికి కావలసిన చెప్పాలనుకోవడం.

1031
00:55:47,000 --> 00:55:50,000
ఈ destinationViewController, ఆ segue ఒక ఆస్తి ఉంది.

1032
00:55:50,000 --> 00:55:53,000
అంటే, నేను వెళుతున్న స్క్రీన్ యొక్క

1033
00:55:53,000 --> 00:55:56,000
నేను నేను వెళుతున్న స్క్రీన్ DivisionsViewController అని తెలుసు

1034
00:55:56,000 --> 00:55:59,000
నేను ఆ వర్గాన్ని సృష్టించింది, ఎందుకంటే

1035
00:55:59,000 --> 00:56:02,000
అందువలన ఇప్పుడు నేను d.divisions చెప్పుకోవాలంటే

1036
00:56:02,000 --> 00:56:06,000
నేను ఇప్పుడు నేను వెళ్ళడానికి గురించి ఉన్నాను వీక్షణ నియంత్రిక ఒక ఆస్తి సెట్ చేస్తున్నాను.

1037
00:56:06,000 --> 00:56:10,000
ఈ నేను మరొక స్క్రీన్ ఒక స్క్రీన్ నుండి డేటాను పంపడం నేను ఎలా ఉంది.

1038
00:56:10,000 --> 00:56:13,000
>> ఈ DivisionsViewController చూడటం

1039
00:56:13,000 --> 00:56:16,000
మీరు ఇక్కడ చూడగలరు. h ఫైలులో

1040
00:56:16,000 --> 00:56:20,000
అక్కడ ఆ ఆస్తి విభాగాలు, మరియు ఆ నిజానికి populating నేను ఏమి

1041
00:56:20,000 --> 00:56:25,000
కాబట్టి నేను అనుగుణంగా విభాగాలు ప్రదర్శించడం నేను మీకు ఎలా

1042
00:56:25,000 --> 00:56:28,000
నేను క్లిక్, మరియు తిరిగి, ఆ లీగ్

1043
00:56:28,000 --> 00:56:31,000
అసలు పట్టిక వీక్షణ కేవలం ఆ సమాధానం, చాలా చక్కని కనిపిస్తుంది

1044
00:56:31,000 --> 00:56:34,000
3 సాధారణ ప్రశ్నలు అలాగే గుర్తించడం

1045
00:56:34,000 --> 00:56:37,000
మీరు తదుపరి స్క్రీన్ తరలించడానికి ఏమి జరుగుతుంది.

1046
00:56:37,000 --> 00:56:40,000
ఇక్కడ ఇతర వస్తువులను కేవలం రెండు.

1047
00:56:40,000 --> 00:56:43,000
మీరు ఇక్కడ ఎగువన గమనించి ఆ కాకుండా # ఉన్నాయి చెప్పడం

1048
00:56:43,000 --> 00:56:45,000
నేను ఇప్పుడు # దిగుమతి మాట్లాడుతూ నేను.

1049
00:56:45,000 --> 00:56:47,000
ఇది ఒక ఆబ్జెక్టివ్-C విషయం.

1050
00:56:47,000 --> 00:56:52,000
దిగుమతి, ప్రధానంగా అనేవి ఒక NICER వెర్షన్

1051
00:56:52,000 --> 00:56:57,000
మరియు ఉదాహరణకు, ఈ తరగతి ఉంది ఏమి అవసరం

1052
00:56:57,000 --> 00:57:00,000
కాబట్టి నేను DivisionsViewController చెప్పలేను.

1053
00:57:00,000 --> 00:57:05,000
మేము మా. సి ఫైల్ standardio.c లోపల హాష్ ట్యాగ్ లేదు ఉంటే

1054
00:57:05,000 --> 00:57:07,000
కంపైలర్ printf గురించి తెలియదు.

1055
00:57:07,000 --> 00:57:12,000
అదేవిధంగా, నేను DivisionsViewController దిగుమతి లేకపోతే

1056
00:57:12,000 --> 00:57:16,000
కంపైలర్ నిజంగా DivisionsViewController ఉంది ఏమిటో తెలియదు.

1057
00:57:16,000 --> 00:57:19,000
మీ వేర్వేరు. M ఫైళ్ళ లోపల మీరు దిగుమతి నిర్ధారించుకోండి నిర్ధారించుకోండి

1058
00:57:19,000 --> 00:57:25,000
సంబంధిత. h ఫైళ్లను కాబట్టి కంపైలర్ ఏమి తెలుసని.

1059
00:57:25,000 --> 00:57:31,000
>> చివరిగా, ఏ Apple చివరికి, వెబ్ వీక్షణ ఉపయోగించి కొన్ని డేటా డిస్ప్లే లేదు

1060
00:57:31,000 --> 00:57:35,000
అందువలన ఒక వెబ్ వీక్షణ మీరు పొందుపరచవచ్చు దీనిలో ఒక వస్తువు

1061
00:57:35,000 --> 00:57:37,000
మీ అనువర్తనం యొక్క లోపల ఒక చిన్న వెబ్ బ్రౌజర్.

1062
00:57:37,000 --> 00:57:40,000
మీరు చెయ్యవలసింది అన్ని, మీ వెబ్ బ్రౌజర్ కు URL సరఫరా

1063
00:57:40,000 --> 00:57:43,000
నేను, mlb.mlb.com కు వెళ్లాలని మీరు అనుకుంటున్నారా

1064
00:57:43,000 --> 00:57:46,000
మరియు ఈ, నేను ప్రతి జట్టుకు హోమ్ పేజీ ఆక్సెస్ ఎలా ఉంది

1065
00:57:46,000 --> 00:57:49,000
మరియు ఈ URL లో చేయడము ద్వారా

1066
00:57:49,000 --> 00:57:52,000
, వెబ్ వీక్షణ నాకు ఈ ప్రదర్శిస్తుంది, మరియు నేను చుట్టూ బ్రౌజ్ చెయ్యవచ్చు

1067
00:57:52,000 --> 00:58:01,000
మరియు సిమ్యులేటర్ ఒక ఉపయోగంలో ఉంటుంది.

1068
00:58:01,000 --> 00:58:03,000
ఇప్పుడు ఈ నా plist నుండి వచ్చింది.

1069
00:58:03,000 --> 00:58:07,000
నేను ఈ క్లిక్ ఉంటే ఈ కూడా నా plist నుండి వచ్చింది, మరియు ఈ స్లైడింగ్ నిర్వహిస్తుంది

1070
00:58:07,000 --> 00:58:09,000
ఆ జారుకుంటారు నిర్వచించడం ద్వారా.

1071
00:58:09,000 --> 00:58:12,000
నేను, ఈ క్లిక్ చేసి ఒకటి

1072
00:58:12,000 --> 00:58:15,000
మరియు ఇప్పుడు ఇక్కడ అలా ఆ వలె నా UIWebView ఉంది

1073
00:58:15,000 --> 00:58:19,000
ఇక్కడ నేను పొందుపర్చిన ఆ URL కోసం వెబ్సైట్ యొక్క

1074
00:58:19,000 --> 00:58:21,000
మరియు నేను క్రేజీ ఏదైనా నిర్వహించడానికి లేదు.

1075
00:58:21,000 --> 00:58:24,000
ఈ వెబ్ పేజీని ప్రదర్శించడానికి ఎలా.

1076
00:58:24,000 --> 00:58:27,000
ఇక్కడ ఈ బ్యాక్ బటన్ వంటి వాటిని కూడా నాకు ఇవ్వబడ్డాయి

1077
00:58:27,000 --> 00:58:33,000
పూర్తిగా ఉచితంగా నేను జారుకుంటారు ఉపయోగించి ఈ సంబంధాలు నిర్వచించిన చేసిన ఎందుకంటే.

1078
00:58:33,000 --> 00:58:37,000
>> ఏదైనా ప్రశ్నలు? అవును.

1079
00:58:37,000 --> 00:58:40,000
[స్టూడెంట్] కాబట్టి మీరు alloc ఉపయోగిస్తున్నప్పుడు, మీరు ఉచిత ఏదైనా అవసరం లేదు?

1080
00:58:40,000 --> 00:58:43,000
సరిగ్గా, మీరు alloc మరియు init కాల్ మీరు ఇది ఉచితం లేదు.

1081
00:58:43,000 --> 00:58:46,000
IOS మీరు ఆ అన్ని నిర్వహించడానికి అన్నారు.

1082
00:58:46,000 --> 00:58:51,000
ఇది అద్భుతమైన, మరియు మీరు ఏ నియమాలు బద్దలు లేదు. అవును.

1083
00:58:51,000 --> 00:58:54,000
మీరు, తెరపై సరిపోతుంది మరింత జట్లు ఉన్నాయి చేసారు [స్టూడెంట్] ఉంటే

1084
00:58:54,000 --> 00:58:58,000
అది స్వయంచాలకంగా జోడించడానికి ఏదో ఒక స్క్రోలు ఎంపిక, లేదా ఉంది?

1085
00:58:58,000 --> 00:59:01,000
నేను మరింత జట్లు కలిగి ఉంటే ఖచ్చితంగా, ఉదాహరణకు, అది స్వయంచాలకంగా నిర్వహించడానికి ఉంటుంది

1086
00:59:01,000 --> 00:59:04,000
నాకు స్క్రోలింగ్, మరియు అన్ని పనితీరు ఆందోళనలు

1087
00:59:04,000 --> 00:59:08,000
భారీ పట్టిక కూడా నాకు పూర్తిగా నిర్వహిస్తారు.

1088
00:59:08,000 --> 00:59:11,000
>> ఇతర ప్రశ్నలు?

1089
00:59:11,000 --> 00:59:13,000
ఈ కోడ్ యొక్క అన్ని పోస్ట్ అన్నారు.

1090
00:59:13,000 --> 00:59:16,000
మేము రకమైన, మరింత చిన్న వివరాలు కొద్దిగా ఓవర్ గ్లాస్ద్

1091
00:59:16,000 --> 00:59:19,000
కానీ వంటి వాటిని వెబ్ వీక్షణ కొన్ని లక్షణాలను అమర్చే

1092
00:59:19,000 --> 00:59:22,000
కేవలం మీరు ఆపిల్ యొక్క డాక్యుమెంటేషన్ బ్రౌజింగ్ ద్వారా పొందవచ్చు ఆ విషయాలు,

1093
00:59:22,000 --> 00:59:24,000
నిజంగా ఇది నిజంగా చక్కగా వేశాడు.

1094
00:59:24,000 --> 00:59:27,000
వారు ఒక నమూనా Apps యొక్క చాలా మరియు ఉదాహరణ ఉపయోగాలను కలిగి

1095
00:59:27,000 --> 00:59:34,000
వివిధ API లు, కాబట్టి ఖచ్చితంగా మీకు ఆ పరిశీలనగా.

1096
00:59:34,000 --> 00:59:36,000
కొన్ని ఉపయోగపడిందా లింకులు మీరు పరిశీలించి అనుకోవచ్చు.

1097
00:59:36,000 --> 00:59:38,000
ఈ కొన్ని సులభ డాక్యుమెంటేషన్ గైడ్లు ఉంటాయి.

1098
00:59:38,000 --> 00:59:41,000
URL లు భారీ కారు కాబట్టి, వారు క్లుప్తంగా చేస్తున్నారు.

1099
00:59:41,000 --> 00:59:44,000
ఈ మొదటి ఒక డాక్యుమెంటేషన్ యొక్క మొత్తం గ్రంథాలయం.

1100
00:59:44,000 --> 00:59:46,000
చిన్న శోధన బార్లు మీరు టైప్ బటన్ ప్రారంభం అయితే, ఉన్నాయి

1101
00:59:46,000 --> 00:59:50,000
ఇది మీరు ఒక బటన్ చేయవచ్చు అన్ని విషయాల గురించి మొత్తం సమాచారాన్ని ఇవ్వడం ప్రారంభమౌతుంది.

1102
00:59:50,000 --> 00:59:53,000
నేను కూడా పట్టిక వీక్షణ ప్రోగ్రామింగ్ గైడ్ చేర్చాను.

1103
00:59:53,000 --> 00:59:56,000
ఇది చాలా వివరాలు పట్టిక అభిప్రాయాలు నిర్వహిస్తుంది

1104
00:59:56,000 --> 01:00:00,000
డైనమిక్ కణాలు లేదా మార్చు కణాలు జోడించడానికి లేదా తీసివేయుటకు వాటి వంటి విషయాలను ఎలా.

1105
01:00:00,000 --> 01:00:02,000
>> ఎలా చేయాలని మీరు చూపిస్తుంది ఆపిల్ నుండి నమూనా Apps మా ఉన్నది

1106
01:00:02,000 --> 01:00:05,000
చివరకు, ఈ చివరి, మానవ అంతర్ముఖ మార్గదర్శకాల

1107
01:00:05,000 --> 01:00:09,000
మరియు ఈ, ప్రధానంగా UI భాగాలు కొన్ని చర్చ

1108
01:00:09,000 --> 01:00:12,000
వంటి విషయాలను 4 పిక్సెల్స్ 4 పిక్సెళ్ళు అని ఒక బటన్ చేయటం లేదు.

1109
01:00:12,000 --> 01:00:15,000
ఒక బాడ్ ఐడియా, మరియు ఆపిల్ మీరు వాంట్స్ టు డు ఇతర విషయాలు

1110
01:00:15,000 --> 01:00:18,000
మంచి డిజైన్ ప్రోత్సహించడానికి.

1111
01:00:18,000 --> 01:00:23,000
>> ఏదైనా చివరి ప్రశ్నలు మేము ముగించడానికి ముందు?

1112
01:00:23,000 --> 01:00:27,000
All right, ఖచ్చితంగా చర్చించండి ప్రత్యేక లేబుల్స్ కొనసాగుతుందని-మేము సంకోచించకండి.

1113
01:00:27,000 --> 01:00:30,000
మేము ఒక iOS ఒక ఉంటారు, కాబట్టి ఖచ్చితంగా ఆ ఉపయోగించుకుంటాయి సంకోచించకండి.

1114
01:00:30,000 --> 01:00:34,000
మీరు ప్రాజెక్టులు మీ సహ విద్యార్థులను పని చేయాలనుకుంటే

1115
01:00:34,000 --> 01:00:37,000
లేదా కొన్ని యాదృచ్ఛిక iOS stuff గుర్తించడానికి సహాయం

1116
01:00:37,000 --> 01:00:40,000
నాకు ఇమెయిల్ చేయడానికి సంకోచించకండి, మరియు ఖచ్చితంగా అన్ని కోడ్ ఆన్లైన్ ఎందుకంటే పరిశీలనగా

1117
01:00:40,000 --> 01:00:43,000
ని ఆసక్తితో మేము రకమైన ఎక్కువ గ్లాస్ద్

1118
01:00:43,000 --> 01:00:45,000
విషయాలు సూక్ష్మ కణాలతో వివరాలు.

1119
01:00:45,000 --> 01:00:47,000
కానీ ఒకవేళ, అప్పుడు మంచి మీ iOS ప్రాజెక్టులు లక్, మరియు నేను మా ఆశ

1120
01:00:47,000 --> 01:00:53,000
App స్టోర్ లో Apps యొక్క ఒక భారీ వలసలు.

1121
01:00:53,000 --> 01:00:56,000
[CS50.TV]