Java/C3/Java-Interfaces/Kannada

From Script | Spoken-Tutorial
Revision as of 17:07, 15 May 2020 by Sandhya.np14 (Talk | contribs)

Jump to: navigation, search
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 ಈಗ, ಇದನ್ನು Animalimplementation ಕ್ಲಾಸ್ ಆಗಿಸಲು ಹೀಗೆ ಟೈಪ್ ಮಾಡಿ: 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