Java/C3/Java-Interfaces/Kannada

Time	Narration
00:01	ಜಾವಾ ಇಂಟರ್‌ಫೇಸ್‌ ಗಳ ಕುರಿತ ಸ್ಪೋಕನ್‌ ಟ್ಯುಟೋರಿಯಲ್‌ ಗೆ ಸ್ವಾಗತ.
00:05	ಈ ಟ್ಯುಟೋರಿಯಲ್‌ ನಲ್ಲಿ ನಾವು, ಇಂಟರ್‌ಫೇಸ್‌ ಅನ್ನು ರಚಿಸುವುದು,
00:10	ಇಂಪ್ಲಿಮೆಂಟೇಶನ್ ಕ್ಲಾಸುಗಳ ರಚನೆ ಮತ್ತು ಇಂಟರ್‌ಫೇಸ್‌ ನ ಬಳಕೆ ಇವುಗಳ ಬಗ್ಗೆ ಕಲಿಯಲಿದ್ದೇವೆ.
00:16	ಈ ಟ್ಯುಟೋರಿಯಲ್ ಗಾಗಿ ನಾನು: ಉಬಂಟು 12.04, JDK1.7 ಮತ್ತು Eclipse 4.3.1 ಇವುಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದೇನೆ.
00:28	ಈ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಅನುಸರಿಸಲು ನೀವು ಜಾವಾ ಮತ್ತು Eclipse IDE ಯ ಬಗ್ಗೆ ತಿಳಿದಿರಬೇಕು.
00:36	ಜಾವಾದಲ್ಲಿ ಸಬ್-ಕ್ಲಾಸಿಂಗ್ ಮತ್ತು Abstract (ಅಬ್ಸ್ಟ್ರ್ಯಾಕ್ಟ್ ) ಕ್ಲಾಸುಗಳ ಬಗ್ಗೆ ಸಹ ತಿಳಿದಿರಬೇಕು.
00:42	ಇಲ್ಲದಿದ್ದಲ್ಲಿ, ಸಂಬಂಧಿತ ಜಾವಾ ಟ್ಯುಟೋರಿಯಲ್ ಗಳಿಗಾಗಿ ಇಲ್ಲಿ ತೋರಿಸಿರುವ ಲಿಂಕ್‌ಗೆ ದಯವಿಟ್ಟು ಭೇಟಿ ನೀಡಿ.
00:48	ಮೊದಲಿಗೆ ನಾವು ಇಂಟರ್ಫೇಸ್ ಏನೆಂಬುದನ್ನು ಅರಿತುಕೊಳ್ಳೋಣ.
00:52	ಇಂಟರ್‌ಫೇಸ್‌, abstract ಮೆಥಡ್‌ ಗಳ ಮತ್ತು ಸ್ಟಾಟಿಕ್‌ ಡೇಟಾ ಮೆಂಬರ್‌ ಗಳ ಗಣವನ್ನು ಹೊಂದಿರುತ್ತದೆ.
00:58	ಇದು ಬಾಡಿ ಇಲ್ಲದ ಮೆಥಡ್‌ ಗಳ ಸಮೂಹದ ಸಿಗ್ನೇಚರ್‌ ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.
01:04	ಇದನ್ನು interface ಕೀವರ್ಡ್ ಬಳಸಿ ಡಿಕ್ಲೇರ್ ಮಾಡಲಾಗುತ್ತದೆ.
01:08	ನಾವೀಗ Eclipse ಗೆ ಬದಲಾಯಿಸುತ್ತೇವೆ ಮತ್ತು InterfaceDemo ಎಂಬ ಹೊಸ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.
01:15	ಇಲ್ಲಿ, ಇಂಟರ್‌ಫೇಸ್‌ ಗಳ ಬಳಕೆಯನ್ನು ತೋರಿಸಲು ಅಗತ್ಯವಿರುವ ಕ್ಲಾಸುಗಳು ಮತ್ತು ಇಂಟರ್‌ ಫೇಸ್‌ ಅನ್ನು ರಚಿಸಲಿದ್ದೇವೆ.
01:24	src ಫೋಲ್ಡರ್‌ ಮೇಲೆ ರೈಟ್‌ ಕ್ಲಿಕ್‌ ಮಾಡಿ ಮತ್ತು New > Interface ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ.
01:30	ಹೆಸರನ್ನು Animal ಎಂದು ಟೈಪ್‌ ಮಾಡಿ ಮತ್ತು Enter ಒತ್ತಿ.
01:34	ಗಮನಿಸಿ: ಇಂಟರ್‌ಫೇಸ್‌ ಅನ್ನು ನಿರೂಪಿಸಲು ʻʻinterface'’ ಕೀವರ್ಡ್‌ ಅನ್ನು ಬಳಸಲಾಗಿದೆ.
01:39	ಈಗ, ಸ್ಕ್ರೀನ್‌ ನಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಕೋಡ್‌ ಅನ್ನು ಟೈಪ್‌ ಮಾಡಿ.
01:43	ಇಲ್ಲಿ ಇಂಟರ್‌ಫೇಸ್‌ ನ ಹೆಸರು Animal ಆಗಿದೆ.
01:46	ಇದು talk(), see() ಮತ್ತು move() ಎಂಬ ಮೂರು ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್ ಗಳನ್ನು ಹೊಂದಿದೆ.
01:52	ಇಂಟರ್‌ಫೇಸ್‌ ನಲ್ಲಿನ ಇಂತಹ ಎಲ್ಲಾ ಮೆಥಡ್‌ ಗಳು ಸೂಚ್ಯವಾಗಿ (implicitly) public ಮತ್ತು abstract ಆಗಿವೆ.
01:59	ಇಂಟರ್‌ಫೇಸ್‌ constant ವೇರಿಯೇಬಲ್‌ ಡಿಕ್ಲೆರೇಷನ್ ಗಳನ್ನು ಸಹ ಹೊಂದಿರಬಹುದು.
02:04	ಇಲ್ಲಿ, ಕಾನ್ಸ್ಟಂಟ್‌ ಸ್ಟ್ರಿಂಗ್‌ ವ್ಯಾಲ್ಯು “Mammal” ಅನ್ನು ವೇರಿಯೇಬಲ್ “type1” ಗೆ ಅಸೈನ್ ಮಾಡಲಾಗಿದೆ.
02:12	ಮತ್ತು “Reptiles” ಅನ್ನು ವೇರಿಯೇಬಲ್ “type2” ಗೆ ಅಸೈನ್ ಮಾಡಲಾಗಿದೆ.
02:16	ಇಂಟರ್‌ಫೇಸ್‌ ನಲ್ಲಿ ಡಿಫೈನ್ ಮಾಡಲಾದ ಎಲ್ಲಾ ಕಾನ್ಸ್ಟಂಟ್‌ ವ್ಯಾಲ್ಯು ಗಳು ಸೂಚ್ಯವಾಗಿ public, static ಮತ್ತು final ಆಗಿವೆ.
02:25	ನಂತರ ನಾವು ಇಂಟರ್ಫೇಸ್ ಗಾಗಿ ಉದಾಹರಣೆಯೊಂದಿಗೆ implementation ಕ್ಲಾಸ್ ನೋಡುವೆವು.
02:32	ಇಲ್ಲಿ Human ಒಂದು ಕ್ಲಾಸ್ ಆಗಿದ್ದು, Animal ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.
02:38	ಆದ್ದರಿಂದ, talk(), see() ಮತ್ತು move() ಮೆಥಡ್ ಗಳಿಗಾಗಿ ಇದು ಇಂಪ್ಲೆಮೆಂಟೇಶನ್ ಗಳನ್ನು ಒದಗಿಸಲೇಬೇಕು.
02:45	ಒಂದು ಕ್ಲಾಸ್, ಅನೇಕ ಇಂಟರ್ಫೇಸ್ ಗಳನ್ನು ಸಹ ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡಬಲ್ಲದು.
02:49	ಉದಾಹರಣೆಯಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ, Human ಕ್ಲಾಸ್ ಎನ್ನುವುದು Animal ಮತ್ತು Action ಎಂಬ ಎರಡು ಇಂಟರ್ಫೇಸ್ ಗಳನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡುತ್ತದೆ.
02:57	ವಿಭಿನ್ನ ಇಂಟರ್ಫೇಸ್ ಗಳನ್ನು ಗುರುತಿಸಲು, ಸಿಂಟ್ಯಾಕ್ಸ್ ನಲ್ಲಿ comma operator ಅನ್ನು ಬಳಸಿರುವುದನ್ನು ಗಮನಿಸಿ.
03:04	ಈಗ ಈ ಕ್ಲಾಸ್, Animal ಮತ್ತು Action ಇಂಟರ್ಫೇಸ್ ಗಳೆರಡರಲ್ಲೂ ಎಲ್ಲಾ abstract ಮೆಥಡ್ ಗಳಿಗೆ ಇಂಪ್ಲಿಮೆಂಟೇಶನ್ ಗಳನ್ನು ಒದಗಿಸಬೇಕು.
03:13	ಇಲ್ಲಿರುವ ಚಿತ್ರವು ಒಂದು ಇಂಪ್ಲಿಮೆಂಟ್ ರಿಲೇಶನ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
03:18	Animal ಕ್ಲಾಸ್ ಇಲ್ಲಿ ಇಂಟರ್ಫೇಸ್ ಆಗಿದೆ.
03:22	Human ಮತ್ತು Snake ಕ್ಲಾಸುಗಳು ಎರಡು implementation ಕ್ಲಾಸುಗಳಾಗಿವೆ.
03:28	Human ಕ್ಲಾಸ್, talk(), see() ಮತ್ತು move() ಮೆಥಡ್ ಗಳಿಗಾಗಿ ತನ್ನದೇ ಆದ ಬೇರೆ ಬೇರೆ ಇಂಪ್ಲೆಮೆಂಟೇಶನ್ ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
03:36	ಮತ್ತು, Snake ಕ್ಲಾಸ್, talk(), see() ಮತ್ತು move() ಮೆಥಡ್ ಗಳಿಗಾಗಿ ತನ್ನದೇ ಆದ ಬೇರೆ ಇಂಪ್ಲೆಮೆಂಟೇಶನ್ ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
03:45	ನಾವೀಗ ಒಂದು ಮಾದರಿ ಪ್ರೋಗ್ರಾಂನೊಂದಿಗೆ ಇಂಟರ್ಫೇಸ್ ಗಳ ಬಳಕೆಯನ್ನು ತಿಳಿದುಕೊಳ್ಳೋಣ.
03:50	default package ಮೇಲೆ ರೈಟ್- ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು Human ಎನ್ನುವ ಕ್ಲಾಸನ್ನು ರಚಿಸಿ.
03:56	ಈಗ, ಇದನ್ನು Animal ನ implementation ಕ್ಲಾಸ್ ಆಗಿಸಲು ಹೀಗೆ ಟೈಪ್ ಮಾಡಿ: implements Animal.
04:04	ನಾವೀಗ Eclipse IDE ಯಲ್ಲಿ ಎರರ್ ಅನ್ನು ನೋಡಬಹುದು.
04:09	Animal ಇಂಟರ್ಫೇಸ್ ಗೆ, implementation ಅನ್ನು ಒದಗಿಸಬೇಕು ಎಂದು ಈ ಎರರ್ ಸೂಚಿಸುತ್ತದೆ.
04:15	ಈ ಎರರ್ ಅನ್ನು ಹೇಗೆ ಸರಿಪಡಿಸಬಹುದು ಎಂದು ನಾವು ನೋಡೋಣ.
04:19	ಈಗ talk(), see() ಮತ್ತು move() ಮೆಥಡ್ ಗಳನ್ನು ಡಿಫೈನ್ ಮಾಡೋಣ.
04:23	ಇದಕ್ಕಾಗಿ ಹೀಗೆ ಟೈಪ್ ಮಾಡಿ: public void talk( ) ಕರ್ಲಿ ಬ್ರ್ಯಾಕೆಟ್ಸ್ ಒಳಗೆ System.out.println ಮತ್ತು ಕೋಟ್ಸ್ ಒಳಗೆ "I am a human and I belong to" ಎಂದು ಟೈಪ್ ಮಾಡಿ.
04:37	ನಾವೀಗ Animal ಇಂಟರ್ಫೇಸ್ ನಲ್ಲಿ ಡಿಕ್ಲೇರ್ ಮಾಡಿರುವ static, final variable type1 ನ ವ್ಯಾಲ್ಯೂವನ್ನು ಬಳಸಬಹುದು.
04:45	ಇದಕ್ಕಾಗಿ, ಹೀಗೆ ಟೈಪ್ ಮಾಡಿ.+ Animal.type1+ ಕೋಟ್ಸ್ ಒಳಗೆ "family" Semicolon.
04:54	ನಾವೀಗ see() ಮೆಥಡ್ ಅನ್ನು ಇಂಪ್ಲೆಮೆಂಟ್ ಮಾಡೋಣ.
04:57	ಇದಕ್ಕಾಗಿ ಹೀಗೆ ಟೈಪ್ ಮಾಡಿ: public void see() ಕರ್ಲಿ ಬ್ರ್ಯಾಕೆಟ್ಸ್ ಒಳಗೆ System.out.println ಕೋಟ್ಸ್ ಒಳಗೆ "I can see all colors" Semicolon.
05:11	ನಾವು move() ಮೆಥಡ್ ಅನ್ನು ಸಹ ಡಿಫೈನ್ ಮಾಡಬೇಕು.
05:14	ಈಗ ಹೀಗೆ ಟೈಪ್ ಮಾಡಿ : public void move() ಕರ್ಲಿ ಬ್ರ್ಯಾಕೆಟ್ಸ್ ಒಳಗೆ System.out.println ಕೋಟ್ಸ್ ಒಳಗೆ "I move by walking" semicolon.
05:29	ಈ ಎಲ್ಲಾ ಮೆಥಡ್ ಗಳನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡಿದಾಗ ಎರರ್ ಮಾಯವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
05:34	ನಂತರ, Snake ಕ್ಲಾಸನ್ನು ಹೇಗೆ ಡಿಫೈನ್ ಮಾಡಬಹುದು ಎಂದು ನೋಡೋಣ.
05:38	ಈಗಾಗಲೇ ನಾನಿದನ್ನು ನನ್ನ ಪ್ರಾಜೆಕ್ಟ್ ನಲ್ಲಿ ರಚಿಸಿದ್ದೇನೆ.
05:42	ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ನಲ್ಲಿ ದಯವಿಟ್ಟು Snake ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ಸ್ಕ್ರೀನ್ ನಲ್ಲಿ ತೋರಿಸಿರುವ ಕೋಡ್ ಅನ್ನು ಟೈಪ್ ಮಾಡಿ.
05:49	ನಾವೀಗ ಕೋಡ್ ಅನ್ನು ನೋಡೋಣ.
05:52	Animal ಇಂಟರ್ಫೇಸ್ ನ ಎಲ್ಲಾ ಮೆಥಡ್ ಗಳಾದ talk(), see() ಮತ್ತು move() ಗಳನ್ನು ಈ ಕ್ಲಾಸ್ ಒಳಗೆ ಇಂಪ್ಲೆಮೆಂಟ್ ಮಾಡಿದ್ದೇವೆ.
06:01	ಇಲ್ಲಿ talk() ಮೆಥಡ್, “I am a snake and I belong to” ಎಂದು ಪ್ರಿಂಟ್ ಮಾಡುತ್ತದೆ.
06:07	ನಂತರ Animal.type2 ನ ವ್ಯಾಲ್ಯೂವನ್ನು, ಆನಂತರ “family” ಯನ್ನು ಪ್ರಿಂಟ್ ಮಾಡಬೇಕು.
06:13	ಇಲ್ಲಿ see() ಮೆಥಡ್, “I can see only in black and white” ಎಂದು ಪ್ರಿಂಟ್ ಮಾಡುತ್ತದೆ.
06:19	move() ಮೆಥಡ್, "I move by crawling" ಅನ್ನು ಪ್ರಿಂಟ್ ಮಾಡುತ್ತದೆ.
06:23	ಗಮನಿಸಿ: talk(), see() ಮತ್ತು move() ಮೆಥಡ್ ಗಳಿಗಾಗಿ Human ಕ್ಲಾಸ್ ತನ್ನದೇ ಆದ ಇಂಪ್ಲೆಮೆಂಟೇಶನ್ ಗಳನ್ನು ಹೊಂದಿದೆ.
06:31	ಮತ್ತು ಇವೇ ಮೆಥಡ್ ಗಳಿಗಾಗಿ Snake ಕ್ಲಾಸ್ ತನ್ನದೇ ಆದ ಇಂಪ್ಲೆಮೆಂಟೇಶನ್ ಗಳನ್ನು ಹೊಂದಿದೆ.
06:39	ಈಗ default package ಮೇಲೆ ರೈಟ್-ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು new > class ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ. ನಂತರ ಹೆಸರನ್ನು Demo ಎಂದು ಟೈಪ್ ಮಾಡಿ.
06:47	main ಮೆಥಡ್, ಈ ಕ್ಲಾಸ್ ಒಳಗೆ ಇರುವುದು.
06:51	ಹೀಗಾಗಿ main ಎಂದು ಟೈಪ್ ಮಾಡಿ ಮತ್ತು main ಮೆಥಡ್ ಅನ್ನು ರಚಿಸಲು ctrl+space ಒತ್ತಿ.
06:58	ಸ್ಕ್ರೀನ್ ನಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಟೈಪ್ ಮಾಡಿ.
07:01	ಈ ಸಾಲಿನಲ್ಲಿ ನಾವು Animal ಇಂಟರ್ಫೇಸ್ ಬಳಸಿ, Human ಕ್ಲಾಸ್ ಅನ್ನು ಇನ್ಸ್ಟಾಂಶಿಯೇಟ್ ಮಾಡುತ್ತೇವೆ.
07:07	ಇದನ್ನು Animal h equals new Human(); ಎಂದು ಬರೆಯುತ್ತೇವೆ.
07:14	ಈಗ ನಾವು ಈ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸಿ, h.talk(); h.see(); h.move(); ಎಂದು ವಿವಿಧ ಮೆಥಡ್ ಗಳನ್ನು ಇನ್ವೋಕ್ ಮಾಡಬಹುದು.
07:26	ನಂತರ, Animal ಇಂಟರ್ಫೇಸ್ ಬಳಸಿ ನಾವು Snake ಕ್ಲಾಸ್ ಅನ್ನು ಇನ್ಸ್ಟಾಂಶಿಯೇಟ್ ಮಾಡುತ್ತೇವೆ.
07:31	ನಾವೀಗ ಇಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಈ ಅಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸಿ ನಾವು ಬೇರೆ ಬೇರೆ ಮೆಥಡ್ ಗಳನ್ನು ಇನ್ವೋಕ್ ಮಾಡಬಹುದು.
07:38	ಈ Demo ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನಾವು ರನ್ ಮಾಡೋಣ.
07:41	ಇದಕ್ಕಾಗಿ ಕ್ಲಾಸ್ Demo ಮೇಲೆ ರೈಟ್-ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು Run as > Java Application ಆಯ್ಕೆಮಾಡಿ.
07:48	ಈಗ ನಾವು ಔಟ್ಪುಟ್ ಅನ್ನು ನೋಡಬಹುದು.
07:52	ಇವುಗಳನ್ನು, human class ನ ಆಬ್ಜೆಕ್ಟ್ h ಅನ್ನು ಬಳಸಿ ಇನ್ವೋಕ್ ಮಾಡಿದ talk(), see() ಮತ್ತು move() ಮೆಥಡ್ ಗಳ ಮೂಲಕ ಪ್ರಿಂಟ್ ಮಾಡಬಹುದು.
08:00	ಇವುಗಳನ್ನು, Snake class ಆಬ್ಜೆಕ್ಟ್ s ಅನ್ನು ಬಳಸಿ ಇನ್ವೋಕ್ ಮಾಡಿದ talk(), see() ಮತ್ತು move() ಮೆಥಡ್ ಗಳ ಮೂಲಕ ಪ್ರಿಂಟ್ ಮಾಡಬಹುದು.
08:08	ನಾವೀಗ ಇಂಟರ್ಫೇಸ್ ಮತ್ತು abstract ಕ್ಲಾಸ್ ಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ತಿಳಿಯೋಣ.
08:14	ಇಂಟರ್ಫೇಸ್ ನ ಎಲ್ಲಾ ಮೆಥಡ್ ಗಳು abstract ಆಗಿರಬೇಕು.
08:18	ಇಂಟರ್ಫೇಸ್ ಒಳಗೆ ಯಾವುದೇ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಗಳು, concrete ಮೆಥಡ್ ಗಳು,
08:23	static ಮೆಥಡ್ ಗಳು ಮತ್ತು main ಮೆಥಡ್ ಇರಬಾರದು.
08:28	ಆದರೆ abstract ಕ್ಲಾಸ್ ಇವೆಲ್ಲವುಗಳನ್ನು ತನ್ನೊಳಗೆ ಹೊಂದಿರಬಹುದು.
08:32	ಇಂಟರ್ಫೇಸ್ ನ ವೇರಿಯೇಬಲ್ ಗಳು static ಮತ್ತು final ಆಗಿರಬೇಕು.
08:38	Abstract ಕ್ಲಾಸಿಗೆ ಇಂತಹ ಯಾವುದೇ ನಿರ್ಬಂಧಗಳು ಇಲ್ಲ.
08:43	ನಾವೀಗ ಈ ಟ್ಯುಟೋರಿಯಲ್ ನ ಕೊನೆಗೆ ತಲುಪಿದ್ದೇವೆ. ಸಂಕ್ಷಿಪ್ತವಾಗಿ,
08:48	ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನಾವು: ಇಂಟರ್ಫೇಸ್ ರಚಿಸಲು,
08:53	implementation ಕ್ಲಾಸ್ ರಚಿಸಲು ಮತ್ತು,
08:56	ಇಂಟರ್ಫೇಸ್ ಗಳ ಬಳಕೆ ಇವುಗಳ ಬಗ್ಗೆ ಕಲಿತೆವು.
08:59	ಅಸೈನ್ಮೆಂಟ್ ಗಾಗಿ, brake() ಮತ್ತು run() ಎಂಬ ಮೆಥಡ್ ಗಳನ್ನು ಹೊಂದಿರುವ Vehicle ಎಂಬ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ರಚಿಸಿ.
09:07	fill(String type,int quantity), pay(int quantity,int price) ಮೆಥಡ್ ಗಳನ್ನು ಹೊಂದಿರುವ Fuel ಎಂಬ ಇನ್ನೊಂದು ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ರಚಿಸಿ.
09:19	Vehicle ಮತ್ತು Fuel ಇವೆರಡೂ ಇಂಟರ್ಫೇಸ್ ಗಳನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡುವ ಸಬ್-ಕ್ಲಾಸ್ Car ಅನ್ನು ರಚಿಸಿ.
09:26	ಇಲ್ಲಿ brake() ಮೆಥಡ್, "Car Applies Power brake" ಎಂದು ಪ್ರಿಂಟ್ ಮಾಡಬೇಕು.
09:30	ಮತ್ತು run() ಮೆಥಡ್, "Car is running on 4 wheels" ಎಂದು ಪ್ರಿಂಟ್ ಮಾಡಬೇಕು.
09:35	ಇದೇ ರೀತಿ, fill() ಮೆಥಡ್, ತುಂಬಿದ ಇಂಧನದ ಪ್ರಕಾರ ಮತ್ತು ಪ್ರಮಾಣವನ್ನು ಪ್ರಿಂಟ್ ಮಾಡಬಹುದು.
09:41	ಉದಾಹರಣೆಗೆ: 10 Litres of petrol.
09:44	pay() ಮೆಥಡ್ ಅನ್ನು, ಪಾವತಿ ಮಾಡಬೇಕಾದ ಹಣವನ್ನು ಪ್ರಿಂಟ್ ಮಾಡಲು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ: Pay Rs. 640
09:53	Vehicle ಮತ್ತು Fuel ಇವೆರಡೂ ಇಂಟರ್ಫೇಸ್ ಗಳನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡುವ ಇನ್ನೊಂದು ಸಬ್-ಕ್ಲಾಸ್ Bike ಅನ್ನು ರಚಿಸಿ.
10:00	ಇಲ್ಲಿ brake() ಮೆಥಡ್, "Bike Applies hand brake" ಎಂದು ಪ್ರಿಂಟ್ ಮಾಡಬಹುದು.
10:05	ಮತ್ತು run() ಮೆಥಡ್, “Bike is running on 2 wheels” ಎಂದು ಪ್ರಿಂಟ್ ಮಾಡಬಹುದು.
10:10	ನಂತರ, ಈ ಹಿಂದೆ ಹೇಳಿದಂತೆ fill() ಮತ್ತು pay() ಮೆಥಡ್ ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ.
10:15	ಕೊನೆಯದಾಗಿ,ಈ ಫಲಿತಾಂಶಗಳನ್ನು ನೋಡಲು main() ಮೆಥಡ್ ಹೊಂದಿರುವ Demo ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸಿ.
10:21	ಈ ಕೆಳಗಿನ ಲಿಂಕ್ ನಲ್ಲಿ ಇರುವ ವೀಡಿಯೊ, ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಪ್ರಾಜೆಕ್ಟ್ ನ ಸಾರಾಂಶವಾಗಿದೆ. ದಯವಿಟ್ಟು ಇದನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಿ ವೀಕ್ಷಿಸಿ.
10:29	ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಪ್ರಾಜೆಕ್ಟ್ ತಂಡವು ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಗಳನ್ನು ಬಳಸಿ ಕಾರ್ಯಶಾಲೆಗಳನ್ನು ನಡೆಸುತ್ತದೆ ಮತ್ತು ಆನ್ ಲೈನ್ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ತೇರ್ಗಡೆ ಹೊಂದಿದವರಿಗೆ ಪ್ರಮಾಣಪತ್ರಗಳನ್ನು ಕೊಡುತ್ತದೆ.
10:38	ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ, ದಯವಿಟ್ಟು ನಮಗೆ ಬರೆಯಿರಿ.
10:41	‘ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್’ ಪ್ರೊಜೆಕ್ಟ್, NMEICT, MHRD, ಭಾರತ ಸರ್ಕಾರದ ಅನುದಾನವನ್ನು ಪಡೆದಿದೆ.
10:48	ಕೆಳಗಿನ ಲಿಂಕ್ ನಲ್ಲಿ ಈ ಮಿಷನ್ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಲಭ್ಯವಿದೆ.
10:52	ಈ ಸ್ಕ್ರಿಪ್ಟ್, ಅಮಲ್ ಜ್ಯೋತಿ ಕಾಲೇಜ್ ಆಫ್ ಎಂಜಿನಿಯರಿಂಗ್ ನ ಮಾಹಿತಿ ತಂತ್ರಜ್ಞಾನ ವಿಭಾಗದ ಕೊಡುಗೆಯಾಗಿದೆ.
11:01	ಈ ಸ್ಕ್ರಿಪ್ಟ್ ನ ಅನುವಾದಕರು ಮಂಗಳೂರಿನಿಂದ ಮೆಲ್ವಿನ್ ಮತ್ತು ಧ್ವನಿ ಡಾ. ನವೀನ್ ಭಟ್, ಉಪ್ಪಿನಪಟ್ಟಣ. ಧನ್ಯವಾದಗಳು.

Contributors and Content Editors

Sandhya.np14