1 00:00:00,000 --> 00:00:02,000 [Powered by Google Translate] [ಸೆಮಿನಾರ್] [ಐಒಎಸ್: ಒಂದು ಬಾಸ್ ಲೈಕ್ Apps ಬರವಣಿಗೆ] 2 00:00:02,000 --> 00:00:04,000 [ಟಾಮಿ MacWilliam] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ] 3 00:00:04,000 --> 00:00:08,000 [ಈ CS50 ಹೊಂದಿದೆ.] [CS50.TV] 4 00:00:08,000 --> 00:00:12,000 >> ಸರಿ, ಎಲ್ಲರಿಗೂ, ಐಒಎಸ್ ಸ್ವಾಗತ: ಒಂದು ಬಾಸ್ ರೀತಿಯ ಅಪ್ಲಿಕೇಶನ್ಗಳು ಬರವಣಿಗೆ. 5 00:00:12,000 --> 00:00:16,000 ಈ ಸೆಮಿನಾರ್ ಐಫೋನ್ಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ಗಳು ಬರೆಯುವ ನಿಟ್ಟಿನಲ್ಲಿ ಹಾಕುತ್ತದೆ 6 00:00:16,000 --> 00:00:19,000 ಮತ್ತು ಅನುಕ್ರಮವಾಗಿ ಐಪ್ಯಾಡ್ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ಬರೆಯುವ, ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಮೂಲತಃ ಸಂಚರಿಸಲು ನೀನು 7 00:00:19,000 --> 00:00:23,000 ಅಪ್ಲಿಕೇಶನ್ ಮಾಡಲು ಹೇಗೆ ಒಂದೆರಡು ವಿಭಿನ್ನ ಉದಾಹರಣೆಗಳು, ಟಿಕ್ ಟಾಕ್ ಟೊ ಒಂದು ಸರಳ ಆಟ, 8 00:00:23,000 --> 00:00:26,000 ಅಥವಾ ನೀವು ನ್ಯೂಸ್ ರೀಡರ್ ರೀತಿಯ ನಂತಹ ಅಪ್ಲಿಕೇಶನ್ ಮಾಡುವ ಹೆಚ್ಚು ಆಕ್ತಿಹೊಂದಿದ್ದರೆ 9 00:00:26,000 --> 00:00:30,000 ಅಥವಾ ನಾನು ಮತ್ತು ಆ ಬಗ್ಗೆ ಮಾತನಾಡಬಹುದು ಇಂಟರ್ನೆಟ್ ಪರಸ್ಪರ ವಿಷಯ. 10 00:00:30,000 --> 00:00:32,000 ಇಲ್ಲಿ ನಮ್ಮ ಸಂಕ್ಷಿಪ್ತ ಕಾರ್ಯಸೂಚಿಯಲ್ಲಿ ಇಲ್ಲಿದೆ. 11 00:00:32,000 --> 00:00:36,000 >> IOS ಅಪ್ಲಿಕೇಶನ್ಗಳು, ಉದ್ದೇಶ-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 ಇದು ಆಪ್ ಸ್ಟೋರ್ನಲ್ಲಿ ಮುಕ್ತವಾಗಿರಬೇಕು, ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಮ್ಯಾಕ್ ಹೊಂದಿವೆ ಅಗತ್ಯವಿದೆ 18 00:00:54,000 --> 00:00:57,000 ಸೈದ್ಧಾಂತಿಕವಾಗಿ OS X ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿ ಚಾಲನೆಯಲ್ಲಿರುವ 19 00:00:57,000 --> 00:00:59,000 ನೀವು ನೀವು ಯಾವುದೇ ಸಮಸ್ಯೆ. 20 00:00:59,000 --> 00:01:02,000 ನಿಮ್ಮ ಬಳಕೆಗೆ ಲಭ್ಯವಿರುವ ವಿಜ್ಞಾನ ಕೇಂದ್ರದಲ್ಲಿ ಮ್ಯಾಕ್ಗಳ ಹೊಂದಿವೆ 21 00:01:02,000 --> 00:01:05,000 XCode ಸ್ಥಾಪಿಸಲಾಗಿದೆ, ಮತ್ತು ಆದ್ದರಿಂದ ಅಭಿವೃದ್ಧಿಗೆ ಆ ಬಳಸಲು ಹಿಂಜರಿಯಬೇಡಿ. ಜೊತೆಗೆ 22 00:01:05,000 --> 00:01:07,000 ನೀವು ಅಪ್ಲಿಕೇಶನ್ ಮಾಡಲು ಬಯಸುವ ಆದರೆ ಮ್ಯಾಕ್ ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ಚಿಂತಿಸಬೇಡಿ. 23 00:01:07,000 --> 00:01:09,000 ಆ ಕ್ಯಾಂಪಸ್ ಸಂಪನ್ಮೂಲಗಳ ಸಾಕಷ್ಟು ಇಲ್ಲ. 24 00:01:09,000 --> 00:01:15,000 ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಮಾಡಬಹುದು ವಿವಿಧ ಅಪ್ಲಿಕೇಶನ್ಗಳ 2 ದೊಡ್ಡ ಉದಾಹರಣೆಗಳು ಸರಿದೂಗಿಸಲು ನೀನು. 25 00:01:15,000 --> 00:01:19,000 ವಸ್ತುನಿಷ್ಠ-ಸಿ ಸಿ ಒಂದು ಸೂಪರ್ ಸೆಟ್ ಎಂಬ ಏನನ್ನು ತಾಂತ್ರಿಕವಾಗಿ 26 00:01:19,000 --> 00:01:24,000 ಯಾವುದೇ ಸಿ ಕೋಡ್ ಸಹ ಮಾನ್ಯ ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ಕೋಡ್ ಎಂದರ್ಥ. 27 00:01:24,000 --> 00:01:29,000 ನಾವು ನಾಳದ ರೀತಿಯ ಸಿ ಕೆಲವು ಹೆಚ್ಚುವರಿ ಲಕ್ಷಣಗಳನ್ನು ಧ್ವನಿಮುದ್ರಣಗೊಂಡಿತು ಅರ್ಥ 28 00:01:29,000 --> 00:01:33,000 ಈ ಲಕ್ಷಣಗಳ ಮುಂದೆ ಮತ್ತೆ malloc ಬರೆಯಲು ಹೊಂದಿರುವ ಇದರಲ್ಲಿ, ದೇವರಿಗೆ ಧನ್ಯವಾದ 29 00:01:33,000 --> 00:01:36,000 ಯಾವುದೇ ಆ ಸ್ಟುಪಿಡ್ ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಚಿಂತೆ ಮಾಡುವಲ್ಲಿ ಮತ್ತು ಅವುಗಳನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ಮತ್ತು ಎಲ್ಲಾ ಸಂಗತಿಗಳನ್ನು 30 00:01:36,000 --> 00:01:40,000 ನೀವು ಸಿ ಬಗ್ಗೆ ದ್ವೇಷಿಸುತ್ತಿದ್ದನು ಮತ್ತು ಅದರ ರೀತಿಯ ಉದ್ದೇಶ-C ನಲ್ಲಿ ಹೋದ. 31 00:01:40,000 --> 00:01:43,000 >> ಈಗ, ಉದ್ದೇಶ-ಸಿ ಕೂಡ, ಹೆಚ್ಚಿನ ಗುಣಮಟ್ಟದ ಗ್ರಂಥಾಲಯ ಹೊಂದಿದೆ 32 00:01:43,000 --> 00:01:47,000 ಆದ್ದರಿಂದ ನೀವು ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ಮುಕ್ತ ಒಳಗಿನ ಪಡೆಯಲು ಸಾಕಷ್ಟು ಹೆಚ್ಚಿನ ಕಾರ್ಯವನ್ನು ಇಲ್ಲ. 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 ಒಂದೇ ಐಒಎಸ್ ಸಂಭವಿಸುತ್ತದೆ. 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 ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ಉದ್ದೇಶ ಭಾಗವಾಗಿ ಏನೋ ಉಲ್ಲೇಖಿಸುತ್ತಿದ್ದಾರೆ 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 ಮತ್ತು ಈ ತರಗತಿಗಳು ನಿಜವಾಗಿಯೂ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ವೈಭವೀಕರಿಸಿದ್ಧಾನೆ ಮಾಡಲಾಗುತ್ತದೆ. 45 00:02:26,000 --> 00:02:30,000 ಒಂದು struct ಒಳಗೆ ನಾವು ಮೂಲಭೂತವಾಗಿ ಇಲ್ಲಿ ಹೇಳಿದರು, ಒಂದು ವಿಷಯ 46 00:02:30,000 --> 00:02:32,000 ಮತ್ತು ಈ ವಿಷಯದಲ್ಲಿ ಸದಸ್ಯರನ್ನು ಹೊಂದಬಹುದು. 47 00:02:32,000 --> 00:02:35,000 ಉದಾಹರಣೆಗೆ, ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ನೋಡ್ ಇತರ ವಿಷಯಗಳನ್ನು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ 48 00:02:35,000 --> 00:02:38,000 ಮೌಲ್ಯವನ್ನು ನಂತಹ ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ನೋಡ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್, 49 00:02:38,000 --> 00:02:44,000 ಮತ್ತು ಒಟ್ಟಿಗೆ ಪಾಯಿಂಟರ್ ಮತ್ತು ಮೌಲ್ಯವು struct ಈ ಒಂದು ಉದಾಹರಣೆಗೆ ರಚಿಸಿದರು ಎಂದು. 50 00:02:44,000 --> 00:02:47,000 ಹೊರತುಪಡಿಸಿ ತರಗತಿಗಳು ಇವೆ 51 00:02:47,000 --> 00:02:50,000 ವರ್ಗಗಳು ಅವುಗಳನ್ನು ಒಳಗೆ ಕಾರ್ಯಗಳನ್ನು ಮಾಡಬಹುದು. 52 00:02:50,000 --> 00:02:54,000 ನಾವು struct ಘೋಷಣೆ ಮಾಡಿದಾಗ, ನಾವು ಕೇವಲ ಇಂಟ್ N ಅಥವಾ ಮುಂದಿನ ನೋಡ್ * ಹೇಳಬಹುದು. 53 00:02:54,000 --> 00:02:57,000 >> ಈಗ ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ನಾವು ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯಗಳನ್ನು ಹಾಕಬಹುದು 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 ಉದಾಹರಣೆಗೆ, ನಾವು ಉದ್ದೇಶ-ಸಿ ತರಗತಿಗಳು ಅಂತರ್ನಿರ್ಮಿತ ಒಂದು ಗುಂಪನ್ನು ನೋಡಿ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ. 57 00:03:07,000 --> 00:03:11,000 ಅವುಗಳಲ್ಲಿ ಒಂದು, ಒಂದು ಸ್ಕ್ರೀನ್ ದೃಷ್ಟಿ ಪ್ರತಿನಿಧಿಸುವ ವರ್ಗ ಮಾಡಬಹುದು 58 00:03:11,000 --> 00:03:14,000 ಹೀಗೆ ಹೇಳುವ ಮೂಲಕ ನನ್ನ ಸ್ವಂತ ಅಭಿಪ್ರಾಯವನ್ನು ಜಾರಿಗೆ ಬಯಸುವ 59 00:03:14,000 --> 00:03:18,000 ನಾವು ಮೂಲತಃ ಆಪಲ್ ನಲ್ಲಿ ಯಾರೋ, ಬಹುಶಃ ನಿಜವಾಗಿಯೂ ಒಳ್ಳೆಯ ಜನ, ಸೇ 60 00:03:18,000 --> 00:03:21,000 ನನಗೆ ಈ ವರ್ಗ ಬರೆದಿದ್ದಾರೆ, ಮತ್ತು ಇದನ್ನು ಬಟನ್ ಕ್ಲಿಕ್ ವಿಷಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ 61 00:03:21,000 --> 00:03:25,000 ಅಥವಾ ಪರದೆ ಸಲ್ಲಿಸುವಿಕೆ, ಮತ್ತು ನಾವು ನೋವನ್ನು ಅನುಭವಿಸಲ್ಪಟ್ಟಿದ್ದೇವೆ ಎಂದು 62 00:03:25,000 --> 00:03:28,000 ಎಲ್ಲಾ ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ನಾವೇ ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಮತ್ತು ಆದ್ದರಿಂದ ಸರಳವಾಗಿ 63 00:03:28,000 --> 00:03:31,000 ಡೇಟಾವನ್ನು ವಂಶಪಾರ್ಯತೆಯ ನಾವು ಆ ವರ್ಗ ಮಾಡಿದ ಎಲ್ಲವನ್ನೂ ಹೇಳಬಹುದು 64 00:03:31,000 --> 00:03:34,000 ನಾನು ನನ್ನ ವರ್ಗದ ಒಳಗೆ ಬಯಸುವ, ಮತ್ತು ನಂತರ ನಾನು ಕೆಲವು ಸ್ಟಫ್ ಮಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ 65 00:03:34,000 --> 00:03:37,000 ಅಂದರೆ ಒಂದು ಅಪ್ಲಿಕೇಶನ್ ಜಾರಿಗೆ. 66 00:03:37,000 --> 00:03:40,000 ಎಂದು ಏನನ್ನು ಪದವನ್ನು ಪಿತ್ರಾರ್ಜಿತ ಅರ್ಥ. ನಾವು ಹೆಚ್ಚು ಕಾಂಕ್ರೀಟ್ ಉದಾಹರಣೆಗೆ ನೋಡುತ್ತಾರೆ. 67 00:03:40,000 --> 00:03:42,000 >> ಮತ್ತು ಅಂತಿಮವಾಗಿ, ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಮುಖ್ಯ ಎಂದು 68 00:03:42,000 --> 00:03:45,000 ಇದು ಅಕ್ಷಾಂಶ ಸುತ್ತುವರಿಯುವಿಕೆ ಕಾರಣವಾಗುತ್ತದೆ. 69 00:03:45,000 --> 00:03:48,000 ನಮ್ಮ ಸಮಸ್ಯೆಯನ್ನು ಕೆಲವು ಸೆಟ್ಗಳಲ್ಲಿ ಈ ದೊಡ್ಡ, ಜಾಗತಿಕ ಅಸ್ಥಿರ ತೋರಿಸಬಹುದಿತ್ತು 70 00:03:48,000 --> 00:03:51,000 ಎಲ್ಲೆಡೆ globals, ಮತ್ತು ನಾವು ರಾಜ್ಯದ ಟ್ರ್ಯಾಕ್ ಬಯಸುವ ಹೇಗೆ. 71 00:03:51,000 --> 00:03:55,000 ತರಗತಿಗಳು ನಾವು ವಸ್ತುವಿನ ಒಳಗೆ ಮಾಹಿತಿಯನ್ನು ಕೋಶೀಕರಿಸುವಿಕೆಯ ಆರಂಭಿಸಬಹುದು. 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 ಮತ್ತು ಆದ್ದರಿಂದ ತರಗತಿಗಳು ಒಳಗೆ ವಸ್ತುಗಳ ಕೋಶೀಕರಿಸುವಿಕೆಯ ಈ ವಾಸ್ತವವಾಗಿ ಕಾರಣವಾಗುತ್ತದೆ 75 00:04:04,000 --> 00:04:08,000 ಉತ್ತಮ ಕೋಡ್ ವಿನ್ಯಾಸಕ್ಕೆ, ಮತ್ತು ಈ ಹೆಚ್ಚುವರಿ ಲಕ್ಷಣಗಳನ್ನು ಕೆಲವೊಂದು ಸಾಧ್ಯ 76 00:04:08,000 --> 00:04:11,000 ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ. 77 00:04:11,000 --> 00:04:15,000 Forewarning, ಉದ್ದೇಶ-ಸಿ ಫಾರ್ ವಾಕ್ಯ ಬಾಳೆಹಣ್ಣುಗಳು ಹೊಂದಿದೆ. 78 00:04:15,000 --> 00:04:19,000 ಇದು, ನಾವು ಮೊದಲು ನೋಡಿದ ಏನೂ ಹಾಗೆ 79 00:04:19,000 --> 00:04:22,000 ಆದ್ದರಿಂದ ಒಂದು ಕಲಿಕೆಯ ರೇಖೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಸಿಲುಕುವ ಸ್ವಲ್ಪ ಹೊಂದಿದೆ 80 00:04:22,000 --> 00:04:24,000 ಈ ಬೀಟಿಂಗ್ ಅರ್ಥವೇನು? 81 00:04:24,000 --> 00:04:27,000 ಆದರೆ ಒಮ್ಮೆ ನೀವು ನಿಜವಾಗಿಯೂ ನಯವಾದ ಆರಂಭಿಕ ಕಲಿಕೆಯ ರೇಖೆಯನ್ನು ಹಿಂದಿನ ಪಡೆಯಿರಿ 82 00:04:27,000 --> 00:04:29,000 ಅಪ್ಲಿಕೇಶನ್ಗಳು ಬರೆಯಲು ಆರಂಭಿಸಲು. 83 00:04:29,000 --> 00:04:33,000 >> ಇಲ್ಲಿ ಹೇಳಲು, ಒಂದು ವರ್ಗ ಘೋಷಿಸಲು, ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ, ನನ್ನ ವರ್ಗ 84 00:04:33,000 --> 00:04:35,000 ಮತ್ತು ಬಹುಶಃ ಇಲ್ಲಿ ನಾನು ನಂತರ ವ್ಯಾಖ್ಯಾನಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಕೆಲವು ವಸ್ತುಗಳು, ಇವು 85 00:04:35,000 --> 00:04:38,000 ನಾನು @ ಇಂಟರ್ಫೇಸ್ ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ. 86 00:04:38,000 --> 00:04:41,000 ನಾನು @ ಇಂಟರ್ಫೇಸ್ ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ. ನನ್ನ ವರ್ಗ ಹೆಸರೊಂದನ್ನು ಪಡೆಯಲಿದ್ದೇನೆ. 87 00:04:41,000 --> 00:04:43,000 ನಂತರ ಎಲ್ಲೋ ಬೇರೆ ನಾನು @ ಕೊನೆಯಲ್ಲಿ ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ 88 00:04:43,000 --> 00:04:46,000 @ @ ಇಂಟರ್ಫೇಸ್ ಮತ್ತು ಅಂತ್ಯದ ನಡುವೆ ಮತ್ತು ಎಲ್ಲವನ್ನೂ 89 00:04:46,000 --> 00:04:48,000 ನನ್ನ ವರ್ಗದ ಹೋಗುತ್ತದೆ. 90 00:04:48,000 --> 00:04:51,000 ನಮ್ಮ. H ಕಡತಗಳ ಒಳಗೆ ಎಂಬುದನ್ನು ಎಂದು ಹೋಗುತ್ತದೆ. 91 00:04:51,000 --> 00:04:55,000 ಕೇವಲ ಸಿ ಮುಂತಾದ ನಮ್ಮ. 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 ನಂತರ ಒಳಗೆ ನಮ್ಮ. ಮೀ ಕಡತಗಳನ್ನು-ಏಕೆಂದರೆ ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ಫಾರ್ ಮೀ 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 ಒಳಗೆ ನಮ್ಮ. ಮೀ ಕಡತದ ನಾವು ಇಲ್ಲಿ ಹೇಳಲು ನೀನು ಯಾವ ಕಾರ್ಯಗಳನ್ನು ಎಲ್ಲಾ 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 ಇಂಟ್ 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 ನಾವು ಸಿ ಕಾರ್ಯಗಳನ್ನು ಡಿಕ್ಲೇರ್ಡ್ ನಾವು ಇಂಟ್ 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 ಅದು ಏನೂ ಮರಳಲು ವಿಶೇಷವೇನು, ಆದ್ದರಿಂದ ಕೌಟುಂಬಿಕತೆ ಬರಿದಾದದು ಎಂದು ವಿಶೇಷವೇನು. 113 00:06:06,000 --> 00:06:08,000 ಈ ನನ್ನ ಕ್ರಿಯೆಯ ರಿಟರ್ನ್ ವಿಧ. 114 00:06:08,000 --> 00:06:11,000 -ನಾನು ಗೊತ್ತಿಲ್ಲ ಈಗ ನಾವು ಇಲ್ಲಿ parens ಹೊಂದಿರುತ್ತವೆ. 115 00:06:11,000 --> 00:06:14,000 ಮುಂದೆ, ನನ್ನ ಕ್ರಿಯೆಯ ಹೆಸರು ಎಂದು ಹೋಗುತ್ತದೆ 116 00:06:14,000 --> 00:06:17,000 ತದನಂತರ ಅಂತಿಮವಾಗಿ ನಾವು ನಾವು ಸಿ ಹೊಂದಿದ್ದ ಒಂದು ಅಲ್ಪ ವಿರಾಮ ಚಿಹ್ನೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ 117 00:06:17,000 --> 00:06:19,000 ಇಲ್ಲಿಗೆ ಯಾವ ಹೊಸದೇನಿದೆ ಇಲ್ಲಿ ಈ ಹುಡುಗ. 118 00:06:19,000 --> 00:06:22,000 ಈ ಕೂಡುಗೆರೆ ವಾಸ್ತವವಾಗಿ ಅವಶ್ಯಕವಾಗಿದೆ, ಮತ್ತು ಈ ಹೇಳುತ್ತದೆ ಎಂದು 119 00:06:22,000 --> 00:06:26,000 ಇಲ್ಲಿ ಈ ವಿಧಾನವು ಒಂದು ವರ್ಗದ ಒಂದು ಉದಾಹರಣೆಗೆ ಕರೆ ಮಾಡಬೇಕು. 120 00:06:26,000 --> 00:06:29,000 >> ನಮ್ಮ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಡಿಕ್ಲೇರ್ಡ್ ನಂತರ ನಾವು ಬಹುಶಃ ಏನೋ ಹಾಗೆ ಹೇಳಿದರು 121 00:06:29,000 --> 00:06:32,000 struct ನೋಡ್ N, ಮತ್ತು ವಾಸ್ತವವಾಗಿ ರಚಿಸಿದ 122 00:06:32,000 --> 00:06:35,000 ನಾನು ನಿಜವಾಗಿಯೂ ಕೆಲಸ ಪ್ರಾರಂಭಿಸಲು ಪರದೆಯಿಂದ ಅಥವಾ ಆ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಒಂದು ದೃಷ್ಟಾಂತೀಕರಿಸಲ್ಪಟ್ಟಿವೆ 123 00:06:35,000 --> 00:06:38,000 ಅದರ ಒಳಗೆ ಎಂಬುದನ್ನು ಜೊತೆಗೆ, ಈ ದೂರವನ್ನು ನಾವು ಎಂದು ಅರ್ಥ 124 00:06:38,000 --> 00:06:41,000 ನಾವು ದೃಷ್ಟಾಂತೀಕರಿಸಲ್ಪಟ್ಟಿವೆ ಉಟಿ ವರ್ಗ ನಿದರ್ಶನದ ಎಂದು struct 125 00:06:41,000 --> 00:06:43,000 ನಾವು ಈ ವಿಧಾನವನ್ನು ಕರೆ ಮೊದಲು. 126 00:06:43,000 --> 00:06:46,000 ನನ್ನ ವಿಧಾನಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟುಗಳನ್ನು ಸೇರಿಸುವ ಆರಂಭಿಸಲು ಬಯಸಿದರೆ 127 00:06:46,000 --> 00:06:48,000 ಇದು ಇನ್ನಷ್ಟು ಬಾಳೆಹಣ್ಣುಗಳು ಪಡೆಯುತ್ತದೆ. 128 00:06:48,000 --> 00:06:50,000 ಇಲ್ಲಿ ನನ್ನ ಹೆಸರು ವಿಧಾನ ಇಲ್ಲಿದೆ. 129 00:06:50,000 --> 00:06:53,000 ಆಗ ನಾನು ಒಂದು ದೊಡ್ಡ ಕರುಳಿನ ಮಾಡಲಿಕ್ಕೆ ಭಾವಿಸುತ್ತೇನೆ, ಮತ್ತು ಈ ಕೊಲೊನ್ ನಂತರ ಇಲ್ಲಿ ಹೇಳುತ್ತಾರೆ ಕೆಲವು ವಾದಗಳನ್ನು ಬರುತ್ತದೆ. 130 00:06:53,000 --> 00:06:56,000 ಈ ವಿಧಾನವು ಒಂದು ವಾದವು ನಡೆಯುತ್ತದೆ. 131 00:06:56,000 --> 00:06:59,000 ಇದರ ವಾದದ ಪ್ರಕಾರ ಒಂದು int, ಮತ್ತು ವಾದದ ಹೆಸರು 132 00:06:59,000 --> 00:07:03,000 ಅಥವಾ ನಾನು ವಿಧಾನದ ಒಳಗೆ ಬಳಕೆಯನ್ನು ಆರಂಭಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಎಂದು ವೇರಿಯಬಲ್ ನಾನು ಕರೆಯಲಾಗುತ್ತದೆ. 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 ಆದ್ದರಿಂದ ಒಳಗೆ ನನ್ನ ಕ್ರಿಯೆಯ ನಾನು ಹೇಳಬಹುದು, ಎಫ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ 140 00:07:23,000 --> 00:07:25,000 ಎಫ್ + = 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 ವಸ್ತುನಿಷ್ಠ-ಸಿ ನಿಜವಾಗಿಯೂ ಸ್ಪಷ್ಟವಾಗಿ ಕೇವಲ ಆದ್ದರಿಂದ, ಸರಿ, ಹೇಳಲು ನಿರ್ಣಯ 144 00:07:37,000 --> 00:07:39,000 ನೀವು ಎಲ್ಲಾ ನಿಯತಾಂಕಗಳನ್ನು ಯಾವ ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಿದಾಗ 145 00:07:39,000 --> 00:07:41,000 ನಾನು ನಿಜವಾಗಿಯೂ ಎಲ್ಲ ಹೆಸರಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ. 146 00:07:41,000 --> 00:07:45,000 ನೀವು ಒಂದು ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಿದಾಗ, ನೀವು ವಾಸ್ತವವಾಗಿ, andFloat ಹೇಳುತ್ತೇನೆ 147 00:07:45,000 --> 00:07:47,000 ತದನಂತರ ನೀವು ಸೈನ್ ಪಾಸ್ ಮಾಡುತ್ತೇವೆ 148 00:07:47,000 --> 00:07:50,000 >> ಸ್ವಾರಸ್ಯವೆಂದರೆ, ಈ ಹೆಸರಿನ, ಆದರೆ ಇತರೆ ನಿಯತಾಂಕಗಳನ್ನು ಎಲ್ಲಾ ಅಲ್ಲ ಇದೆ 149 00:07:50,000 --> 00:07:53,000 ನಾವು 3 ಚರ್ಚೆ ನಡೆಸಿದರು ಆದ್ದರಿಂದ ನಾನು andFloat ಹೇಳಬಹುದು 150 00:07:53,000 --> 00:07:56,000 ಮತ್ತೊಂದು ಫ್ಲೋಟ್ ಹೀಗೆ. 151 00:07:56,000 --> 00:08:01,000 ಈ ವಿಧಾನಗಳು ಕರೆ ಮಾಡಿದಾಗ, ಕೋರ್ಸ್ ಬಾಳೆಹಣ್ಣುಗಳನ್ನು ಆಗಿದೆ 152 00:08:01,000 --> 00:08:04,000 ನಾನು ವಸ್ತುವನ್ನು ಹೊಂದಿರುವ, ಮತ್ತು ನಾನು, foo ಎಂಬ ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಹಾಗಿದ್ದಲ್ಲಿ 153 00:08:04,000 --> 00:08:09,000 ಮತ್ತು ನಾನು foo ಮುಕ್ತ / ನಿಕಟ parens ಹೀಗೆ ಕರೆಯುತ್ತಾರೆ, ಹೆಚ್ಚಾಗಿ ಬಯಸುವ 154 00:08:09,000 --> 00:08:11,000 ನಾನು ಬ್ರಾಕೆಟ್ ತೆರೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ. 155 00:08:11,000 --> 00:08:13,000 ಇಲ್ಲಿ ನನ್ನ ವಿಧಾನದ ಹೆಸರನ್ನು ಇಲ್ಲಿದೆ. 156 00:08:13,000 --> 00:08:17,000 ನಾನು ಬ್ರಾಕೆಟ್ ಮುಚ್ಚಲು ಪಡೆಯಲಿದ್ದೇನೆ, ಮತ್ತು ಈ ನಾನು ಎಂದು ನುಡಿದರು ವಸ್ತುವಾಗಿದೆ. 157 00:08:17,000 --> 00:08:20,000 ನೆನಪಿಡಿ, ಈ ವಿಧಾನಗಳು ಎಲ್ಲಾ ವರ್ಗದ ಒಳಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ 158 00:08:20,000 --> 00:08:23,000 ವರ್ಗಗಳು ಅವುಗಳನ್ನು ಒಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿವೆ ಏಕೆಂದರೆ. 159 00:08:23,000 --> 00:08:26,000 >> ಇಲ್ಲಿ ನಾನು ನಿರಂಕುಶವಾಗಿ, ಕೆಲವು ವರ್ಗದ ವಸ್ತುವನ್ನು ರಚಿಸಿದ 160 00:08:26,000 --> 00:08:28,000 ಮತ್ತು ಇದು ಯುದ್ಧಕ್ಕೆ ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೊಂದಿದೆ. 161 00:08:28,000 --> 00:08:31,000 ವಸ್ತುವನ್ನು ನಿರ್ಮಿಸಲು 2 ಹಂತಗಳು ಇವೆ. 162 00:08:31,000 --> 00:08:34,000 ಮೊದಲ ಹಂತದ ನಾನು ಸ್ಥಳವನ್ನು ನಿಯೋಜಿಸಿ ಬಯಸುವ ಹೇಳಲು ಹೊಂದಿದೆ. 163 00:08:34,000 --> 00:08:37,000 ಈ ಒಂದು malloc ಸಮ. ನಾವು ಎಂದಿಗೂ malloc ಹೇಳಲು ಇಲ್ಲ. 164 00:08:37,000 --> 00:08:42,000 ನಾವು, ಮೀ ಕೈಬಿಡಲಾಯಿತು ಇದು alloc ಮಾಡಿದ, ಮತ್ತು. ಎಂ. ಸಿ ಬದಲಿಗೆ. 165 00:08:42,000 --> 00:08:47,000 ನಾವು alloc ಏನನ್ನಾದರೂ ನಂತರ ನಾವು ನಂತರ ಅದನ್ನು ಆರಂಭಿಸಲು ಅಗತ್ಯವಿದೆ. 166 00:08:47,000 --> 00:08:49,000 ಮೂಲತಃ ನೀವು ವಸ್ತುಗಳನ್ನು ತಯಾರಿಸಲು ನೀವು ಕೆಲವು ತರ್ಕ ಹೊಂದಿರುತ್ತವೆ ಬಯಸಬಹುದು 167 00:08:49,000 --> 00:08:53,000 ಅವರು ರಚಿಸಿದ ಮಾಡಿದಾಗ ನಿರ್ವಹಿಸುವ, ಆದ್ದರಿಂದ ನೀವು ಕೆಲವು ಪೂರ್ವನಿಯೋಜಿತ ಮೌಲ್ಯಗಳನ್ನು ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ 168 00:08:53,000 --> 00:08:57,000 ಅಥವಾ ಆ ರೀತಿಯ, ಮತ್ತು ಈ init ವಿಧಾನವು ವಾಸ್ತವವಾಗಿ ವಸ್ತು ಸೃಷ್ಟಿಸುತ್ತದೆ ಏನು. 169 00:08:57,000 --> 00:08:59,000 ಮೊದಲು, ನಾವು ಸಿ ಮಾಡಿದಂತೆ ಸ್ಥಳವನ್ನು ನಿಯೋಜಿಸಿ 170 00:08:59,000 --> 00:09:04,000 ನಂತರ ನಾವು ಅಥವಾ ಇಡೀ ಆಡಿದ್ದೇನೆ ಇರಬಹುದು ಇದು ಆರಂಭಿಸಲು. 171 00:09:04,000 --> 00:09:07,000 ನಾವು ವಸ್ತುವಿನ ಓ ಈ ವಿಷಯ ಹಿಂದಿರುಗಿದ ಮಾಡುತ್ತಿದ್ದೇವೆ. 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 ಈ ವಸ್ತುವು ಒ ರಲ್ಲಿ, ಆದ್ದರಿಂದ ನಾನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ವೇಳೆ ಅರ್ಥ 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 ಈ ವಸ್ತುವು ಒ ಒಂದು ಕ್ರಿಯೆ ಕರೆ ಇದೆ. 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 >> ಸರಿ, ಅವರ ಉದ್ದೇಶ-ಸಿ ನಿರ್ಮಿಸಲಾಗಿದೆ ಕೆಲವು ವಿಷಯಗಳ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಅವಕಾಶ 186 00:09:54,000 --> 00:09:56,000 ಎಂದು ಅವಶ್ಯವಾಗಿ ಸಿ ನಿರ್ಮಿಸಲಾಗಿರುವ ಇಲ್ಲ 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 ವಸ್ತುನಿಷ್ಠ-ಸಿ ಎಲ್ಲಾ ನಮಗೆ ನಿರ್ಮಿಸಲಾದ ಆ ಹೊಂದಿದೆ, ಮತ್ತು ಇದು ನಿರ್ಮಾಣವಾಗಿರುವ 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 ಈ ಸಿ ಕೇವಲ 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 ಈ ವಾಕ್ಯವನ್ನು ರು ಹೇಳುತ್ತಾರೆ ಒಂದು ವಿಧಾನ 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 ಆಪಲ್ನ ದಸ್ತಾವೇಜನ್ನು ಮಹಾನ್ ಹೊಂದಿದೆ, ಮತ್ತು ನಾವು ಸ್ವಲ್ಪ ಆ ನೋಡೋಣ ಮಾಡುತ್ತೇವೆ. 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 ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು 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 ಮೂಲಕ, ಆಪಲ್ ನ ಗ್ರಂಥಾಲಯಗಳು ಬಹಳಷ್ಟು ಒಳಗೆ ಈ ಎನ್ಎಸ್ ನೋಡುತ್ತಾರೆ. 235 00:12:18,000 --> 00:12:21,000 ಎನ್ಎಸ್ ನಿಜವಾಗಿಯೂ ಸ್ಟೀವ್ ಜಾಬ್ಸ್ ಮೊದಲ ಕಂಪನಿಯಾಗಿದೆ ಇದು ಮುಂದಿನ ಹಂತದಲ್ಲಿ, ಎಂದರೆ 236 00:12:21,000 --> 00:12:24,000 ಅವರು ನಿಜವಾಗಿಯೂ ಕೋಡ್ ಸಾಕಷ್ಟು ಬರೆಯಲು ಪ್ರಾರಂಭಿಸಿದರು ಮತ್ತು ಆ ಸ್ 237 00:12:24,000 --> 00:12:27,000 ಮ್ಯಾಕ್ OS X ಮತ್ತು ಇತರ ವಿಷಯವನ್ನು ಎಲ್ಲಾ ಆಧಾರದ ರೀತಿಯ ಮಾಹಿತಿ, 238 00:12:27,000 --> 00:12:32,000 ಆದ್ದರಿಂದ ಈ ಎನ್ಎಸ್ ಈ ಸಂತೋಷವನ್ನು ಪರಂಪರೆ ರೀತಿಯ ಹಿಂದಿನ ಕಂಪನಿಗಳಿಗೆ ಕೂಗುತ್ತಾನೆ ಆಗಿದೆ 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 ನ ಒಂದು ಸಮಗ್ರ ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ಉದಾಹರಣೆಯನ್ನು ಅವಲೋಕಿಸೋಣ. 242 00:12:41,000 --> 00:12:44,000 ಇಲ್ಲಿ ನಾನು XCode ಒಳಗೆ am. 243 00:12:44,000 --> 00:12:47,000 ಇಲ್ಲಿ ಪಡೆಯಲು, ನಾನು ಮೊದಲ, ಆಪ್ ಸ್ಟೋರ್ ನಿಂದ 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 ನಾವು ಸಿ ನಡೆಯುತ್ತಿರುವ ನಾವು ಕೇವಲ ಹಾಗೆ 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 ಆದ್ದರಿಂದ ನಾವು ಈ ನನ್ನ ಮೊದಲ ಉದ್ದೇಶ-ಸಿ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರವೇಶ ಬಿಂದು ಎಂದು ನೋಡಬಹುದು. 256 00:13:30,000 --> 00:13:32,000 ಇಲ್ಲಿ ನಾವು ಈಗ ಈ ನಿರ್ಲಕ್ಷಿಸಬಹುದು. 257 00:13:32,000 --> 00:13:35,000 ಈ ಮೂಲತಃ ಕೆಲವು ಮೆಮೊರಿ ನಿರ್ವಹಣಾ ಸಾಮಗ್ರಿ ಎಂದು ನೀವು ನಿಜವಾಗಿಯೂ ತಿನ್ನುವೆ 258 00:13:35,000 --> 00:13:37,000 ಎವರ್ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ. 259 00:13:37,000 --> 00:13:39,000 >> ಇಲ್ಲಿ ಈ ಮೊದಲ ಬ್ಲಾಕ್ ನೋಡೋಣ. 260 00:13:39,000 --> 00:13:46,000 ಈ ಮೊದಲ ಸಾಲು, ನಾನು ವಿದ್ಯಾರ್ಥಿ ಹೇಳಲು ವೇಳೆ * ಆಲಿಸ್ = [[ವಿದ್ಯಾರ್ಥಿ alloc] init] ಏನು ಎಂದು ಈಸ್? 261 00:13:46,000 --> 00:13:50,000 ಇಲ್ಲಿ ಈ ಮೊದಲ ವಿದ್ಯಾರ್ಥಿ, ಬಹುಶಃ ಒಂದು ವರ್ಗ. 262 00:13:50,000 --> 00:13:54,000 ಈ ಆಪಲ್ ಬರೆದ ಒಂದು ವರ್ಗ, ಆದರೆ ನಾನು ಬರೆದ ಒಂದು ಕ್ಲಾಸ್. 263 00:13:54,000 --> 00:13:57,000 ನಾನು ಬಯಸುವ ಮೊದಲ ವಿಷಯ, ನಾನು ಒಂದು ಹೊಸ ವಿದ್ಯಾರ್ಥಿ ಸ್ಥಳವನ್ನು ನಿಯೋಜಿಸಿ ಬಯಸುವ ಆಗಿದೆ 264 00:13:57,000 --> 00:14:00,000 ತದನಂತರ ನಾನು ಆರಂಭಿಸಲು ಬಯಸುವ, ಆದ್ದರಿಂದ ಈ ನನಗೆ ಮರಳಿ ನೀಡುತ್ತದೆ 265 00:14:00,000 --> 00:14:05,000 ಈ ಹೊಸ ವಿದ್ಯಾರ್ಥಿ ವಸ್ತು, ಮತ್ತು ಆಲಿಸ್ ಎಂಬ ವೇರಿಯಬಲ್ ಈ ಸಂಗ್ರಹಿಸುವ ನುಡಿದರು. 266 00:14:05,000 --> 00:14:07,000 ಆ ವರ್ಗ ಅಲ್ಲಿ ಬರುತ್ತದೆಯೇ? 267 00:14:07,000 --> 00:14:12,000 ಹಾಗೆಯೇ, ಇಲ್ಲಿ ಮೇಲೆ ಎಡಭಾಗದಲ್ಲಿ ಈ ನನ್ನ ಯೋಜನೆಯ ಒಳಗೆ ವಿವಿಧ ಕಡತಗಳ ಎಲ್ಲಾ. 268 00:14:12,000 --> 00:14:16,000 ನಾವು ನಾನು Student.h ಮತ್ತು Student.m ಹೊಂದಿರುತ್ತವೆ ಇಲ್ಲಿ ನೋಡಬಹುದು. 269 00:14:16,000 --> 00:14:20,000 ನಾನು ಎಲ್ಲ ವಿಷಯಗಳ ಘೋಷಿಸಲು ಅಲ್ಲಿ. H ಫೈಲ್, ನೆನಪು, ಆಗಿದೆ 270 00:14:20,000 --> 00:14:22,000 ಆ ವರ್ಗದ ಒಳಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಕಾಣಿಸುತ್ತದೆ. 271 00:14:22,000 --> 00:14:25,000 >> ಅವರ ಆ ಒಂದು ಗಮನಿಸೋಣ. 272 00:14:25,000 --> 00:14:29,000 ಸರಿ, ಇಲ್ಲಿ ನಾವು ಈ @ ಇಂಟರ್ಫೇಸ್ ಹೊಂದಿವೆ, ಮತ್ತು ಈ ಇಲ್ಲಿ ಬರುತ್ತದೆ ಹೇಳುತ್ತಾರೆ 273 00:14:29,000 --> 00:14:33,000 ನನ್ನ ವರ್ಗ ಒಳಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಎಲ್ಲ ಘೋಷಣೆಗಳು. 274 00:14:33,000 --> 00:14:36,000 ಆಗ ನಾನು ಒಂದು ದೊಡ್ಡ ಕರುಳಿನ ಹೊಂದಿರುತ್ತವೆ. ಆಗ ನಾನು ಈ ವಿಷಯ NSObject ಹೊಂದಿರುತ್ತವೆ. 275 00:14:36,000 --> 00:14:40,000 ಈ ಕೊಲೊನ್ ನಾವು ಸ್ವಲ್ಪ ಮುಂಚಿನ ಚರ್ಚಿಸುತ್ತಿದ್ದಾರೆ ಎಂದು ಪಿತ್ರಾರ್ಜಿತ ಬಿಟ್ ಸಂಕೇತವಾಗಿದೆ. 276 00:14:40,000 --> 00:14:43,000 ಈ ಹೇಳುತ್ತಾರೆ ಒಂದು NSObject ಮಾಡಬಹುದು ಎಲ್ಲವೂ 277 00:14:43,000 --> 00:14:46,000 NSObject ಬೇರೊಬ್ಬರು ಬರೆದ ಈ ವರ್ಗ, ಅಲ್ಲಿ 278 00:14:46,000 --> 00:14:50,000 ನಾನು ಹಾಗೆ ಮಾಡಲು ಬಯಸುವ ಈ NSObject ಮಾಡಬಹುದು ಎಲ್ಲವೂ. 279 00:14:50,000 --> 00:14:54,000 ಹೇಳುವ ಮೂಲಕ: NSObject ಎಂದು ನಾನು ಮೂಲತಃ ಅರ್ಥ 280 00:14:54,000 --> 00:14:58,000 ಇನ್ನೊಂದು ವರ್ಗದ ಕಾರ್ಯಗಳನ್ನು ಎಲ್ಲಾ ಆನುವಂಶಿಕವಾಗಿ. 281 00:14:58,000 --> 00:15:02,000 ನಿಜಕ್ಕೂ ನಾನು ಬಳಸಬಹುದಾದ ವಿವಿಧ ವಿಧಾನಗಳು ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳ ಇಡೀ ಗುಂಪೇ ನೀಡಿದರು. 282 00:15:02,000 --> 00:15:05,000 ಡೌನ್ ಇಲ್ಲಿ ನಾನು 2 ಲಕ್ಷಣಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ ನುಡಿದರು. 283 00:15:05,000 --> 00:15:08,000 ಈ ಒಂದು struct ವೇಳೆ ನನ್ನ ವಿದ್ಯಾರ್ಥಿ ಅರ್ಥ, ಈ 2 ಸಂಗತಿಗಳು ಎಂದು 284 00:15:08,000 --> 00:15:11,000 ಒಳಗೆ ನನ್ನ struct ಆಫ್, ಆದ್ದರಿಂದ ಪ್ರತಿ ವಿದ್ಯಾರ್ಥಿ ಒಂದು ಹೆಸರನ್ನು ಹೊಂದಿದೆ 285 00:15:11,000 --> 00:15:14,000 , ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ, ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ ಸಹ ಗ್ರೇಡ್ ಹೊಂದಿದೆ 286 00:15:14,000 --> 00:15:17,000 ಒಂದು ಇಂಟ್ ಹೊಂದಿದೆ. 287 00:15:17,000 --> 00:15:23,000 >> ಅಂತಿಮವಾಗಿ, ಕೆಳಗೆ ಇಲ್ಲಿ ನನ್ನ ವಿದ್ಯಾರ್ಥಿ ವಿಧಾನವನ್ನು ರಚಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ. 288 00:15:23,000 --> 00:15:26,000 ನಾನು initWithName, ನನ್ನ ವಿಧಾನ ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಇದು ಒಂದು ವಾದವು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ 289 00:15:26,000 --> 00:15:31,000 ಮತ್ತು ಆರ್ಗ್ಯುಮೆಂಟ್ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ, ಮತ್ತು ನಾನು ಅದನ್ನು ಹೆಸರಿಸಲು ಕರೆಯಲಾಗುತ್ತದೆ. 290 00:15:31,000 --> 00:15:35,000 ಈಗ ನಾವು ವಾಸ್ತವವಾಗಿ ಈ ವರ್ಗ ಜಾರಿಗೆ ಹೇಗೆ ನೋಡೋಣ. 291 00:15:35,000 --> 00:15:38,000 ಇಲ್ಲಿ, ಈಗ ನಾನು, ನನ್ನ. ಮೀ ಕಡತದ ಒಳಗೆ ಆಮ್ 292 00:15:38,000 --> 00:15:40,000 ಅನುಷ್ಠಾನಕ್ಕೆ ಮೀ, ನಾನು ಭಾವಿಸುತ್ತೇನೆ. 293 00:15:40,000 --> 00:15:44,000 ನಾನು, ನನ್ನ ಕೊನೆಯ ನನ್ನ ಅಳವಡಿಸಿರುವ, ಮತ್ತು ನಾನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ನಾನು ಅಲ್ಲಿ ಇಲ್ಲಿ 294 00:15:44,000 --> 00:15:47,000 ಯಾವ initWithName ಮಾಡುತ್ತದೆ. 295 00:15:47,000 --> 00:15:50,000 ನಾನು ನಂತರ initWithName, ನನ್ನ ನಿಯತಾಂಕ ಹೆಸರು, ಮತ್ತು ಈ ಹೊಂದಿವೆ 296 00:15:50,000 --> 00:15:53,000 ನಾನು ವಿದ್ಯಾರ್ಥಿ ರಚಿಸುವ ನಾನು ಅಲ್ಲಿ, ಆಗಿದೆ 297 00:15:53,000 --> 00:15:56,000 ಆದ್ದರಿಂದ ಈ ಒಂದು ಸ್ವಲ್ಪ ರಹಸ್ಯ ಹೊಂದಿದೆ, ಆದರೆ ಈ ಬಾಯ್ಲರ್ ರೀತಿಯ 298 00:15:56,000 --> 00:15:58,000 ನಿಮ್ಮ ನಿರ್ಮಾಣಕ್ಕೆ ಒಳಗೊಂಡಿದೆ ಬಯಸುವ. 299 00:15:58,000 --> 00:16:02,000 ಇಲ್ಲಿ ಈ ಆರಂಭಕ್ಕೆ ಫಂಕ್ಷನ್, initWithName, ನಿರ್ಮಾಣಕಾರ ಒಂದು ವಿಧ. 300 00:16:02,000 --> 00:16:05,000 ನೀವು ಮೂಲತಃ ಹೊಸ ವಿದ್ಯಾರ್ಥಿ ವಸ್ತುವನ್ನು ನಿರ್ಮಿಸುವ ನೀವು 301 00:16:05,000 --> 00:16:07,000 ಮತ್ತು ಬಹುಶಃ ಇದು ಒಳಗೆ ಕೆಲವು ಡೇಟಾವನ್ನು ಕಳುಹಿಸಲು. 302 00:16:07,000 --> 00:16:11,000 ನಾನು ಬಯಸುವ ಮೊದಲ ನಾನು ಈ ಸೂಪರ್ ವಿಷಯ ಬಗ್ಗೆ init ಕರೆ ಬಯಸುವ ಹೊಂದಿದೆ. 303 00:16:11,000 --> 00:16:15,000 >> ನೆನಪಿಡಿ ನಾನು. H ಕಡತ ಮತ್ತೆ ಇಲ್ಲಿ ಹೇಳಿದರು 304 00:16:15,000 --> 00:16:21,000 ಎಲ್ಲವೂ ಒಂದು NSObject ವಿದ್ಯಾರ್ಥಿ ಸಹ ಹೊಂದಿರುತ್ತದೆ. 305 00:16:21,000 --> 00:16:24,000 ನಾನು ಯಾವ ನಾನು ಅಗತ್ಯವಾಗಿ ಒಂದು ವಿದ್ಯಾರ್ಥಿ ರಚಿಸುವಾಗ ಅರ್ಥ 306 00:16:24,000 --> 00:16:28,000 ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ನಾನು ಆ ಡೇಟಾವನ್ನು ವಂಶಪಾರ್ಯತೆಯ ನಾನು NSObject 307 00:16:28,000 --> 00:16:32,000 ಸಹ ಸರಿಯಾಗಿ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಇದೆ. 308 00:16:32,000 --> 00:16:36,000 ನಾನು ಹೇಳಲು ಅಗತ್ಯವಿದೆ ಈ ಸೂಪರ್ ನಿಜವಾಗಿ ಪೋಷಕ ವರ್ಗ ಉಲ್ಲೇಖಿಸಲು ಹೋಗುತ್ತದೆ 309 00:16:36,000 --> 00:16:39,000 ನಾನು ವಂಶಪಾರ್ಯತೆಯ ನಾನು, ಆದ್ದರಿಂದ ನಾನು ಆರಂಭಿಸಲು ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ 310 00:16:39,000 --> 00:16:43,000 ನಾನು ಅದನ್ನು ಬಳಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಆರಂಭಿಸುವ ಮುನ್ನ ನಾನು ಅವಲಂಬಿಸಿ ನಾನು ಎಲ್ಲವೂ. 311 00:16:43,000 --> 00:16:46,000 ಆ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ವೇಳೆ ನಂತರ ಸರಿಯಾಗಿ ಈ ಕೇವಲ ಹೇಳುವ ವೇಳೆ malloc 312 00:16:46,000 --> 00:16:50,000 ಶೂನ್ಯ ಹಿಂತಿರುಗಿಸಿಲ್ಲ ನಂತರ ನಾನು ಕೆಲವು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿಸುವ ಆರಂಭಿಸಬಹುದು. 313 00:16:50,000 --> 00:16:54,000 >> ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು 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 ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಪಿತ್ರಾರ್ಜಿತ ವಿಷಯವನ್ನು ಅರ್ಥ ಇದ್ದರೆ ಚಿಂತಿಸಬೇಡಿ. 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 ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ವಾಕ್ಯ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ನಾವು ಕೆಲವು ಹೆಚ್ಚು ಅರ್ಧದಂತೆ ಆರಂಭಿಸುವ ಮುನ್ನ 362 00:19:26,000 --> 00:19:30,000 ಆಸಕ್ತಿದಾಯಕ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ಅಭಿವೃದ್ಧಿ ವಿಷಯ? 363 00:19:30,000 --> 00:19:34,000 >> ಸರಿ, ಆದ್ದರಿಂದ ಅವರ ವಾಸ್ತವವಾಗಿ ಒಂದು ಐಫೋನ್ ಅಪ್ಲಿಕೇಶನ್ ಮಾಡೋಣ. 364 00:19:34,000 --> 00:19:39,000 ನಿಮ್ಮ ಐಫೋನ್ ಅಪ್ಲಿಕೇಶನ್ ನೀವು ಒಳಗೆ ಬಳಸಿಕೊಂಡು ವಾಪಸಾಗುತ್ತೇವೆ ಕೋರ್ ತರಗತಿಗಳು, ವೀಕ್ಷಿಸಿ ನಿಯಂತ್ರಕಗಳು ಕರೆಯಲಾಗುತ್ತದೆ 365 00:19:39,000 --> 00:19:42,000 ಮತ್ತು ಒಂದು ನೋಟ ನಿಯಂತ್ರಕ ಮೂಲತಃ ಒಂದು ಸ್ಕ್ರೀನ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ 366 00:19:42,000 --> 00:19:46,000 ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಒಳಗೆ, ಆದ್ದರಿಂದ ನಾನು, ಉದಾಹರಣೆಗೆ, ಸಂಗೀತ ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ ಆಮ್ ವೇಳೆ 367 00:19:46,000 --> 00:19:50,000 ಒಂದು ನೋಟ ನಿಯಂತ್ರಕ ನನ್ನ ಐಫೋನ್ ಎಲ್ಲಾ ಹಾಡುಗಳನ್ನು ವೀಕ್ಷಿಸಲು ಇದರಲ್ಲಿ ವೀಕ್ಷಿಸಿ ಬಿಂಬಿಸುತ್ತದೆ. 368 00:19:50,000 --> 00:19:53,000 ನಾನು ಹಾಡು ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ಆಡಲು ಪ್ರಾರಂಭಿಸಿದಾಗ ಮತ್ತೊಂದು ನೋಟ ನಿಯಂತ್ರಕ ಆಗಿರಬಹುದು 369 00:19:53,000 --> 00:19:55,000 ಅಥವಾ ನಾನು ಕಲಾವಿದರು ಕೆಳಭಾಗಕ್ಕೆ ಕೊರೆಯುವುದು ಭಾವಿಸುತ್ತೇನೆ ಎಂದು. 370 00:19:55,000 --> 00:19:59,000 ಆ ವಿವಿಧ ಪರದೆಯ ಪ್ರತಿ, ಒಂದು ವಿಭಿನ್ನ ದೃಷ್ಟಿಕೋನವನ್ನು ನಿಯಂತ್ರಕ ನಿರೂಪಿಸಲಾಗಿದೆ ಮಾಡಬಹುದು 371 00:19:59,000 --> 00:20:04,000 ಮತ್ತು ಒಂದು ನೋಟ ನಿಯಂತ್ರಕ ನಿಜವಾಗಿಯೂ ಈ ಸ್ಕ್ರೀನ್ ಹೇಗೆ ಕೆಲಸ ಹೇಳುತ್ತದೆ ಕೇವಲ ಒಂದು ವರ್ಗ. 372 00:20:04,000 --> 00:20:07,000 ಒಂದು ನೋಟ ನಿಯಂತ್ರಕ ಒಳಗೆ ಥಿಂಗ್ಸ್, ನಾವು, ಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿವೆ ಎಂದು ನೀನು 373 00:20:07,000 --> 00:20:10,000 ಆದ್ದರಿಂದ ಒಂದು ಬಟನ್ ವಿಷಯಗಳನ್ನು ನಮ್ಮ ದೃಷ್ಟಿಕೋನ ನಿಯಂತ್ರಕ ಒಂದು ಆಸ್ತಿ ಎಂದು ಹೋಗುತ್ತದೆ. 374 00:20:10,000 --> 00:20:13,000 >> ನಾವು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿವೆ ಎಂದು ನೀನು, ಮತ್ತು ಈ ಮೂಲತಃ ಈವೆಂಟ್ ನಿರ್ವಹಣಾಕಾರರು ಇವೆ. 375 00:20:13,000 --> 00:20:16,000 ಈ ವಿಧಾನವು ಈ ಗುಂಡಿಯನ್ನು ಒತ್ತಿ ಯಾವಾಗ ಹೇಳುತ್ತಾರೆ 376 00:20:16,000 --> 00:20:19,000 ನಾನು, ಅಂತಿಮವಾಗಿ, ಮತ್ತೆ ಏನನ್ನಾದರೂ ಮಾಡಲು ಬಯಸುವ, ಮತ್ತು 377 00:20:19,000 --> 00:20:24,000 ನಾವು ಪ್ರಸ್ತುತ ಉದಾಹರಣೆಗೆ ಪ್ರವೇಶಿಸಲು ಈ ಸ್ವಯಂ ಕೀವರ್ಡ್ ಅನ್ನು ಮಾಡಲು ನೀನು. 378 00:20:24,000 --> 00:20:29,000 ಐಒಎಸ್ ರಲ್ಲಿ ಸಂಪರ್ಕಸಾಧನಗಳನ್ನು ನಿರ್ಮಿಸಲು ವಾಸ್ತವವಾಗಿ ನಿಜವಾಗಿಯೂ ಸುಲಭ. 379 00:20:29,000 --> 00:20:32,000 ಅವರು, ಈ ಸಂತೋಷವನ್ನು ಡ್ರ್ಯಾಗ್ ಮತ್ತು ಇಂಟರ್ಫೇಸ್ ಬಿಲ್ಡರ್ ಎಂಬ ಬಿಡು ಇಂಟರ್ಫೇಸ್ ಹೊಂದಿಲ್ಲ 380 00:20:32,000 --> 00:20:37,000 ಮತ್ತು 2 ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು ನಿಮ್ಮ ಉದ್ದೇಶ-ಸಿ ಅಪ್ ಇಂಟರ್ಫೇಸ್ ಬಿಲ್ಡರ್ ಗೆ ತಂತಿ 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 >> ವಾಸ್ತವವಾಗಿ ಈ ಗ್ರಾಫಿಕಲ್ ಅಪ್ WIRE ಗೆ 388 00:20:57,000 --> 00:21:00,000 ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್ ಅದು ನಿಜವಾಗಿಯೂ ಸರಳ. 389 00:21:00,000 --> 00:21:03,000 ನೀವು IBOutlet ಲಗತ್ತಿಸಬಹುದು ಬಯಸಿದರೆ, ನೀವು ಮಾಡಬೇಕಾದ ಎಲ್ಲಾ, ನೀವು ಕ್ಲಿಕ್ ನಿಯಂತ್ರಣ 390 00:21:03,000 --> 00:21:05,000 ಮತ್ತು ಈ ನಿಜವಾಗಿಯೂ ತ್ವರಿತ ಉದಾಹರಣೆ ನೋಡುತ್ತಾರೆ. 391 00:21:05,000 --> 00:21:07,000 ವೀಕ್ಷಿಸು ನಿಯಂತ್ರಕ ಅದನ್ನು ಹೇಳುತ್ತಾರೆ ಅಲ್ಲಿ ನೀವು ಕ್ಲಿಕ್ ನಿಯಂತ್ರಿಸಲು. 392 00:21:07,000 --> 00:21:09,000 ನೀವು ಇದಕ್ಕೆ ಇಂಟರ್ಫೇಸ್ ಒಂದಿಗೆ ಎಳೆಯಿರಿ ಹೋಗುವ, ಅಥವಾ ನೀವು 393 00:21:09,000 --> 00:21:13,000 ನೀವು ಕ್ರಿಯೆಯನ್ನು ಹ್ಯಾಂಡ್ಲರ್ ಹುಕ್ ಅಪ್ ಬಯಸಿದರೆ ನೀವು ಇಂಟರ್ಫೇಸ್ನಿಂದ ಎಳೆಯಲು ನೀನು 394 00:21:13,000 --> 00:21:15,000 ಬೇರೆ ದಿಕ್ಕಿನಲ್ಲಿ. 395 00:21:15,000 --> 00:21:20,000 ನ ಒಂದು ನಿಜವಾಗಿಯೂ ಸರಳ ಐಒಎಸ್ ಉದಾಹರಣೆಯನ್ನು ಅವಲೋಕಿಸೋಣ. 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 ಮತ್ತು ಉಚಿತ ಹೇಳಲು ಹೊಂದಿರುವ ನಿಮ್ಮನ್ನು ತಡೆಯುವ ಉತ್ತಮ ಲಕ್ಷಣವಾಗಿದೆ. 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 ಮತ್ತು ಈ, ಮತ್ತೆ, ಆಪಲ್ ನಮಗೆ HANDY ಸ್ಟಫ್ ಬಹಳಷ್ಟು ಮಾಡುತ್ತದೆ ಎಂದು ಬರೆದ ಕೆಲವು ವರ್ಗ 424 00:22:43,000 --> 00:22:46,000 ಪ್ರದರ್ಶನಕ್ಕಾಗಿ ಇಷ್ಟ. 425 00:22:46,000 --> 00:22:50,000 ನಾನು ನನ್ನ ನೋಟ ನಿಯಂತ್ರಕ ಏನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಆರಂಭಿಸಬಹುದು ಅಲ್ಲಿ ಇಲ್ಲಿ, 426 00:22:50,000 --> 00:22:52,000 ಮತ್ತು ನಾನು ಈ ಯಾವುದೇ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು ತಿರುಗುತ್ತದೆ. 427 00:22:52,000 --> 00:22:55,000 ಈ ಆಪಲ್ ಉಚಿತವಾಗಿ ನನಗೆ ನೀಡುವ ಬಾಯ್ಲರ್ ಸಂಕೇತಗಳನ್ನು. 428 00:22:55,000 --> 00:22:59,000 , ನಾನು ಮೊದಲ ಲೈನ್ ಅಗತ್ಯವಿದೆ ಮಾಡಲಿಲ್ಲ, ಅಥವಾ ನಾನು ವರ್ಗ ಇಲ್ಲ 429 00:22:59,000 --> 00:23:02,000 ಆದ್ದರಿಂದ ನಾವು ತೊಡೆದುಹಾಕಲು ಮತ್ತು ಈ ತೊಡೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ. 430 00:23:02,000 --> 00:23:05,000 ಸರಿ, ಈ ನನ್ನ ಖಾಲಿ ಸ್ಕ್ರೀನ್ ಹೊಂದಿದೆ. 431 00:23:05,000 --> 00:23:08,000 >> ಈಗ ಈ MainStoryboard.storyboard ಕ್ಲಿಕ್ ಅವಕಾಶ 432 00:23:08,000 --> 00:23:11,000 ಇದು ಕುತೂಹಲಕಾರಿ ಪಡೆಯಲು ಆರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಇದು. 433 00:23:11,000 --> 00:23:14,000 ಈ ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ ಮೊದಲ ಸ್ಕ್ರೀನ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. 434 00:23:14,000 --> 00:23:17,000 ನಾನು ಒಂದು ಬಟನ್ ಸೇರಿಸಲು ಬಯಸಿದರೆ, HTML ನಲ್ಲಿ ನಾನು ಒಂದು ಬಟನ್ ಟ್ಯಾಗ್ ತಯಾರಿಸಿದರು. 435 00:23:17,000 --> 00:23:20,000 Android ನಲ್ಲಿ, ಒಂದು ಗುಂಡಿಯನ್ನು ಟ್ಯಾಗ್ ರಚಿಸಲು ಹೊಂದಿವೆ 436 00:23:20,000 --> 00:23:23,000 ಆದರೆ ಐಒಎಸ್ ರಲ್ಲಿ ನಾನು ಕೆಳಗೆ ಬಲಭಾಗದಲ್ಲಿ ಇಲ್ಲಿ ಕೆಳಗೆ ಬರುವ ವೇಳೆ 437 00:23:23,000 --> 00:23:27,000 ನಾನು ಇಲ್ಲಿ ಈ 3 ನೇ ಒಂದು ಕ್ಲಿಕ್ ಮಾಡಿದರೆ ಮತ್ತು ಅದು, ಆಬ್ಜೆಕ್ಟ್ಸ್ ಹೇಳುತ್ತಾರೆ ಅಲ್ಲಿ 438 00:23:27,000 --> 00:23:31,000 ನಾನು ಕೆಳಗೆ ಚಲಿಸಬಹುದು, ಅಥವಾ ನಾನು ಬಟನ್ ಹುಡುಕುವ ಆರಂಭಿಸಬಹುದು. 439 00:23:31,000 --> 00:23:35,000 ನಾನು ವಾಸ್ತವವಾಗಿ ಈ ಬಲಕ್ಕೆ ಎಳೆಯಿರಿ ಬಿಡಿ ಹಾಗಾಗಿ ಮತ್ತು, ಒಂದು ಗುಂಡಿಯನ್ನು ನೋಡಿ 440 00:23:35,000 --> 00:23:38,000 ನಾನು ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ ಈ ತೆರೆಯಲ್ಲಿ ಒಂದು ಬಟನ್ ಸೇರಿಸಿದ. 441 00:23:38,000 --> 00:23:41,000 ನಾನು ಪಠ್ಯ ಬದಲಾಯಿಸಲು ಬಯಸಿದಲ್ಲಿ, ನಾನು ಡಬಲ್, ಅದನ್ನು ಕ್ಲಿಕ್ ಮಾಡಬಹುದು 442 00:23:41,000 --> 00:23:47,000 ಏನೋ ಹಾಗೆ ಆಕರ್ಷಿಸುತ್ತವೆ ಹೇಳುತ್ತಾರೆ "ಮಿ ಒತ್ತಿರಿ." 443 00:23:47,000 --> 00:23:51,000 ಈ ಅಪ್ಲಿಕೇಶನ್ ರನ್ ವೇಳೆ ಸರಿ, ಈಗ ನಾವು, ಇದು ಕಂಪೈಲ್ 444 00:23:51,000 --> 00:23:54,000 ಆದ್ದರಿಂದ ಚಲಾಯಿಸಲು ನಾನು ಮೇಲಿನ ಎಡಬದಿಯಲ್ಲಿನ ಪ್ಲೇ ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ, ಮತ್ತು ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ ಇಲ್ಲ. 445 00:23:54,000 --> 00:23:58,000 ನಾನು ಏನನ್ನೂ ಮಾಡಲಿಲ್ಲ, ಮತ್ತು ನಾನು ಸಿಹಿ ನೋಡುತ್ತಿರುವ ಐಫೋನ್ ಅಪ್ಲಿಕೇಶನ್ ದೊರೆತಿದೆ. 446 00:23:58,000 --> 00:24:01,000 ನಾನು ಅದನ್ನು ನಿಲ್ಲಿಸಲು ಬಯಸಿದರೆ, ನೀವು ಸ್ಟಾಪ್ ಬಟನ್ ಕ್ಲಿಕ್ಕಿಸಿ 447 00:24:01,000 --> 00:24:03,000 ಹೆಚ್ಚು ಮೋಜಿನ ಏಕೆಂದರೆ. 448 00:24:03,000 --> 00:24:07,000 >> ಲೆಟ್ಸ್ ನಾನು ಈ ಗುಂಡಿಯನ್ನು ಒತ್ತಿ ಯಾವಾಗ ಸಂಭವಿಸಬಹುದು ಏನಾದರೂ ಬಯಸುವ ಹೇಳುತ್ತಾರೆ. 449 00:24:07,000 --> 00:24:09,000 ಏನು ನಾನು ಅಗತ್ಯವಿದೆ ಎಂದು ಮಾಡಲು ನಾನು ರಚಿಸಬೇಕಾಗಿದೆ 450 00:24:09,000 --> 00:24:13,000 ಹೊಸ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಅಥವಾ ಕ್ರಿಯಾಶೀಲ. 451 00:24:13,000 --> 00:24:16,000 ಎಂದು ನಾನು ಎಂದು ಬಯಸುವ ಕೆಲವು ವಿಧಾನವನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿದೆ ಎಂದು ಅರ್ಥ 452 00:24:16,000 --> 00:24:18,000 ನಾನು ಗುಂಡಿಯನ್ನು ಒತ್ತಿ ಮಾಡಿದಾಗ, ಆದ್ದರಿಂದ ಅವರ ಒಂದು ಹೊಸ ವಿಧಾನವನ್ನು ರಚಿಸಲು ಅವಕಾಶ. 453 00:24:18,000 --> 00:24:20,000 ನಾನು ViewController.h ಒಳಗೆ ಆಗಿದ್ದೇನೆ. 454 00:24:20,000 --> 00:24:22,000 ನಾನು ವಿಧಾನ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಹೇಳುವ ಅಗತ್ಯವಿದೆ. 455 00:24:22,000 --> 00:24:26,000 ನಾನು ವೀಕ್ಷಿಸಿ ನಿಯಂತ್ರಕ ಈ ಕರೆ ವೃಂದದಲ್ಲಿರುತ್ತೇನೆ ಏಕೆಂದರೆ ನಾನು ಮೊದಲ ಕೂಡುಗೆರೆ ಅಗತ್ಯವಿದೆ. 456 00:24:26,000 --> 00:24:28,000 ನಾನು ಈ ಒಂದು ರೀತಿಯ ನೀಡಬೇಕಾಗಬಹುದು. 457 00:24:28,000 --> 00:24:31,000 ಈ ಪ್ರಕಾರ ನಾವು ಮೊದಲು ಕಂಡ ಆ IBAction ವಿಷಯ ಎಂದು ಹೋಗುತ್ತದೆ. 458 00:24:31,000 --> 00:24:35,000 ಈ ಕ್ರಿಯೆಯನ್ನು ಹ್ಯಾಂಡ್ಲರ್ ಹೊಂದಿದೆ, ಇದು ಒಂದು IBAction ಮರಳಲು ವಿಶೇಷವೇನು ಆದ್ದರಿಂದ 459 00:24:35,000 --> 00:24:38,000 ಮತ್ತು ಈ ಹೇಳುವ XCode ಒಂದು ಸುಳಿವು ಹೊಂದಿದೆ 460 00:24:38,000 --> 00:24:40,000 ನಾನು ಏನಾದರೂ 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 . ಮೀ ಕಡತದ ಒಳಗೆ ನಾನು ಅನೂರ್ಜಿತ ಹೇಳಬಹುದು ಇಲ್ಲಿ ಗಮನಿಸಿ, 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 ಈ ಪಾಪ್ಅಪ್ ಸಂದೇಶವನ್ನು ಆಗಿರಬಹುದು "ಈ ಐಒಎಸ್ ಹೊಂದಿದೆ." 487 00:26:08,000 --> 00:26:10,000 ಪ್ರತಿನಿಧಿ ವಿಷಯವೆಂದರೆ, ನಾನು ಏನು ಗೊತ್ತಿಲ್ಲ. 488 00:26:10,000 --> 00:26:13,000 ಲೆಟ್ಸ್ ಅದು ಏನನ್ನೂ ಹೇಳುವುದಿಲ್ಲ. 489 00:26:13,000 --> 00:26:18,000 ಈಗ ಕಾಣಿಸಿಕೊಳ್ಳಲು ವಿಶೇಷವೇನು ಗುಂಡಿಯನ್ನು ", ಇದು ಖಚಿತವಾಗಿ ಇದು" ಮುಂತಾದ ಏನಾದರೂ ಹೇಳಬಹುದು 490 00:26:18,000 --> 00:26:24,000 ಮತ್ತು ನಾನು ಯಾವುದೇ ಗುಂಡಿಗಳು ಬಯಸುವುದಿಲ್ಲ, ಇದರಿಂದ ಆ ಅಳಿಸಲು ಮತ್ತು ಬ್ರಾಕೆಟ್ ಮುಚ್ಚಿ ಅವಕಾಶ. 491 00:26:24,000 --> 00:26:27,000 >> ಸರಿ, ನಾನು ಒಂದು ಹೆಚ್ಚುವರಿ ಕಲ್ಪಿಸಿತು. ನಾವು ಹೋಗಿ. 492 00:26:27,000 --> 00:26:30,000 ಈ ಹೊಸ ಪಾಪ್ಅಪ್ ರಚಿಸಬಹುದು ಹೇಗೆ. 493 00:26:30,000 --> 00:26:35,000 ನಾನು ವಾಸ್ತವವಾಗಿ ಪಾಪ್ಅಪ್ ತೋರಿಸಲು ಬಯಸಿದರೆ ನಾನು ಪ್ರದರ್ಶನ ವಿಧಾನ ಕರೆಯಲು ಬಯಸುತ್ತೇನೆ. 494 00:26:35,000 --> 00:26:38,000 ನಾನು ಎಚ್ಚರಿಕೆಯನ್ನು ಮತ್ತು ಪ್ರದರ್ಶನ ಎಂದು ಹೇಳಬಹುದು ಮಾಡಲು, 495 00:26:38,000 --> 00:26:40,000 ಮತ್ತೆ, ಸ್ವಯಂ ಸೂಪರ್ ಸಂತೋಷದ ವಿಚಾರ. 496 00:26:40,000 --> 00:26:42,000 ನಾನು ಕೇವಲ ರು ಬೆರಳಚ್ಚಿಸಿದ ವೇಳೆ ಆ, ಏನು ಮರೆತುಹೋಗಿದೆ, ವೇಳೆ 497 00:26:42,000 --> 00:26:45,000 ನಾನು, ಅದು ಏನೆಂದು ಲೆಕ್ಕಾಚಾರ ಇಲ್ಲಿ ಚಲಿಸಬಹುದು 498 00:26:45,000 --> 00:26:48,000 ಮತ್ತು ಅದನ್ನು ಚೆನ್ನಾಗಿ ಶೋಧಿಸುತ್ತದೆ. 499 00:26:48,000 --> 00:26:52,000 ಈಗ ಈ ಹೊಸ ಪಾಪ್ಅಪ್ ರಚಿಸಲಾಗಿದೆ. 500 00:26:52,000 --> 00:26:55,000 ನಾವು, ನಂತರ ಪ್ರತಿನಿಧಿ ಎಂದರೆ ಏನು ಹಿಂತಿರುಗಬೇಕಾಗಿದೆ ವಿಲ್ 501 00:26:55,000 --> 00:26:58,000 ಮತ್ತು ಈಗ ನಾನು ಈ ವಿಧಾನವನ್ನು ಉಂಟಾಗದ ಬಯಸುವ ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ 502 00:26:58,000 --> 00:27:01,000 ನಾನು ಗುಂಡಿಯನ್ನು ಒತ್ತಿ ಮಾಡಿದಾಗ,, ನನ್ನ ಸ್ಟೋರಿಬೋರ್ಡ್ ಹಿಂತಿರುಗಬೇಕಾಗಿದೆ ಪಡೆಯಲಿದ್ದೇನೆ ಆದ್ದರಿಂದ 503 00:27:01,000 --> 00:27:04,000 ನಾನು ಈಗ ಈ IBAction ಲಗತ್ತಿಸಬಹುದು ಬಯಸುವ. 504 00:27:04,000 --> 00:27:06,000 ನೀವು ಬಯಸುತ್ತೀರಿ ಮೊದಲ ವಿಷಯ ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್ ಆಗಿದೆ. 505 00:27:06,000 --> 00:27:08,000 ನಾನು ಈ ಗುಂಡಿಯನ್ನು ಒತ್ತಿ ನಾನು ಸಂಭವಿಸಿ ಏನಾದರೂ ಬಯಸುವ. 506 00:27:08,000 --> 00:27:10,000 ನಾನು ಕಂಟ್ರೋಲ್ ಒತ್ತಿ ಹಿಡಿದು ವಿಶೇಷವೇನು ಇಲ್ಲ. 507 00:27:10,000 --> 00:27:13,000 ನಾನು ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಬಟನ್ ನಿಂದ ಎಳೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ 508 00:27:13,000 --> 00:27:15,000 ಇಲ್ಲಿ ಮೇಲೆ ಅಲ್ಲಿ ಇದನ್ನು ವೀಕ್ಷಿಸಿ ನಿಯಂತ್ರಕ ಹೇಳುತ್ತಾರೆ. 509 00:27:15,000 --> 00:27:17,000 ನಾವು ಚೆನ್ನಾಗಿ ಮಿಂಚುಹರಿಸುವಲ್ಲಿ ಎಂದು ನೋಡಬಹುದು. 510 00:27:17,000 --> 00:27:22,000 >> ನನ್ನ ಇಲಿಯನ್ನು ಆಗದ ನಾನು ಕೆಲವು ಆಯ್ಕೆಗಳಿವೆ ಅಲ್ಲಿ ನಾನು ಈಗ ಇಲ್ಲಿ ಈ ಪಾಪ್ಅಪ್ ಹೊಂದಿರುತ್ತವೆ. 511 00:27:22,000 --> 00:27:24,000 ಈ ಒಂದು ನಾನು ನೋಂದಾಯಿಸಿಕೊಳ್ಳಬಹುದು ಘಟನೆಗಳ ಹೊಂದಿದೆ. 512 00:27:24,000 --> 00:27:28,000 ಈ ನನ್ನ 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 ಉದಾಹರಣೆಗೆ, ಟಿಕ್ ಟಾಕ್ ಟೊ ನಾನು, 9 ಗುಂಡಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ 546 00:29:08,000 --> 00:29:11,000 ಮತ್ತು 9 ಬಾರಿ ಡ್ರ್ಯಾಗ್ ಮತ್ತು ಡ್ರಾಪ್ ಮಾಡಲು ಸೂಪರ್, ಸೂಪರ್ ಕಿರಿಕಿರಿ ಪಡುತ್ತೇವೆ 547 00:29:11,000 --> 00:29:14,000 ಅಥವಾ ನಾನು 81 ಜೊತೆ ಟಿಕ್ ಟಾಕ್ ಟೊ ಮಾಡುವ ಬದಲು 9 ಹೊಂದಿದ್ದರೆ 548 00:29:14,000 --> 00:29:17,000 ಮತ್ತು ನಾನು ಎಳೆಯಿರಿ ಮತ್ತು 81 ಪಟ್ಟು ಬಿಡಲು ಹೊಂದಿತ್ತು, ಮತ್ತು ಲೇಮ್ ಇಲ್ಲಿದೆ. 549 00:29:17,000 --> 00:29:20,000 ನಾವು ಬದಲು ಮಾಡಬಹುದು ಹೆಚ್ಚು ಒಂದು HTML ಹಾಗೆ 550 00:29:20,000 --> 00:29:23,000 ನಾವು ID ಗಳು ಮತ್ತು ಹೆಸರುಗಳು ವಿಷಯಗಳನ್ನು ಮತ್ತು ನಾವು ವಿಷಯಗಳನ್ನು ಹುಡುಕಬಹುದು ಮಾಡಿದಾಗ 551 00:29:23,000 --> 00:29:27,000 ಅವರ ಮೂಲಕ, ಟ್ಯಾಗ್ಗಳೆಂಬ ಐಒಎಸ್ ಇದೇ ರೀತಿಯ ಕಲ್ಪನೆಯನ್ನು ಇಲ್ಲ. 552 00:29:27,000 --> 00:29:31,000 >> ಒಂದು ಟ್ಯಾಗ್ ಕೇವಲ ಒಂದು ಘಟಕವನ್ನು ಒಂದು ವಿಶಿಷ್ಟ ಸಾಂಖ್ಯಿಕ ಗುರುತಿನ ಹೊಂದಿದೆ. 553 00:29:31,000 --> 00:29:34,000 ನಾನು ಈ 0 ಒಂದು ಟ್ಯಾಗ್ ಹೊಂದಿದೆ ಹೇಳಲು ವೇಳೆ, ಉದಾಹರಣೆಗೆ, 554 00:29:34,000 --> 00:29:38,000 ನಾನು ಒಂದು ಬಟನ್ ರಚಿಸಲು ಮತ್ತು 0 ಒಂದು ಟ್ಯಾಗ್ ನೀಡಲು, ಮತ್ತು ನಾವು ಎರಡನೇ ಆ ಹೇಗೆ ನೋಡುತ್ತಾರೆ ವೇಳೆ, 555 00:29:38,000 --> 00:29:41,000 ನಾನು ಗುಂಡಿಯನ್ನು ಪಡೆಯಲು ಬಯಸಿದರೆ ನಾನು ಕೇವಲ ನಾನು ಕರೆ ಬಯಸುವ ಹೇಳಬಹುದು 556 00:29:41,000 --> 00:29:45,000 ಇಲ್ಲಿ ಮೇಲೆ ವಸ್ತುವಿನ ಮೇಲೆ ವಿಧಾನ viewWithTag, 557 00:29:45,000 --> 00:29:48,000 ಉದಾಹರಣೆಗೆ ಪ್ರಸ್ತುತ ಪರದೆಯ ಪ್ರತಿನಿಧಿಸುವ self.view,,. 558 00:29:48,000 --> 00:29:53,000 ನಾನು viewWithTag ವಿಧಾನ ಕರೆ ವೇಳೆ, ನಾನು ಟ್ಯಾಗ್ 0 ಬಟನ್ ಹಿಂತೆಗೆದುಕೊಳ್ಳುವುದನ್ನು ಪಡೆಯಲಿದ್ದೇನೆ. 559 00:29:53,000 --> 00:29:58,000 ಕಟ್ಟಡ ಟಿಕ್ ಟಾಕ್ ಟೊ ಈ ಒಂದು ಗಮನಿಸೋಣ. 560 00:29:58,000 --> 00:30:01,000 ಮೊದಲ, ಈ ನನ್ನ ಸ್ಟೋರಿಬೋರ್ಡ್ ಹೊಂದಿದೆ. 561 00:30:01,000 --> 00:30:05,000 ಈ 10 UI ಗುಂಡಿಗಳು ರಚಿಸಿದ. 562 00:30:05,000 --> 00:30:07,000 ಅವರು ಒಂದೇ ಗಾತ್ರ ನೀವು ಗಮನಿಸಿ. 563 00:30:07,000 --> 00:30:11,000 ನಾನು ಈ ಒಂದು ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಈ ಬಲಭಾಗದ ಇಲ್ಲಿ ಮೇಲೆ ಹಿಂತಿರುಗಿ ವೇಳೆ 564 00:30:11,000 --> 00:30:15,000 ನೀವು, ನಾನು ಇಲ್ಲಿಯೇ ಫಾಂಟ್ ಸರಿಪಡಿಸಲಾಯಿತು, ಆದ್ದರಿಂದ ನಾನು ಸ್ವಲ್ಪ ದೊಡ್ಡ ಫಾಂಟ್ ಮಾಡಿದ ನೋಡುತ್ತಾರೆ 565 00:30:15,000 --> 00:30:19,000 ಆದರೆ ನಾನು ಏನು ಈ ಟ್ಯಾಗ್ ಸ್ಥಾಪಿಸಲಾಯಿತು. 566 00:30:19,000 --> 00:30:23,000 ಈ 1 ಒಂದು ಟ್ಯಾಗ್ ತಿಳಿಸಿದರು, ಮತ್ತು ಎಡ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಇಲ್ಲಿದೆ. 567 00:30:23,000 --> 00:30:26,000 >> ಈಗ, ನಾನು ಇನ್ನೊಂದು ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿದರೆ, ಇಲ್ಲಿ ಈ ಎರಡನೇ ರೀತಿಯಲ್ಲಿ, 568 00:30:26,000 --> 00:30:29,000 ಈಗ ನೀವು ನನ್ನ ಟ್ಯಾಗ್ 2 ಎಂದು ನೋಡುತ್ತಾರೆ. 569 00:30:29,000 --> 00:30:32,000 ಈ ಗುಂಡಿಗಳು ಪ್ರತಿ ಕೇವಲ ಒಂದು ಅನನ್ಯ ಟ್ಯಾಗ್ ಹೊಂದಿದೆ 570 00:30:32,000 --> 00:30:35,000 ಆದ್ದರಿಂದ ಈ ನಂತರ ಹೇಗೆ ನಾನು ಪರಸ್ಪರ ಆರಂಭಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಇದೆ 571 00:30:35,000 --> 00:30:38,000 ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ನೊಂದಿಗೆ. 572 00:30:38,000 --> 00:30:40,000 ಇದು, ಒಂದು ನೋಟ ನಿಯಂತ್ರಕ ಎಲ್ಲಾ ಒಳಗಿದೆ 573 00:30:40,000 --> 00:30:42,000 ಆದರೆ ಇಲ್ಲಿ ನಾವು ಏನು. 574 00:30:42,000 --> 00:30:44,000 ನಾವು ಇಲ್ಲಿ 3 ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿವೆ. 575 00:30:44,000 --> 00:30:49,000 ಮೊದಲ ಹಾಗೂ ಕೊನೆಯ ಒಂದು ನನ್ನ ಮಂಡಳಿಯ ರಾಜ್ಯ ಪ್ರತಿನಿಧಿಸಲು ಹೋಗುವ. 576 00:30:49,000 --> 00:30:53,000 ಮೂಲತಃ ಈ ಮೊದಲ ಒಂದು 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 ಮತ್ತು ವಿವಿಧ sprites ಅದೇ ಸಮಯದಲ್ಲಿ ವಿಭಿನ್ನ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಮಾಡಬಹುದು. 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 ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ರಚಿಸಲ್ಪಟ್ಟಿದೆ. 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 >> ನಾವು, ಟಿಕ್ ಟಾಕ್ ಟೊ ಆಫ್ ಲಾಜಿಕ್ ತುಂಬಾ ಒಳಗೆ ಸಿಗುವುದಿಲ್ಲ 606 00:32:26,000 --> 00:32:30,000 ಇದು ತುಂಬಾ ಉತ್ತೇಜನಕಾರಿಯಾಗಿದೆ, ಆದರೆ ಈಗ ನೋಡೋಣ ಆದರೂ 607 00:32:30,000 --> 00:32:33,000 ನಾವು ಐಒಎಸ್ ಒಳಗೆ ಮಾಡಬಹುದು ವಿಷಯಗಳ ಕೆಲವು. 608 00:32:33,000 --> 00:32:35,000 ಈ ಹೊಸ ಆಟದ ವಿಧಾನ ಕೆಲಸದಿಂದ ಏರಲಿದೆ 609 00:32:35,000 --> 00:32:37,000 ನಾನು ಹೊಸ ಆಟದ ಗುಂಡಿಯನ್ನು ಒತ್ತಿ ಮಾಡುವಾಗ. 610 00:32:37,000 --> 00:32:41,000 ನಾನು ಕೇವಲ ನನ್ನ ಕಥಾಫಲಕಕ್ಕೆ ಮೇಲೆ ಬರುವ ಸೆಳೆಯಲು. 611 00:32:41,000 --> 00:32:43,000 ನಾನು ಹೊಸ ಆಟದ ಕ್ಲಿಕ್. 612 00:32:43,000 --> 00:32:47,000 ನಾನು ಇಲ್ಲಿ ಮೇಲೆ ಬಂದರೆ ನಾನು ನೋಡಬಹುದು 613 00:32:47,000 --> 00:32:50,000 NewGame ವಿಧಾನ ಸಂಪರ್ಕಿಸಲಾಗಿತ್ತು ಇದೆ ಇನ್ಸೈಡ್ ಅಪ್ ಮುಟ್ಟಬಾರದು. 614 00:32:50,000 --> 00:32:53,000 ಈ ಕೆಲಸದಿಂದ ಕಾಣುವುದು ಏಕೆ ಆ. 615 00:32:53,000 --> 00:32:56,000 newGame ವಿಧಾನವನ್ನು ಕೆಲವು ಸೆಟ್ ಅಪ್ ಮಾಡಲು ಹೋಗುತ್ತದೆ. 616 00:32:56,000 --> 00:32:59,000 ನಾನು ನೀವು ಮಂಡಳಿಯ ರಾಜ್ಯ ತೆರವುಗೊಳಿಸಲು ನೀವು ಹೇಳಲು ವಿಶೇಷವೇನು. 617 00:32:59,000 --> 00:33:01,000 ಈ ಅಸ್ಥಿರ ಸರಣಿಗಳ ಮೇಲೆ ಒಂದು ಉತ್ತಮವಾದ ವಿಧಾನವಾಗಿದೆ. 618 00:33:01,000 --> 00:33:03,000 ಇದು, ಈಗ ಎಕ್ಸ್ ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಹೇಳುತ್ತಾರೆ ಹಾಕುತ್ತದೆ 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 ಅಥವಾ ಒಗಳನ್ನು ಬಿಡುತ್ತಾನೆ. 625 00:33:20,000 --> 00:33:24,000 ನಾನು ಟ್ಯಾಗ್ ವೀಕ್ಷಿಸಿ, 1, 2, 3, 4 ಎಟ್ ಇತ್ಯಾದಿ ಬಯಸುವ ಹೇಳಬಹುದು. 626 00:33:24,000 --> 00:33:27,000 ಈ ವಿಭಿನ್ನ ಬಟನ್ ಪ್ರತಿ ಬಾರಿ ಪುಲ್ ಕಾಣಿಸುತ್ತದೆ. 627 00:33:27,000 --> 00:33:30,000 ಇಲ್ಲಿ ನಾನು UIButton ಅದನ್ನು ಎರಕ ಪಡೆಯಲಿದ್ದೇನೆ. 628 00:33:30,000 --> 00:33:33,000 ನಾವು ಫ್ಲೋಟ್ಗಳು ಮತ್ತು ಪ್ರತಿಕ್ರಮದಲ್ಲಿ ಗೆ ints ಪಾತ್ರ ಎಂದು ಕೇವಲ ರೀತಿಯಲ್ಲಿ 629 00:33:33,000 --> 00:33:37,000 ಈ ನಾನು UIButton ಈ ಪಾತ್ರ ಬಯಸುವ ಹೇಳುತ್ತಾರೆ. 630 00:33:37,000 --> 00:33:40,000 ಅಂದರೆ ಈ ರೀತಿಯ ಒಂದು UIButton * ಎಂದು 631 00:33:40,000 --> 00:33:43,000 ಏಕೆಂದರೆ ಪಾಯಿಂಟರ್ಗಳ, ಆದರೆ ಚಿಂತಿಸಬೇಡಿ, ಅವರು ಎಂದಿಗೂ ಭಯಾನಕ ಅಲ್ಲ. 632 00:33:43,000 --> 00:33:47,000 >> ಒಮ್ಮೆ ನಾನು ಒಂದು ವಿಧಾನವನ್ನು ಕರೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ ಈ ಬಟನ್ ಹೊಂದಿರುತ್ತವೆ. 633 00:33:47,000 --> 00:33:50,000 ಈ ವಿಧಾನವನ್ನು setTitle forState ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಈ ಹೇಳುತ್ತಾರೆ 634 00:33:50,000 --> 00:33:53,000 ನಾನು, ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಬಟನ್ ಪಠ್ಯ ಹೊಂದಿಸಲು ಬಯಸುವ 635 00:33:53,000 --> 00:33:57,000 ಮತ್ತು ನಾನು ಅದು ಒತ್ತದೇ ಸಂದರ್ಭದಲ್ಲಿ ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಬಯಸುವ. 636 00:33:57,000 --> 00:34:01,000 ಈ ವಿಧಾನವನ್ನು ಬಳಸಿ ಭಾವಿಸುತ್ತೇನೆ ವೇಳೆ, ನಾನು ಬಟನ್ ಪಠ್ಯ ಬದಲಾಯಿಸಬಹುದು 637 00:34:01,000 --> 00:34:04,000 ಯಾರಾದರೂ ಹೊಡೆದರೆ, ಆದರೆ ಬಟನ್ ಕೇವಲ ಕುಳಿತುಕೊಂಡು ಮಾಡಿದಾಗ ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ ಬೇಗ 638 00:34:04,000 --> 00:34:07,000 ನಾನು ಪಠ್ಯ ಖಾಲಿ ಬಯಸುತ್ತೇನೆ. 639 00:34:07,000 --> 00:34:10,000 ಅಂತಿಮವಾಗಿ, ನಾವು, ನನ್ನ ಬೋರ್ಡ್ ಆರಂಭಿಸಲು ನೀನು 640 00:34:10,000 --> 00:34:12,000 ಮತ್ತು ನಾನು, ಎಲ್ಲವನ್ನೂ 0 ಪ್ರಸ್ತುತ ಎಂದು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ 641 00:34:12,000 --> 00:34:15,000 ಈ ಬೋರ್ಡ್ ಆದ್ದರಿಂದ ಸದಸ್ಯರು ನಿರ್ವಿಕಾರ, ಒಂದು ಅಸ್ಥಿರ ರಚನೆ 642 00:34:15,000 --> 00:34:21,000 ಇದು ನಾನು addObject ವಿಧಾನ ಮತ್ತು ಅದು ಕೇವಲ ಒಂದು 0 ಒಳಗೆ ಕರೆ ಎಂದರ್ಥ. 643 00:34:21,000 --> 00:34:23,000 ನಾನು ಹೊಸ ಗೇಮ್ ಏನಾಗುತ್ತದೆ ಇಲ್ಲಿದೆ. 644 00:34:23,000 --> 00:34:25,000 >> ನ ಮತ್ತೊಂದು ಒಂದು ಗಮನಿಸೋಣ. 645 00:34:25,000 --> 00:34:28,000 ಇಲ್ಲಿ ಈ ವಿಧಾನವನ್ನು ಒತ್ತಲು ಅನುಕೂಲವಾಗುವಂತೆ ವಿಶೇಷವೇನು ಎಂದು IBAction ಆಗಿದೆ 646 00:34:28,000 --> 00:34:31,000 ಪ್ರತಿ ಬಾರಿ ಆ ಚೌಕಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಒತ್ತಿದರೆ. 647 00:34:31,000 --> 00:34:33,000 ಈಗ ನಾವು ಕೆಲವು ಟಿಕ್ ಟಾಕ್ ಟೊ ತರ್ಕ ಇಲ್ಲಿ ಹೊಂದಿವೆ. 648 00:34:33,000 --> 00:34:36,000 ನಾವು ಇದರ ಪ್ರತಿಯಾಗಿ ಅದು ಔಟ್ ಲೆಕ್ಕಾಚಾರ 649 00:34:36,000 --> 00:34:39,000 ಮತ್ತು, ನಾವು ಎರಡೂ ಒಂದು X ಅಥವಾ O ಸೆಟ್ ಆಧರಿಸಿದೆ 650 00:34:39,000 --> 00:34:43,000 ಆದರೆ ನಾವು ಅದೇ ಕ್ರಿಯೆಯನ್ನು ಹ್ಯಾಂಡ್ಲರ್ ಮರುಪಯೊಗದಿಂದ ಎಂಬುದನ್ನು ಗಮನಿಸಿ 651 00:34:43,000 --> 00:34:45,000 ಆ ಗುಂಡಿಗಳು ಪ್ರತಿಯೊಂದು ಒಂದು. 652 00:34:45,000 --> 00:34:49,000 ನಾನು ಮೇಲಿನ ಎಡ ಬಟನ್ ವಿಧಾನವನ್ನು ಹೊಂದಿಲ್ಲ ಎಂದರ್ಥ, 653 00:34:49,000 --> 00:34:52,000 ನಾನು ಕೆಳಗೆ ಬಲ ಗುಂಡಿಯನ್ನು ಬೇರೆ ವಿಧಾನವನ್ನು ಎಂದು ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ಕಂಡುಬರುತ್ತವೆ. 654 00:34:52,000 --> 00:34:54,000 ನಿಜಕ್ಕೂ ಉತ್ತಮ ವಿನ್ಯಾಸ ನೆರವೇರಿಸಲಾಯಿತು. 655 00:34:54,000 --> 00:34:57,000 ನಾನು ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವೆ ನಾನು ನಿರ್ಧರಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಆಗಿದೆ 656 00:34:57,000 --> 00:35:00,000 ಒತ್ತಿದರೆ ಆ ಗುಂಡಿಯನ್ನು ಟ್ಯಾಗ್ ಏನು. 657 00:35:00,000 --> 00:35:04,000 ಈ ಆಟದ ವಿಧಾನ ಒಂದು ವಾದವು ನಡೆಯುತ್ತದೆ ಎಂದು ಗಮನಿಸಿ. 658 00:35:04,000 --> 00:35:07,000 ಇದು ಕಳುಹಿಸುವವರ ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಕಳುಹಿಸುವವರು ಕಳುಹಿಸುವವರ ಹೋಗುವ ಇದೆ ಇದೆ ಇದೆ 659 00:35:07,000 --> 00:35:10,000 ನಿಖರವಾಗಿ ಮೇಲೆ ಕ್ರಮ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ ಎಂಬುದನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ. 660 00:35:10,000 --> 00:35:15,000 ನಾನು ಒಂದು ಬಟನ್ ಒತ್ತಿದಾಗ, ಈ ಕಳುಹಿಸುವವರ ಎಂದು UIButton ಏರಲಿದೆ 661 00:35:15,000 --> 00:35:18,000 ನಾನು ವಾಸ್ತವವಾಗಿ ಒತ್ತುವುದಕ್ಕಾಗಿ, ಆದ್ದರಿಂದ ಅಂದರೆ ಆ UIButton 662 00:35:18,000 --> 00:35:20,000 ನಾನು ಟ್ಯಾಗ್ ರಚಿಸಿರುವುದರಿಂದ ಒಂದು ಟ್ಯಾಗ್ ಹೊಂದಿದೆ. 663 00:35:20,000 --> 00:35:23,000 >> ನಾನು ಟ್ಯಾಗ್ ನಲ್ಲಿ ಪಡೆಯಲು ಬಯಸಿದರೆ ನಾನು ಸರಳವಾಗಿ ಹೇಳಬಹುದು 664 00:35:23,000 --> 00:35:26,000 ನಾನು, ಕಳುಹಿಸುವವರ ಆಫ್ ಟ್ಯಾಗ್ ಬಯಸುವ 665 00:35:26,000 --> 00:35:28,000 ಮತ್ತೆ, ನಾನು ಒಂದು 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 ಮತ್ತು ಟ್ಯಾಗ್ ನಾನು ಈಗ ನಾನು ಮಂಡಳಿಯ ಒಳಗೆ am ಅಲ್ಲಿ ತಿಳಿದಿದೆ. 673 00:35:48,000 --> 00:35:51,000 ಆಗ ನಾನು ಕೇವಲ X ಅಥವಾ O, ತಿರುವು ಮಿಡಿ ಮಾಡಬಹುದು, ಅಥವಾ ಹೊಂದಿಸಬಹುದು 674 00:35:51,000 --> 00:35:54,000 , ಎಟ್ ಇತ್ಯಾದಿ ಗಳಿಸಿದ ಪರಿಶೀಲಿಸಿ. 675 00:35:54,000 --> 00:35:59,000 >> ಈ ಇಲ್ಲಿಯವರೆಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? 676 00:35:59,000 --> 00:36:02,000 ಸರಿ, ನಾವು ಆನ್ಲೈನ್ ನಾವು ತುಂಬಾ ಬರಲು ಬಯಸುವುದಿಲ್ಲ ಪೋಸ್ಟ್ ಎಲ್ಲಾ ಕೋಡ್ 677 00:36:02,000 --> 00:36:06,000 ಟಿಕ್ ಟಾಕ್ ಟೊ ತರ್ಕದ, ಆದರೆ ಈಗ ನೀವು ನಿಜಕ್ಕೂ ನೋಡಬಹುದು 678 00:36:06,000 --> 00:36:09,000 ನಾವು ಮಾಡುತ್ತಿರುವುದು ಎಲ್ಲಾ, ಈ ರಚನೆಯ ಮೇಲೆ ಲೂಪ್ ನೀವು ಆಗಿದೆ 679 00:36:09,000 --> 00:36:13,000 ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಕುಣಿಕೆಗಳು ಗಾಗಿ ಒಂದೆರಡು ಹೊಂದಿವೆ, ಮತ್ತು ನಾವು ನೋಡಲು ಹೋಲಿಸುವ ನೀವು 680 00:36:13,000 --> 00:36:18,000 ನಾವು ಎಲ್ಲಾ ಸಾಲುಗಳು, ಹಾಗೆ ಒಂದು ಕಾಲಮ್ ಅಥವಾ ಏನು ಒಂದು ಪಂದ್ಯದಲ್ಲಿ ಒಂದು ಪಂದ್ಯದಲ್ಲಿ ಹೊಂದಿಲ್ಲ. 681 00:36:18,000 --> 00:36:21,000 ಈ ಗುಂಡಿಗಳು ಒಂದು ಸ್ಪರ್ಶಿಸಿ ವೇಳೆ ವಾಸ್ತವವಾಗಿ, ಈ ಅಪ್ಲಿಕೇಶನ್ ಚಲಾಯಿಸಲು 682 00:36:21,000 --> 00:36:24,000 ಆ ಆಟದ ವಿಧಾನ ಉರಿಸಲಾಯಿತು, ನಾನು ಸೆಟ್ ಎಂದರೆ ಎಷ್ಟು 683 00:36:24,000 --> 00:36:31,000 ಬಟನ್ ಒಂದು X ಎಂದು, ಆದ್ದರಿಂದ ಈಗ ಈ ಬಟನ್, ಒ, ಮತ್ತು ಹೀಗೆ ಕಾಣಿಸುತ್ತದೆ 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 ಟಿಕ್ ಟಾಕ್ ಟೊ ಎಂದು ಉತ್ತೇಜಕ ಐಒಎಸ್ ಒಳಗೆ, ಅಪ್ಲಿಕೇಶನ್ಗಳು ಸಾಕಷ್ಟು ಆಗಿತ್ತು 688 00:36:47,000 --> 00:36:50,000 ಈ DRILL ರೀತಿಯ ಅನೇಕ ಸ್ಕ್ರೀನ್ಗಳು ಕೆಲಸಗಳನ್ನು ಕೆಳಗೆ ಇವೆ. 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 ಈ ವಿಧಾನಗಳ ಕೆಲವು, ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ವೇಳೆ ಹೇಳುತ್ತಾರೆ 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 ಐಒಎಸ್ ಒಳಗೆ ಅಂಶಗಳು ಬಹಳಷ್ಟು ಈ ಲಾಭ 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 >> ನನ್ನ. ಮೀ ಕಡತದಲ್ಲಿ ಇಲ್ಲಿ ಬಂದರೆ, ನಾನು ಒಂದು ರೀತಿಯ ವಿಧಾನವನ್ನು ಜಾರಿಗೆ ತಂದಿವೆ. 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 ವಿವಿಧ ಐಒಎಸ್ ಘಟಕಗಳ ರೀತಿಯಲ್ಲಿ ಘಟನೆಗಳು ನೋಂದಾಯಿಸಲು. 770 00:41:27,000 --> 00:41:29,000 ಗುಂಡಿಗಳು, ಉದಾಹರಣೆಗೆ, ಆ IBActions ಬಳಸಿ. 771 00:41:29,000 --> 00:41:32,000 ಪಠ್ಯ ಜಾಗ, ಮತ್ತೊಂದೆಡೆ, ಪ್ರತಿನಿಧಿಗಳು ಬಳಸಲು ಹೋಗುವ. 772 00:41:32,000 --> 00:41:36,000 ನಾವು ನೋಡಬಹುದು ಮತ್ತು ನೀವು ದಸ್ತಾವೇಜನ್ನು ಆ ಅಪ್ ಒಳಗೆ ಎಲ್ಲಾ ನೋಡಬಹುದು. 773 00:41:36,000 --> 00:41:41,000 ಮೂಲಕ, ನೀವು ಐಒಎಸ್ ನಿರ್ಮಿಸಲಾಗಿರುವ UI ವಿಷಯವನ್ನು ಒಂದು ಟನ್, ವಾಸ್ತವವಾಗಿ ಇಲ್ಲ 774 00:41:41,000 --> 00:41:46,000 ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ರೀತಿಯಲ್ಲಿ ನಾನು ಕೆಳಗೆ ಬಲಭಾಗದಲ್ಲಿ ಇದನ್ನು ಹೇಳಿದ್ದಾರೆ ಎಂದು ಮಾಡಿದ 775 00:41:46,000 --> 00:41:48,000 ಈ ಪಠ್ಯ ಕ್ಷೇತ್ರದಲ್ಲಿ ಆಯ್ಕೆ ಇದೆ. 776 00:41:48,000 --> 00:41:50,000 ನಾನು ಇಲ್ಲಿ ಮೇಲೆ ಬಂದಿತು. 777 00:41:50,000 --> 00:41:53,000 ನಾನು, ಕೀಲಿ ಮರಳಲು ಸ್ವಲ್ಪ ಸುರುಳಿಕೆಲಸ 778 00:41:53,000 --> 00:41:56,000 ನಾನು ಹೇಳಲು ಎಂದು ಬಯಸಿದರೆ, ಮತ್ತು ನಾನು, ಈ ವಸ್ತುಗಳ ಇಡೀ ಗುಂಪೇ ಮಾಡಬಹುದು 779 00:41:56,000 --> 00:42:00,000 ತುರ್ತು ಬದಲಿಗೆ ನಾನು ಸಂಪೂರ್ಣವಾಗಿ ಯಾದೃಚ್ಛಿಕ ಇದು, ಹಾಗೆ ಮಾಡಬಹುದು ಕರೆ 780 00:42:00,000 --> 00:42:02,000 ಒಂದು ಅಂತರ್ನಿರ್ಮಿತ ತುರ್ತು ಕರೆ ಬಟನ್ ಇಲ್ಲ ಏಕೆ ಮತ್ತು ನಾನು, ಗೊತ್ತಿಲ್ಲ 781 00:42:02,000 --> 00:42:06,000 ಆದರೆ, ನಿಜವಾಗಿಯೂ ಸಣ್ಣ ಅಕ್ಷರಗಳಲ್ಲಿ ತುರ್ತು ಕರೆ ಇದು ಹೇಳುತ್ತದೆ. 782 00:42:06,000 --> 00:42:08,000 ಅಲ್ಲಿ ನೀವು ಹೋಗಿ. 783 00:42:08,000 --> 00:42:12,000 >> ಖಂಡಿತವಾಗಿಯೂ ಐಒಎಸ್ ಈ ವಿವಿಧ ಆಯ್ಕೆಗಳನ್ನು ಎಲ್ಲಾ ಅನ್ವೇಷಿಸಬಹುದು. 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 ಒಂದು ಟೇಬಲ್ ವೀಕ್ಷಿಸಿ ಮೂಲಭೂತವಾಗಿ ಎಲ್ಲಾ ಐಒಎಸ್ ಸ್ಥಾನ ಮೀರಿದೆ ಐಟಂಗಳ ಎಂದು ಪಟ್ಟಿ. 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 ಐಒಎಸ್ ಒಂದು ಟೇಬಲ್ ವೀಕ್ಷಿಸಿ ಅನುಷ್ಠಾನಕ್ಕೆ ಬಹಳ ಸರಳವಾಗಿದೆ. 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: tableView ಕರೆಯಲಾಗುತ್ತದೆ. 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 ಐಒಎಸ್ ತಿಳಿಯಲು ಅಗತ್ಯವಿರುವ ಮುಂದಿನ ಪ್ರಶ್ನೆಗೆ ನೀವು ಎಷ್ಟು ಸಾಲುಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ ಹೊಂದಿದೆ? 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 ಮತ್ತು ಆದ್ದರಿಂದ ಐಒಎಸ್ ಪ್ರದರ್ಶಿಸಲು ಎಷ್ಟು ಜೀವಕೋಶಗಳು ತಿಳಿದಿರುವ ಹೇಗೆ. 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 ಅಂತಿಮವಾಗಿ, ಐಒಎಸ್, ಪ್ರತಿ ಜೀವಕೋಶ ತೋರುತ್ತಿದೆ ಏನೆಂಬುದನ್ನು ತಿಳಿಯುವುದು ಅಗತ್ಯ 815 00:43:52,000 --> 00:43:54,000 ಹಾಗಾಗಿ ಇದು ವಾಸ್ತವವಾಗಿ ಮಾಡಲು ವಿಶೇಷವೇನು, ಕೆಳಗೆ ಇಲ್ಲಿ ಈ ವಿಧಾನವನ್ನು ಕಾಲ್ ಆಗಿದೆ 816 00:43:54,000 --> 00:43:57,000 ಈ tableView: cellForRowAtIndexPath. 817 00:43:57,000 --> 00:44:01,000 ನಿಮ್ಮ ಮೇಜಿನ ಒಳಗೆ ಪ್ರತಿಯೊಂದು ಜೀವಕೋಶದ ಮೇಲೆ ಈ ವಿಧಾನ ಕರೆಯಲು ವಿಶೇಷವೇನು. 818 00:44:01,000 --> 00:44:03,000 ಹೇಗೆ ಅದನ್ನು ಕರೆಯಲು ಎಷ್ಟು ಬಾರಿ ತಿಳಿದಿದೆಯೇ? 819 00:44:03,000 --> 00:44:06,000 ಅಲ್ಲದೆ, ನೀವು ವಿಭಾಗದಲ್ಲಿ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯ ಒಳಗೆ ಅದನ್ನು ತಿಳಿಸಿದರು. 820 00:44:06,000 --> 00:44:08,000 ನಾವು, ನಮ್ಮ ಕೋಶಗಳ ಪ್ರತಿ ಈ ಕರೆಯಲು ನೀನು 821 00:44:08,000 --> 00:44:11,000 ನೀವು ನಿಜವಾಗಿಯೂ ವಿಷಯಗಳನ್ನು ಮಾಡಬಹುದು ಅಲ್ಲಿ ಮತ್ತು ಒಳಗೆ ಈ ಹೊಂದಿದೆ 822 00:44:11,000 --> 00:44:16,000 ಪಠ್ಯ ಸೆಟ್ ಅಥವಾ ಬಲಭಾಗದ ಮೇಲೆ ಸ್ವಲ್ಪ ನೀಲಿ ಬಟನ್ ಏನು ಹೇಳಲು. 823 00:44:16,000 --> 00:44:19,000 ಈ ಜೀವಕೋಶಗಳು ಪಡೆಯಲು ಮಾದರಿಯಲ್ಲಿ, ನಾವು ಈ ವಿಧಾನವನ್ನೇ ನೀನು 824 00:44:19,000 --> 00:44:22,000 dequeueReusableCellWithIdentifier ಕರೆಯಲಾಗುತ್ತದೆ. 825 00:44:22,000 --> 00:44:29,000 >> ವಸ್ತುನಿಷ್ಠ-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 ಕೇವಲ ಒಂದು ಐಒಎಸ್ ವಿಷಯ. 829 00:44:39,000 --> 00:44:41,000 ನಿಮ್ಮ ಐಪಾಡ್ ಮೇಲೆ 100,000 ಹಾಡುಗಳ ರೀತಿಯ ಹೊಂದಿದ್ದರೆ 830 00:44:41,000 --> 00:44:45,000 ಯಾವ ಐಒಎಸ್ ಮಾಡಲು ಬಯಸುವುದಿಲ್ಲ, 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 ನೀವು ಪಠ್ಯ ಲೇಬಲ್ ಎಂದು ಈ ಆಸ್ತಿಯ ಜೀವಕೋಶದ ಪಠ್ಯ ಹೊಂದಿಸಬಹುದು. 847 00:45:32,000 --> 00:45:36,000 ನೀವು ಬಲ ಅಥವಾ ಕೆಲವು ಇತರ ಯಾದೃಚ್ಛಿಕ ವಿಷಯವನ್ನು ಆ ಬಾಣದ ಸೇರಿಸಬಹುದು 848 00:45:36,000 --> 00:45:41,000 ಈ ಇತರ ಆಸ್ತಿಯ accessoryType ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಇನ್ನೂ ಮುಂತಾದವು. 849 00:45:41,000 --> 00:45:46,000 >> ನ ವಾಸ್ತವವಾಗಿ ಈಗ ಟೇಬಲ್ ವೀಕ್ಷಿಸಿ ಅನುಷ್ಠಾನಗೊಳಿಸುವ ಒಂದು ಗಮನಿಸೋಣ. 850 00:45:46,000 --> 00:45:49,000 ನಾನು ಈ ಯೋಜನೆಯನ್ನು ರಚಿಸಿದಾಗ 851 00:45:49,000 --> 00:45:53,000 ಬದಲಿಗೆ ಏಕ ನೋಟ ಅಪ್ಲಿಕೇಶನ್ ಹೇಳುವ ಹೆಚ್ಚು ನಾನು ವಾಸ್ತವವಾಗಿ ಇಲ್ಲಿ ಮೇಲೆ ಬಂದ 852 00:45:53,000 --> 00:45:57,000 ಆಚಾರ್ಯ ವಿವರ ಅನ್ವಯವನ್ನು, ಮತ್ತು ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ ಈ ಮೇಲ್ ಅಪ್ಲಿಕೇಶನ್ ಸೂಚಿಸುತ್ತದೆ 853 00:45:57,000 --> 00:46:01,000 ಎಡಭಾಗದಲ್ಲಿರುವ ಪಟ್ಟಿ ವೀಕ್ಷಣೆ ಮತ್ತು ನಂತರ ಬಲಭಾಗದಲ್ಲಿ ವಿಷಯಗಳ ಐಪ್ಯಾಡ್ ಮೇಲೆ. 854 00:46:01,000 --> 00:46:07,000 ಐಪಾಡ್ ಅಥವಾ ಐಫೋನ್ ಈ ಒಂದು ಟೇಬಲ್ ವೀಕ್ಷಿಸಿ ಹೋಲುತ್ತದೆ ಹೋಗುತ್ತದೆ. 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 ನಾನು ಪ್ರತಿ ಹಣ್ಣಿನ ಒಂದು ಸಾಲನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ಈ ಎಣಿಕೆ 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 >> ಮತ್ತೆ, ಈ ಐಒಎಸ್ ನನಗೆ ಮಾಡುತ್ತಿರುವ ವಿಷಯ. 910 00:48:53,000 --> 00:48:55,000 ಮತ್ತೊಂದು ತ್ರಾಸದಾಯಕ ಪಾಪ್ಅಪ್ ಪ್ರದರ್ಶಿಸಲು ಲೆಟ್ಸ್ 911 00:48:55,000 --> 00:48:59,000 ಎಂದು ಸರಳವಾಗಿ ನೀವು ಅಲ್ಲಿ ವಿಷಯ ಏನೋ ಆಯ್ಕೆ ಹೇಳುತ್ತಾರೆ 912 00:48:59,000 --> 00:49:04,000 ಸಾಲು ವಿಷಯವಾಗಿ ಹೋಗುತ್ತದೆ. 913 00:49:04,000 --> 00:49:10,000 ನಾನು ಈ ರನ್, ನಾನು ಈ ಸಂತೋಷವನ್ನು ಟೇಬಲ್ ವೀಕ್ಷಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ 914 00:49:10,000 --> 00:49:14,000 ಈ ಹಣ್ಣಿನ ಪ್ರತಿಯೊಂದು ಒಂದು ಸಾಲು ಜೊತೆಗೆ, ಮತ್ತು ನಾನು ಒಂದು ಸ್ಪರ್ಶಿಸಿ 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 ಸ್ಟೋರಿಬೋರ್ಡಿಂಗ್ನ ಬಗ್ಗೆ ಸಂತೋಷವನ್ನು ಭಾಗ 920 00:49:31,000 --> 00:49:35,000 ಕೇವಲ, ವೈಯಕ್ತಿಕವಾಗಿ ನಮಗೆ ವಿನ್ಯಾಸ ಸ್ಕ್ರೀನ್ಗಳು ಸಹಾಯ ಹಿಂದಿರುಗಬಹುದೆಂದು ಇದೆ 921 00:49:35,000 --> 00:49:38,000 ಇದು, ನಮ್ಮ ಸಂಪೂರ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಒಟ್ಟಿಗೆ ಟೈ ಸಹಾಯ ವಿಶೇಷವೇನು 922 00:49:38,000 --> 00:49:42,000 ಆದ್ದರಿಂದ ನಾವು ಕಟ್ಟಡ ಇರುವಿರಿ ಅಂತಿಮ ಅಪ್ಲಿಕೇಶನ್, ಈ ಸಂತೋಷವನ್ನು ಕ್ರೀಡೆ ನ್ಯೂಸ್ ರೀಡರ್ ಆಗಿದೆ 923 00:49:42,000 --> 00:49:45,000 ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಅನೇಕ ಸ್ಕ್ರೀನ್್ಗಳು ಹೋಗುವುದಿಲ್ಲ, ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ವಾಸ್ತವವಾಗಿ ಪ್ರತಿನಿಧಿಸಬಹುದು 924 00:49:45,000 --> 00:49:48,000 ಸ್ಟೋರಿಬೋರ್ಡ್ ಈ ಬಹು ಪರದೆಯ ಪ್ರತಿ, 925 00:49:48,000 --> 00:49:52,000 ನಾನು ಔಟ್ ಜೂಮ್ ಮತ್ತು ಉನ್ನತ ಮಟ್ಟದ ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ ನೋಡಬಹುದು. 926 00:49:52,000 --> 00:49:55,000 >> ನನ್ನ ಸ್ಟೋರಿಬೋರ್ಡ್ ಹೊಸ ಅಂಶ ಒಳಗೆ ರಚಿಸಲು 927 00:49:55,000 --> 00:49:59,000 ಇದು ಇಂಟರ್ಫೇಸ್ ಬಿಲ್ಡರ್ ಒಳಗೆ ನಿಜವಾಗಿಯೂ ಸರಳ. 928 00:49:59,000 --> 00:50:01,000 ನಾನು ಈ ಇನ್ನೊಂದು ತೆರೆಯ ಸೇರಿಸಲು ಬಯಸಿದರೆ, ಉದಾಹರಣೆಗೆ, 929 00:50:01,000 --> 00:50:06,000 ನಾನು ಮೊದಲ, ಆಪಲ್ ತುಂಬಾ ಇಷ್ಟಪಡುತ್ತೇನೆ ಪಿಂಚ್ ಝೂಮ್ ಔಟ್ ಝೂಮ್ ಮಾಡಬಹುದು 930 00:50:06,000 --> 00:50:09,000 ಮತ್ತು ಕೆಳಗೆ ಇಲ್ಲಿ ನಾನು ಬಟನ್ ಹುಡುಕಲು ಮೊದಲು 931 00:50:09,000 --> 00:50:12,000 ಮತ್ತು ನಾನು ಒಂದು ಗುಂಡಿಯನ್ನು ಎಳೆಯಿರಿ ಮತ್ತು ಬಿಡಿ 932 00:50:12,000 --> 00:50:15,000 ನಾನು ಹೊಸ ಸ್ಕ್ರೀನ್ ರಚಿಸಲು ಬಯಸುವ ವೇಳೆ ನಾನು ವಾಸ್ತವವಾಗಿ ಕೇವಲ ಡ್ರ್ಯಾಗ್ ಮತ್ತು ಡ್ರಾಪ್ ಮಾಡಬಹುದು 933 00:50:15,000 --> 00:50:19,000 ಸಂಪೂರ್ಣ ವೀಕ್ಷಿಸಿ ನಿಯಂತ್ರಕ, ನಾನು ಈ ಆಯ್ಕೆ ಹಾಗಾಗಿ, ಇಲ್ಲಿ ಅದನ್ನು ಎಳೆಯಲು 934 00:50:19,000 --> 00:50:23,000 ಹೇ, ಅಲ್ಲಿ ಮತ್ತೊಂದು ಸ್ಕ್ರೀನ್, ಮತ್ತು ಆದ್ದರಿಂದ ಈಗ ಇದೇ ಸ್ಟೋರಿಬೋರ್ಡ್ ಫೈಲ್ ಬಳಸಿ 935 00:50:23,000 --> 00:50:26,000 ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ ಒಳಗೆ ಪರದೆಯ ಎಲ್ಲಾ ಹೊಂದಿರುತ್ತವೆ, ಮತ್ತು ನಾನು ಔಟ್ ಝೂಮ್ ಮಾಡಬಹುದು 936 00:50:26,000 --> 00:50:28,000 ಮತ್ತು ಅವರು ಪರಸ್ಪರ ಹೇಗೆ ನೋಡಿ. 937 00:50:28,000 --> 00:50:32,000 ಈ ಇನ್ನೂ ಪರಸ್ಪರ ಮಾಡುವುದಿಲ್ಲ. 938 00:50:32,000 --> 00:50:36,000 ಈ 2 ಸ್ಕ್ರೀನ್ಗಳು ಸಂವಹನ ವಿಧಾನವನ್ನು ನೀವು ಸಂಬಂಧಗಳು ವ್ಯಾಖ್ಯಾನಿಸುವ ಹೊಂದಿದೆ. 939 00:50:36,000 --> 00:50:39,000 ನೀವು ಮೂಲತಃ, ಈ ಗುಂಡಿಯನ್ನು ಒತ್ತಿ, ಈ ತೆರೆಯಲ್ಲಿ ಹೇಳಬಹುದು 940 00:50:39,000 --> 00:50:42,000 ನಾನು ಈ ಹೊಸ ತೆರೆಗೆ ಮೇಲೆ ಸ್ಲೈಡ್ ಬಯಸುವ. 941 00:50:42,000 --> 00:50:44,000 ಅರ್ಥ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಈ ರೀತಿಯ ಇಲ್ಲ 942 00:50:44,000 --> 00:50:46,000  ಮೊದಲ ಸ್ಕ್ರೀನ್ ಮತ್ತು ಎರಡನೇ ಸ್ಕ್ರೀನ್. 943 00:50:46,000 --> 00:50:49,000 ನೀವು ಮೂಲತಃ ಗುಂಡಿಯನ್ನು ಎರಡನೇ ತೆರೆಗೆ ಬಾಣ ನಿಮಗಿದೆ 944 00:50:49,000 --> 00:50:53,000 ನಾನು ಹೋಗಿ ಬಯಸುವ ಅಲ್ಲಿ ನೀವು ಈ ಗುಂಡಿಯನ್ನು ಒತ್ತಿ ಆ ಎಂದು ಹೇಳಿದರು. 945 00:50:53,000 --> 00:50:57,000 ನಾವು ಕ್ಲಿಕ್ ಮತ್ತು ಆ ಮಳಿಗೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಎಳೆದಿದ್ದೀರಿ ಕಂಟ್ರೋಲ್ ಕೇವಲ ಹಾಗೆ 946 00:50:57,000 --> 00:51:01,000 ನಾವು ಈ segues ವ್ಯಾಖ್ಯಾನಿಸಲು ಒಂದೇ ವಿಷಯವನ್ನು ನೀನು. 947 00:51:01,000 --> 00:51:05,000 >> ನಾವು ಒಂದು ಉದಾಹರಣೆಗೆ ನೋಡಿ, ನಾವು ವಾಸ್ತವವಾಗಿ ಪರಿವರ್ತನೆಯನ್ನು ಮೊದಲು ವಿಲ್ 948 00:51:05,000 --> 00:51:08,000 ಒಂದು ಸ್ಕ್ರೀನ್ ಇನ್ನೊಂದಕ್ಕೆ ಐಒಎಸ್ ಈ ವಿಧಾನವನ್ನು ಕರೆ ಸಾಕಷ್ಟು ಸಂತೋಷ 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 >> ಅಂತಿಮವಾಗಿ, ಐಒಎಸ್ ಮೇಲೆ ಕೇವಲ ಒಂದು ಯಾದೃಚ್ಛಿಕ ಪಾಯಿಂಟ್. 959 00:51:39,000 --> 00:51:41,000 ನೀವು ದತ್ತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು ಬಯಸಿದರೆ ಕೋರ್ ಅಕ್ಷಾಂಶ ಎಂಬ ಈ ವಿಷಯ ಇಲ್ಲ 960 00:51:41,000 --> 00:51:44,000 ಇದು ನಿಜವಾಗಿಯೂ ಕೆಲಸ ಜಟಿಲವಾಗಿದೆ ಬಗೆಯಾಗಿದೆ. 961 00:51:44,000 --> 00:51:47,000 ನೀವು, ದತ್ತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು SQL ಬಳಸಬಹುದು 962 00:51:47,000 --> 00:51:51,000 ಇದು ಮತ್ತೊಮ್ಮೆ, ಕೆಲಸ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಭಾಗದಲ್ಲಿ ಸಂತೋಷವನ್ನು ಆದರೆ ರೀತಿಯ ಹೊಂದಿದೆ 963 00:51:51,000 --> 00:51:55,000 ಆದರೆ ಐಒಎಸ್ ಸಹ, ಆಸ್ತಿ ಪಟ್ಟಿಗಳನ್ನು ಎಂಬ ಈ ನಿಜವಾಗಿಯೂ ತಂಪಾದ ವಿಷಯಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ 964 00:51:55,000 --> 00:52:00,000 ಮತ್ತು ಒಂದು ಆಸ್ತಿಯ ಪಟ್ಟಿಯಲ್ಲಿ ಕೇವಲ ಕೀಲಿ ಮೌಲ್ಯವನ್ನು ಜೋಡಿ ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಕಡತವಾಗಿರುತ್ತದೆ. 965 00:52:00,000 --> 00:52:03,000 ನೀವು ಕೀಲಿಗಳು ಪಟ್ಟಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು, ಮತ್ತು ನೀವು ಈ ಕೀಲಿಯನ್ನು ಸರಣಿಯಾಗಿರಬೇಕು ಹೋಗಿ ಹೇಳುತ್ತಾರೆ. 966 00:52:03,000 --> 00:52:06,000 ಈ ಕೀಲಿಯನ್ನು ಮೂಲತಃ ನೀವು ಮಾಡಬಹುದು ಏನು ಸ್ಟ್ರಿಂಗ್ ಹೋಗುವ, ಮತ್ತು 967 00:52:06,000 --> 00:52:10,000 JSON ರಲ್ಲಿ ನೀವು ಒಂದು ಆಸ್ತಿ ಪಟ್ಟಿಯ ಒಳಗೆ ಮಾಡಬಹುದು 968 00:52:10,000 --> 00:52:14,000 ಮತ್ತು ಈ ನಿಜವಾಗಿಯೂ ಚೆನ್ನಾಗಿ ನಮಗೆ ಕೆಲವು ಡೇಟಾವನ್ನು ಕೆಲಸ ಅನುಮತಿಸುತ್ತದೆ. 969 00:52:14,000 --> 00:52:18,000 ಉದಾಹರಣೆಗೆ, ನಾನು ರಚಿಸಿದ ಈ Teams.plist ಹೊಂದಿರುತ್ತವೆ. 970 00:52:18,000 --> 00:52:22,000 ನಾನು ಹೊಸ plist ಕಡತವನ್ನು ರಚಿಸಿದ, ಮತ್ತು ನಾನು ಕೆಳಗೆ ಕೊರೆತಕ್ಕಾಗಿ ಮಾಡಬಹುದು. 971 00:52:22,000 --> 00:52:26,000 ಈ ನಿಘಂಟು, ಈ ನಿಘಂಟು, ಈ, ತಂತಿಗಳು 972 00:52:26,000 --> 00:52:30,000 ಆದ್ದರಿಂದ ಈ ಒಂದು JSON ಡಾಕ್ಯುಮೆಂಟ್ನ ಸಂತೋಷವನ್ನು ಚಿತ್ರಾತ್ಮಕ ನಿರೂಪಣೆಯನ್ನು ಹೊಂದಿದೆ 973 00:52:30,000 --> 00:52:33,000 ಅಥವಾ ಕೀಲಿ ಮೌಲ್ಯವನ್ನು ಜೋಡಿ ಕೇವಲ ಒಂದು ಸೆಟ್, 974 00:52:33,000 --> 00:52:37,000 ಆದ್ದರಿಂದ ಈ ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ ಒಳಗೆ ಕೆಲಸ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ ಡೇಟಾವನ್ನು ಹೊಂದಿದೆ. 975 00:52:37,000 --> 00:52:40,000 >> ಮೊದಲ ಇಲ್ಲಿ ಮೇಲೆ ಬರಲಿ. ನಾವು ಈಗ ಸಾಕಷ್ಟು ಹೆಚ್ಚು ಕಡತಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. 976 00:52:40,000 --> 00:52:44,000 ಆದರೆ ಮೊದಲ ಸ್ಟೋರಿಬೋರ್ಡ್ ಇಲ್ಲಿ ಮೇಲೆ ಬರಲಿ. 977 00:52:44,000 --> 00:52:48,000 ಸ್ಟೋರಿಬೋರ್ಡ್ ಇಲ್ಲಿಗೆ ನಾನು ಝೂಮ್ ಮಾಡಬಹುದು ಹೊರಗೆ 978 00:52:48,000 --> 00:52:51,000 ನಾವು ಈಗ ಈ ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ ಹರಿವು ಎಂದು ನೋಡಬಹುದು. 979 00:52:51,000 --> 00:52:53,000 ನಾನು ಮೊದಲ ಈ ತೆರೆಯಲ್ಲಿ ಆರಂಭಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ. 980 00:52:53,000 --> 00:52:55,000 ನಾನು, ಈ ಪರದೆಯ ಕೆಳಗೆ ಕೊರೆತಕ್ಕಾಗಿ ಪಡೆಯಲಿದ್ದೇನೆ 981 00:52:55,000 --> 00:52:58,000 ಮತ್ತು ನಾನು ಈ ಪರದೆಯ ಕೆಳಗೆ ಕೊರೆತಕ್ಕಾಗಿ ಪಡೆಯಲಿದ್ದೇನೆ, ಮತ್ತು ನಾವು ಇಲ್ಲಿ ನೋಡಬಹುದು ನಾನು ರೀತಿಯ ವೇಳೆ 982 00:52:58,000 --> 00:53:04,000 ನಾವು ಈ ಬಾಣಗಳನ್ನು ಇಲ್ಲಿಂದ ಇಲ್ಲಿ ಹೋಗಿ ಸುಮಾರು ಇವುಗಳಲ್ಲಿ ಒಂದು, ಸರಿಸಲು 983 00:53:04,000 --> 00:53:08,000 ನಾನು ಸ್ವಲ್ಪ ಜೂಮ್ ವೇಳೆ ನಾನು ಆ ಬಾಣದ ವ್ಯಾಖ್ಯಾನಿಸಲು ರೀತಿಯಲ್ಲಿ, ಆಗಿತ್ತು 984 00:53:08,000 --> 00:53:12,000 ಮತ್ತು ನಾನು ಈ ಅಭಿಪ್ರಾಯವನ್ನು ನಿಯಂತ್ರಕಕ್ಕೆ ಮೇಲೆ ಬಂದರೆ, 985 00:53:12,000 --> 00:53:16,000 ಮತ್ತು ಇಲ್ಲಿ ಕೋಶ, ಮತ್ತು ನೀವು ಒಂದು ಜೀವಕೋಶದ ಸ್ಪರ್ಶಿಸಿ ನಾನು ನಾನು ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ 986 00:53:16,000 --> 00:53:18,000 ನಾನು ಮತ್ತೊಂದು ತೆರೆಗೆ ಮೇಲೆ ಸ್ಲೈಡ್ ಬಯಸುವ. 987 00:53:18,000 --> 00:53:21,000 ನಾನು ಸುಮ್ಮನೆ, ನಿಯಂತ್ರಣ ಡೌನ್ ಹಿಡಿಸುವ 988 00:53:21,000 --> 00:53:26,000 ಸ್ವಲ್ಪ ಮೇಲೆ ಸ್ಕ್ರಾಲ್, ನಿಯಂತ್ರಣ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಿ ಈ ಜೀವಕೋಶದ ಮೇಲೆ ಎಳೆಯಿರಿ ಮತ್ತು ಹೋಗಿ ಅವಕಾಶ. 989 00:53:26,000 --> 00:53:30,000 >> ಮತ್ತು ಇಲ್ಲಿ ಮೇಲೆ ನಾವು ನೀವು ಬಳಸಲು ಬಯಸುವ ಪರಿವರ್ತನೆ ಏನು ಹೇಳುತ್ತಾರೆ? 990 00:53:30,000 --> 00:53:32,000 ನೀವು ಪುಶ್ ಕರೆಯಲಾಗುತ್ತದೆ ಎಂದು ಸ್ಲೈಡ್ ವಿಷಯ ಬಳಸಲು ಬಯಸುತ್ತೀರಿ? 991 00:53:32,000 --> 00:53:34,000 ನೀವು ಕೆಳಗಿನಿಂದ ಸ್ಲೈಡ್ ಮೇಲಕ್ಕೆ ಬಯಸುತ್ತೀರಾ? 992 00:53:34,000 --> 00:53:36,000 ಆ ಮಾದರಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. 993 00:53:36,000 --> 00:53:40,000 ಮತ್ತು ಒಮ್ಮೆ ನಾನು ಈ ಒಂದು ಕ್ಲಿಕ್ ಮಾಡಿ, ಅದು ನನಗೆ ಈ ಬಾಣ ಸೆಳೆಯಲು ವಿಶೇಷವೇನು 994 00:53:40,000 --> 00:53:44,000 ಮತ್ತು ನಾನು ಸಚಿತ್ರವಾಗಿ ಈ ಬಟನ್ ಒತ್ತಿ, ಏನಾಗುತ್ತದೆ ನಿರ್ವಹಿಸಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥ. 995 00:53:44,000 --> 00:53:48,000 ನಾನು ವಾಸ್ತವವಾಗಿ ಒಂದು ಪರದೆಯಿಂದ ಮುಂದಿನ ಒಂದು ಸ್ಲೈಡ್ ಯಾವುದೇ ಕೋಡ್ ಬರೆಯಲಿಲ್ಲ. 996 00:53:48,000 --> 00:53:51,000 ನಾನು ಅಂತರ್ಮುಖಿ ಬಿಲ್ಡರ್ ಈ ದೃಷ್ಟಿ ಒಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. 997 00:53:51,000 --> 00:53:55,000 ನಾನು ಈ ಬಾಣದ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿದಲ್ಲಿ, ನಾವು ಈ ವಿಷಯವನ್ನು ಹೆಸರನ್ನು ನೀಡಿದ ನೋಡಬಹುದು. 998 00:53:55,000 --> 00:53:59,000 ನಾನು showDivisions ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಈ ನನಗೆ ಗೊತ್ತು ಇದರಿಂದ ಆಗಿದೆ 999 00:53:59,000 --> 00:54:03,000 ಯಾವ ಸ್ಥಿತ್ಯಂತರದ ಬಗ್ಗೆ ಸಂಭವಿಸುತ್ತವೆ, ಮತ್ತು ಏಕೆ ಕೇವಲ ಒಂದು ಸೆಕೆಂಡ್ನಲ್ಲಿ ನಾವು ನೋಡುತ್ತಾರೆ. 1000 00:54:03,000 --> 00:54:06,000 ಎಂದು ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ ವಿವಿಧ ಪರದೆಯ ಅಪ್ ತಂತಿ ನೀವು ಹೇಗೆ. 1001 00:54:06,000 --> 00:54:09,000 ಈ ಬಟನ್, ಉದಾಹರಣೆಗೆ, ಬದಲಿಗೆ ಒಂದು ಟೇಬಲ್ ನೋಟ ವೇಳೆ, 1002 00:54:09,000 --> 00:54:11,000 ನಾನು, ಮುಂದಿನ ತೆರೆಗೆ ಮೇಲೆ ಎಳೆಯಿರಿ, ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್ ನಿಯಂತ್ರಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ 1003 00:54:11,000 --> 00:54:16,000 ಮತ್ತು ನಾನು ಸಂಚರಣೆ ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು ಹೇಗೆ. 1004 00:54:16,000 --> 00:54:19,000 >> ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ನಾವು MasterViewController ಬರುವ ವೇಳೆ, 1005 00:54:19,000 --> 00:54:22,000 ಮತ್ತೆ, ನಾವು ಕೇವಲ ವಸ್ತುಗಳ ಪಟ್ಟಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನೀನು 1006 00:54:22,000 --> 00:54:26,000 ಎಂದು ಪಟ್ಟಿ ವೀಕ್ಷಣೆಯಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. 1007 00:54:26,000 --> 00:54:29,000 ಇಲ್ಲಿ ನಾನು ಆ plist ಕಡತ ತೆಗೆದುಕೊಳ್ಳಲು ಬಯಸುವ ಹೇಳುವ ನಾನು 1008 00:54:29,000 --> 00:54:32,000 ಮತ್ತು ನಾನು, ಒಂದು ನಿಘಂಟು ಅದನ್ನು ಲೋಡ್ ಬಯಸುವ 1009 00:54:32,000 --> 00:54:35,000 ಮತ್ತು ಒಮ್ಮೆ ನೀವು ನಿಘಂಟು ಹೊಂದಿವೆ, ನಾನು ಮತ್ತೆ ಅದೇ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ. 1010 00:54:35,000 --> 00:54:37,000 ಇಲ್ಲಿ ವಿಭಾಗಗಳ ಸಂಖ್ಯೆ. 1011 00:54:37,000 --> 00:54:41,000 ಒಂದು, ಪ್ರತಿ ಲೀಗ್ ಸಾಲು, ಮತ್ತು ಪ್ರತಿಯೊಂದು ಕೋಶದ ಪಠ್ಯ ಇಲ್ಲ 1012 00:54:41,000 --> 00:54:46,000 ಆದ್ದರಿಂದ ಮೊದಲ ಒಂದು, ಮೊದಲ ಲೀಗ್ ಎರಡನೇ ಲೀಗ್ ಮತ್ತು ಆಗಿರಬೇಕು. 1013 00:54:46,000 --> 00:54:51,000 ಅಂತಿಮವಾಗಿ, ನಾನು, ನಾವು prepareForSegue ಎಂದು ನೋಡಿತು ಈ ವಿಧಾನವನ್ನೇ ಪಡೆಯಲಿದ್ದೇನೆ 1014 00:54:51,000 --> 00:54:54,000 ಮತ್ತು ನಾನು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ಉಂಟಾಗದ ಹೋಗುವುದಿಲ್ಲ ಎಂದು ವಿಧಾನ 1015 00:54:54,000 --> 00:54:57,000 ಆ ಸಾಲುಗಳ ಮೇಲೆ ಮತ್ತು ಆದ್ದರಿಂದ ಆ ಪರಿವರ್ತನೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆ 1016 00:54:57,000 --> 00:54:59,000 ನಾನು ಬಾಣಗಳು ಹೊಂದಿಸಲು ಎಂದು. 1017 00:54:59,000 --> 00:55:02,000 ನಾನು ಬಹು ಹೊಂದಬಹುದು ಎಂದು ಇದೆ 1018 00:55:02,000 --> 00:55:05,000 ಒಂದು ಸ್ಕ್ರೀನ್ ಇನ್ನೊಂದಕ್ಕೆ ಸಂಬಂಧಗಳು. 1019 00:55:05,000 --> 00:55:08,000 ನಾನು 2 ಗುಂಡಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ ಮತ್ತು ಪ್ರತಿ ಬಟನ್ ಬೇರೆ ತೆರೆಗೆ ಕೊಂಡೊಯ್ಯುತ್ತದೆ ವೇಳೆ 1020 00:55:08,000 --> 00:55:10,000 ನಾನು ಪ್ರತಿ ಬಟನ್ 2 segues, 1 ಹೊಂದಿರುತ್ತವೆ ಪಡೆಯಲಿದ್ದೇನೆ. 1021 00:55:10,000 --> 00:55:14,000 ಆದರೆ ಈ prepareForSegue ಮರುಬಳಕೆ ಹೋಗಿ, ಮತ್ತೆ, ಆಗಿದೆ 1022 00:55:14,000 --> 00:55:17,000 ವಿವಿಧ ಸಂಬಂಧಗಳನ್ನು ಪ್ರತಿಯೊಂದು, ಆದ್ದರಿಂದ ನಾನು ಒಂದು ದಾರಿ ಬೇಕಿದೆ ಅರ್ಥ 1023 00:55:17,000 --> 00:55:21,000 ನೀವು ಮೊದಲ ಗುಂಡಿಯನ್ನು ಒತ್ತಿ ಅಥವಾ ನೀವು ಎರಡನೇ ಗುಂಡಿಯನ್ನು ಒತ್ತಿದಾಗ ಗುರುತಿಸುವ. 1024 00:55:21,000 --> 00:55:25,000 >> ನಾನು ನಿಲ್ಲಿಸದೆ ಮುಂದುವರಿಸು ಹೆಸರನ್ನು ಈ showDivisions, ನೀಡಿದಾಗ ನೆನಪಿಡಿ 1025 00:55:25,000 --> 00:55:29,000 ನಾನು ಈಗ ಈ ಸಕ್ರಿಯ ಎಂದು ನಿಲ್ಲಿಸದೆ ಮುಂದುವರಿಸು ಎಂದು ತಿಳಿಯಲು ಹೇಗೆ. 1026 00:55:29,000 --> 00:55:32,000 ನಾನು ಬಯಸುವ ಎಲ್ಲಾ ನಾನು ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ ಆಗಿದೆ 1027 00:55:32,000 --> 00:55:35,000 ನಾನು ಕೇವಲ ಹಿಟ್ ಏನೆಂದು ಲೆಕ್ಕಾಚಾರ ಬಯಸುವ 1028 00:55:35,000 --> 00:55:38,000 ಮತ್ತು ಆದ್ದರಿಂದ ಪಡೆಯಲು, ನಾನು ಆಯ್ಕೆ ಸಾಲಿನ indexPath ಬಯಸುವ ಹೇಳಬಹುದು 1029 00:55:38,000 --> 00:55:42,000 ನಾನು ಕ್ಲಿಕ್ ಅಲ್ಲಿ indexPath ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಕೇವಲ ಹೇಳುತ್ತಾರೆ 1030 00:55:42,000 --> 00:55:47,000 ತದನಂತರ ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ ಅಲ್ಲಿ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಬಯಸುವ ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ. 1031 00:55:47,000 --> 00:55:50,000 ಈ destinationViewController ಆ ನಿಲ್ಲಿಸದೆ ಮುಂದುವರಿಸು ಒಂದು ಸ್ವತ್ತಿನ. 1032 00:55:50,000 --> 00:55:53,000 ಎಂದು, ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ ಪರದೆಯ 1033 00:55:53,000 --> 00:55:56,000 ಆದ್ದರಿಂದ ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ ಪರದೆಯ DivisionsViewController ಕರೆಯಲಾಗುತ್ತದೆ ತಿಳಿದಿದೆ 1034 00:55:56,000 --> 00:55:59,000 ನಾನು ವರ್ಗ ದಾಖಲಿಸಿದವರು, ಏಕೆಂದರೆ 1035 00:55:59,000 --> 00:56:02,000 ಆದ್ದರಿಂದ ಈಗ ನಾನು d.divisions ಹೇಳಲು ವೇಳೆ 1036 00:56:02,000 --> 00:56:06,000 ನಾನು ಈಗ ನಾನು ಹೋಗಲು ಬಗ್ಗೆ ಆಮ್ ವೀಕ್ಷಿಸಿ ನಿಯಂತ್ರಕ ಒಂದು ಆಸ್ತಿ ಹೊಂದಿಸುವ ನುಡಿದರು. 1037 00:56:06,000 --> 00:56:10,000 ನಾನು ಮತ್ತೊಂದು ತೆರೆಗೆ ಒಂದು ತೆರೆಯಿಂದ ದತ್ತಾಂಶವನ್ನು ಕಳುಹಿಸುವಾಗ ನಾನು ಹೇಗೆ. 1038 00:56:10,000 --> 00:56:13,000 >> ಈ DivisionsViewController ನೋಡಿ 1039 00:56:13,000 --> 00:56:16,000 ನೀವು ಇಲ್ಲಿ ಕಾಣಬಹುದಾಗಿದೆ. H ಕಡತದಲ್ಲಿ 1040 00:56:16,000 --> 00:56:20,000 , ಅದು ಆಸ್ತಿ ವಿಭಾಗಗಳನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ನಾನು ಮೂಲತಃ 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 ಇದು ಕೇವಲ ಒಂದು ಉದ್ದೇಶ-ಸಿ ವಿಷಯ. 1050 00:56:47,000 --> 00:56:52,000 ಆಮದು, ಮೂಲತಃ ಪೈಕಿ ಒಂದು ಒಳ್ಳೆಯದೆಂದು ಆವೃತ್ತಿಯಾಗಿದೆ 1051 00:56:52,000 --> 00:56:57,000 ಮತ್ತು ಉದಾಹರಣೆಗೆ, ನಾವು, ಈ ವರ್ಗದ ಯಾವ ತಿಳಿದುಕೊಳ್ಳಬೇಕಾಗಬಹುದು 1052 00:56:57,000 --> 00:57:00,000 ಆದ್ದರಿಂದ ನಾನು DivisionsViewController ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ. 1053 00:57:00,000 --> 00:57:05,000 ನಮ್ಮ. ಸಿ ಕಡತದ 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 ನಿಮ್ಮ ಬೇರೆ. ಮೀ ಕಡತಗಳ ಒಳಗೆ ನೀವು ಆಮದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ 1058 00:57:19,000 --> 00:57:25,000 ಸೂಕ್ತವಾದ. ​​H ಕಡತಗಳನ್ನು ಆದ್ದರಿಂದ ಕಂಪೈಲರ್ ಇಂದಿನ ವಿಶೇಷವೇನು ತಿಳಿದಿಲ್ಲ. 1059 00:57:25,000 --> 00:57:31,000 >> ಅಂತಿಮವಾಗಿ, ಏನು ಆಪಲ್ ಅಂತಿಮವಾಗಿ, ಒಂದು ವೆಬ್ ನೋಟ ಬಳಸಿಕೊಂಡು ಕೆಲವು ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಇದೆ ಇಲ್ಲ 1060 00:57:31,000 --> 00:57:35,000 ಮತ್ತು ಆದ್ದರಿಂದ ಒಂದು ವೆಬ್ ನೋಟ ನೀವು ಎಂಬೆಡ್ ಮಾಡಬಹುದು ಇದರಲ್ಲಿ ಒಂದು ವಸ್ತು 1061 00:57:35,000 --> 00:57:37,000 ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಒಳಗೆ ಸ್ವಲ್ಪ ವೆಬ್ ಬ್ರೌಸರ್. 1062 00:57:37,000 --> 00:57:40,000 ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ಇಷ್ಟೆ, ನಿಮ್ಮ ವೆಬ್ ಬ್ರೌಸರ್ ಒಂದು 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 ಆ segues ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. 1071 00:58:09,000 --> 00:58:12,000 ನಾನು, ಈ ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಒಂದಕ್ಕಿಂತ 1072 00:58:12,000 --> 00:58:15,000 ಮತ್ತು ಈಗ ಇಲ್ಲಿ ಆದ್ದರಿಂದ ಕೇವಲ, ನನ್ನ UIWebView ಆಗಿದೆ 1073 00:58:15,000 --> 00:58:19,000 ಇಲ್ಲಿ ನಾನು ಎಂಬೆಡೆಡ್ ಆ 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 ಸಂಪೂರ್ಣವಾಗಿ ಉಚಿತವಾಗಿ ನಾನು segues ಬಳಸಿಕೊಂಡು ಈ ಸಂಬಂಧಗಳು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಮಾಡಿದ ಕಾರಣ. 1078 00:58:33,000 --> 00:58:37,000 >> ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಹೌದು. 1079 00:58:37,000 --> 00:58:40,000 [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ನೀವು alloc ಬಳಸುವಾಗ, ನೀವು ಉಚಿತ ಏನು ಯಾವತ್ತೂ? 1080 00:58:40,000 --> 00:58:43,000 ನಿಖರವಾಗಿ, ನೀವು alloc ಮತ್ತು init ಕರೆ ಬಂದಾಗ ನೀವು ಮುಕ್ತಗೊಳಿಸಲು ಹೊಂದಿಲ್ಲ. 1081 00:58:43,000 --> 00:58:46,000 IOS ನೀವು ಆ ಎಲ್ಲಾ ನಿರ್ವಹಿಸಲು ಹೋಗುತ್ತದೆ. 1082 00:58:46,000 --> 00:58:51,000 ಇದು ಅದ್ಭುತ, ಮತ್ತು ನೀವು ಯಾವುದೇ ನಿಯಮಗಳನ್ನು ಮುರಿದ ಇಲ್ಲ. ಹೌದು. 1083 00:58:51,000 --> 00:58:54,000 ನೀವು ತೆರೆಯಲ್ಲಿ ಹೊಂದಿಕೊಳ್ಳಲು ಸೂಕ್ತವಾಗುವಂತೆ ಹೆಚ್ಚು ತಂಡಗಳೆಂದರೆ ಹೊಂದಿದ್ದವು [ವಿದ್ಯಾರ್ಥಿ] ವೇಳೆ 1084 00:58:54,000 --> 00:58:58,000 ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ ಎಂದು ಏನೋ ಒಂದು ಚಲನ ಆಯ್ಕೆಯನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಅಥವಾ ಅದು? 1085 00:58:58,000 --> 00:59:01,000 ನಾನು ಹೆಚ್ಚು ತಂಡಗಳು ಹೊಂದಿದ್ದರೆ ನಿಖರವಾಗಿ, ಉದಾಹರಣೆಗೆ, ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸಲು ಎಂದು 1086 00:59:01,000 --> 00:59:04,000 ನನಗೆ ಸ್ಕ್ರೋಲಿಂಗ್ ಮತ್ತು ನಿರ್ವಹಣೆ ಕಾಳಜಿ 1087 00:59:04,000 --> 00:59:08,000 ದೊಡ್ಡ ಟೇಬಲ್ ಕೂಡ ನನಗೆ ಸಂಪೂರ್ಣವಾಗಿ ನಿರ್ವಹಿಸಲ್ಪಡುತ್ತವೆ. 1088 00:59:08,000 --> 00:59:11,000 >> ಇತರ ಪ್ರಶ್ನೆಗಳು? 1089 00:59:11,000 --> 00:59:13,000 ಈ ಕೋಡ್ ಎಲ್ಲಾ ಪೋಸ್ಟ್ ಏರಲಿದೆ. 1090 00:59:13,000 --> 00:59:16,000 ನಾವು ರೀತಿಯ ಹೆಚ್ಚು ಸಣ್ಣ ವಿವರಗಳು ಸ್ವಲ್ಪ ಮೇಲೆ glossed 1091 00:59:16,000 --> 00:59:19,000 ಆದರೆ ವಿಷಯಗಳನ್ನು ವೆಬ್ ನೋಟ ಕೆಲವು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿಸುವ 1092 00:59:19,000 --> 00:59:22,000 ನೀವು ಆಪಲ್ನ ದಸ್ತಾವೇಜನ್ನು ಬ್ರೌಸಿಂಗ್ ಮೂಲಕ ಪಡೆಯಬಹುದು ಎಂದು ವಸ್ತುಗಳು, 1093 00:59:22,000 --> 00:59:24,000 ನಿಜವಾಗಿಯೂ, ಇದು ನಿಜವಾಗಿಯೂ ಚೆನ್ನಾಗಿ ಔಟ್ ಹಾಕಿತು. 1094 00:59:24,000 --> 00:59:27,000 ಅವು ಒಂದು ಮಾದರಿಯ ಅಪ್ಲಿಕೇಶನ್ಗಳು ಬಹಳಷ್ಟು ಮತ್ತು ಉದಾಹರಣೆಗೆ ಬಳಕೆಗಳು ಹೊಂದಿವೆ 1095 00:59:27,000 --> 00:59:34,000 ವಿವಿಧ API ಗಳು, ಆದ್ದರಿಂದ ಖಂಡಿತವಾಗಿ ನೀವು ಸಾಧ್ಯವಾದರೆ ಆ ಲಕ್ಷ್ಯಪೂರ್ವಕವಾಗಿ. 1096 00:59:34,000 --> 00:59:36,000 ಕೆಲವು ಉಪಯುಕ್ತ ಕೊಂಡಿಗಳು ನೀವು ನೋಡೋಣ ಬಯಸಬಹುದು. 1097 00:59:36,000 --> 00:59:38,000 ಈ ಕೆಲವು HANDY ದಸ್ತಾವೇಜನ್ನು ಮಾರ್ಗದರ್ಶಿಗಳಾಗಿರುತ್ತವೆ. 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 >> ಹೇಗೆ ಮಾಡಲು ನೀವು ತೋರಿಸುತ್ತದೆ ಎಂದು ಆಪೆಲ್ ಮಾದರಿ ಅಪ್ಲಿಕೇಶನ್ಗಳು ಸಾಕಷ್ಟು, ಇಲ್ಲ 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 ಸರಿ, ಖಂಡಿತವಾಗಿಯೂ ಚರ್ಚೆ ಮೇಲೆ ವಿಶೇಷ ಲೇಬಲ್ಗಳನ್ನು ಮಾಡಲಿಕ್ಕೆ-ನಾವು ಹಿಂಜರಿಯಬೇಡಿ. 1113 01:00:27,000 --> 01:00:30,000 ನಾವು ಐಒಎಸ್ ಒಂದು ಸಾಧ್ಯವಿದೆ, ಆದ್ದರಿಂದ ಖಂಡಿತವಾಗಿ ಆ ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ ಹಿಂಜರಿಯಬೇಡಿ. 1114 01:00:30,000 --> 01:00:34,000 ನೀವು ಯೋಜನೆಗಳಲ್ಲಿ ನಿಮ್ಮ ಸಹಪಾಠಿಗಳನ್ನು ಕೆಲಸ ಬಯಸಿದರೆ 1115 01:00:34,000 --> 01:00:37,000 ಅಥವಾ ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ಐಒಎಸ್ ಸ್ಟಫ್ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಸಹಾಯ 1116 01:00:37,000 --> 01:00:40,000 ನನಗೆ ಇಮೇಲ್ ಹಿಂಜರಿಯಬೇಡಿ, ಮತ್ತು ಖಂಡಿತವಾಗಿಯೂ ಎಲ್ಲಾ ಕೋಡ್ ಆನ್ಲೈನ್ ಏಕೆಂದರೆ ಲಕ್ಷ್ಯಪೂರ್ವಕವಾಗಿ 1117 01:00:40,000 --> 01:00:43,000 ಸಕಾಲದಲ್ಲಿ ಆಸಕ್ತಿಯನ್ನು ನಾವು ರೀತಿಯ ಹೆಚ್ಚು ಮೇಲೆ glossed 1118 01:00:43,000 --> 01:00:45,000 ವಸ್ತುಗಳ ಸೂಕ್ಷ್ಮ ಕಣಗಳ ವಿವರಗಳು. 1119 01:00:45,000 --> 01:00:47,000 ಆದರೆ ಒಂದು ವೇಳೆ, ನಂತರ ಒಳ್ಳೆಯ ನಿಮ್ಮ ಐಒಎಸ್ ಯೋಜನೆಗಳಲ್ಲಿ ಅದೃಷ್ಟ, ಮತ್ತು ನಾನು ನಾವು ಭಾವಿಸುತ್ತೇವೆ 1120 01:00:47,000 --> 01:00:53,000 ಆಪ್ ಸ್ಟೋರ್ ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ಗಳ ದೊಡ್ಡ ಒಳಹರಿವು. 1121 01:00:53,000 --> 01:00:56,000 [CS50.TV]