Java/C3/Java-Interfaces/Gujarati

From Script | Spoken-Tutorial
Jump to: navigation, search
Time
Narration
00:01 Java Interfaces પરનાં Spoken Tutorial માં સ્વાગત છે.
00:05 આ ટ્યુટોરીયલમાં, આપણે આપેલ વિશે શીખીશું: interface બનાવવું
00:10 Implementation classes બનાવવા અને Interface નો ઉપયોગ.
00:16 આ ટ્યુટોરીયલ માટે, હું વાપરી રહ્યો છું: Ubuntu 12.04 ,JDK 1.7 અને Eclipse 4.3.1
00:28 આ ટ્યુટોરીયલનાં અનુસરણ માટે, તમને સામાન્ય Java અને Eclipse IDE નું જ્ઞાન હોવું અનિવાર્ય છે.
00:36 સાથે જ તમને Java માં subclassing અને Abstract classes નું પણ જ્ઞાન હોવું જોઈએ.
00:42 જો નથી, તો સંદર્ભિત જાવા ટ્યુટોરીયલો માટે, કૃપા કરી દર્શાવેલ લીંકની મુલાકાત લો.
00:48 પહેલા ચાલો સમજીએ કે interface શું છે.
00:52 એક ઈન્ટરફેસ abstract મેથડો અને static data members નો એક સેટ (ગણ કે સમૂહ) ધરાવે છે.
00:58 તે બોડી સિવાયનાં methods નાં સમૂહની સહીઓને વ્યાખ્યાયિત કરે છે.
01:04 તે interface કીવર્ડનો ઉપયોગ કરીને જાહેર કરવામાં આવે છે.
01:08 હવે આપણે Eclipse પર જશું અને InterfaceDemo નામનો એક નવો પ્રોજેક્ટ બનાવીશું.
01:15 અહીં, આપણે interfaces નાં વપરાશને ડેમોનસ્ટ્રેટ કરવા માટે જરૂરી classes અને interface બનાવીશું.
01:24 src ફોલ્ડર પર જમણું-ક્લિક કરો અને ક્લિક કરો New > Interface.
01:30 નામ Animal તરીકે ટાઈપ કરો અને Enter દબાવો.
01:34 નોંધ લો “interface” કીવર્ડનો ઉપયોગ ઇન્ટરફેસને વ્યાખ્યાયિત કરવા માટે થાય છે.
01:39 હવે સ્ક્રીન પર દર્શાવ્યા પ્રમાણે કોડ ટાઈપ કરો.
01:43 અહીં, interface નું નામ Animal છે.
01:46 તે ત્રણ એબસ્ટ્રેક્ટ મેથડો ધરાવે છે talk(), see() અને move().
01:52 ઈન્ટરફેસમાં આવા તમામ methods સર્વથા public અને abstract છે.
01:59 સાથે જ interfaceconstant variable ડીકલેરેશન (જાહેરનામું) પણ ધરાવી શકે છે.
02:04 અહીં, અચલ સ્ટ્રીંગ વેલ્યુ “Mammal” ને વેરીએબલ (ચલ) “type1” ને એસાઈન કરાયી છે.
02:12 અને “Reptiles” એ વેરીએબલ (ચલ) “type2” ને એસાઈન કરાયી છે.
02:16 interface માં વ્યાખ્યાયિત કરેલ તમામ constant વેલ્યુઓ સર્વથા public, static અને final છે.
02:25 આગળ આપણે ઉદાહરણ સહીત interface માટે implementation class જોશું.
02:32 અહીં, Human એ ક્લાસ છે જે Animal ઇન્ટરફેસને અમલીકરણ કરે છે.
02:38 તો, તેણે મેથડો talk(), see() અને move() માટે અમલીકરણો પ્રદાન કરવું જોઈએ.
02:45 એક class બહુવિધ ઇન્ટરફેસોનું પણ અમલીકરણ કરી શકે છે.
02:49 ઉદાહરણમાં દર્શાવ્યા પ્રમાણે, ક્લાસ Human એ બે ઇન્ટરફેસો Animal અને Action નું અમલીકરણ કરે છે.
02:57 નોંધ લો સિન્ટેક્સ (વાક્યરચના) માં વપરાતું comma operator એ વિવિધ ઇન્ટરફેસોને ઓળખવા માટે છે.
03:04 હવે આ class Animal અને Action ઇન્ટરફેસો આ બંનેમાં આવેલ તમામ abstract methods ને અમલીકરણો પ્રદાન કરવું જોઈએ.
03:13 અહીં આ આકૃતિ એક અમલ સંબંધને રજુ કરે છે.
03:18 Animal ક્લાસ એ એક interface છે.
03:22 Human અને Snake ક્લાસો આ બે implementation classes છે.
03:28 Human ક્લાસ એ talk(), see() અને move() મેથડો માટે તેનાં પોતાનાં વિભિન્ન અમલીકરણો પ્રદાન કરે છે.
03:36 અને, Snake ક્લાસ એ talk(), see() અને move() મેથડો માટે તેનાં પોતાનાં વિભિન્ન અમલીકરણો પ્રદાન કરે છે.
03:45 ચાલો સેમ્પલ (નમુનો) પ્રોગ્રામ વડે interfaces નો વપરાશ સમજીએ.
03:50 default package પર જમણું-ક્લિક કરો અને Human નામનો એક class બનાવો.
03:56 હવે, આને Animal નું એક implementation class બનાવવા માટે, ટાઈપ કરો: implements Animal.
04:04 હવે, આપણે જોઈ શકીએ છીએ કે Eclipse IDE માં એક એરર આવે છે.
04:09 આ એરર દર્શાવે છે કે આપણે Animal interface ને 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" અર્ધવિરામ.
04:54 ચાલો હવે see() મેથડનું અમલીકરણ કરીએ.
04:57 તો, ટાઈપ કરો: public void see( ) છગડીયા કૌંસમાં ટાઈપ કરો System.out.println અવતરણમાં "I can see all colors" અર્ધવિરામ.
05:11 સાથે જ આપણે move() મેથડને પણ વ્યાખ્યાયિત કરવું જોઈએ.
05:14 તો, ટાઈપ કરો: public void move( ) છગડીયા કૌંસમાં ટાઈપ કરો System.out.println અવતરણમાં "I move by walking" અર્ધવિરામ.
05:29 નોંધ લો એકવાર તમામ methods નું અમલીકરણ થવા પર, એરર જતું રહે છે.
05:34 આગળ આપણે Snake ક્લાસને વ્યાખ્યાયિત કરવાનું જોશું.
05:38 મેં તેને પહેલાથી જ મારા project માં બનાવ્યું છે.
05:42 કૃપા કરી snake class ને તમારા project માં બનાવો અને સ્ક્રીન પર દર્શાવ્યા પ્રમાણે આપેલ કોડ ટાઈપ કરો.
05:49 હવે ચાલો કોડ મારફતે જઈએ.
05:52 આપણે જોઈ શકીએ છીએ કે Animal interface- talk(), see() અને move() નાં તમામ methods એ આ class માં અમલીકરણ થયા છે.
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 નોંધ લો Human ક્લાસનાં તેના પોતાના talk(), see() અને move() મેથડોનાં અમલીકરણો છે.
06:31 અને, Snake ક્લાસનાં તેના પોતાના talk(), see() અને move() મેથડોનાં અમલીકરણો છે.
06:39 હવે, ડીફોલ્ટ પેકેજ (મૂળભૂત પેકેજ) પર જમણું-ક્લિક કરો, ક્લિક કરો new > class અને ત્યારબાદ નામને Demo તરીકે ટાઈપ કરો.
06:47 class અંતર્ગત, આપણી પાસે main મેથડ રહેશે.
06:51 તો, ટાઈપ કરો main અને ત્યારબાદ main મેથડ ઉત્પન્ન કરવા માટે ctrl+space દબાવો.
06:58 સ્ક્રીન પર દર્શાવ્યા પ્રમાણે આપેલ કોડ ટાઈપ કરો.
07:01 આ લાઈનમાં, આપણે Animal ઇન્ટરફેસ વાપરીને Human class તત્કાલિત કરીએ છીએ.
07:07 આને આ રીતે રજુ કરાય છે Animal h બરાબર new Human();
07:14 હવે આપણે h.talk(); h.see(); h.move(); તરીકે આ object વાપરીને વિભિન્ન મેથડોનું આવ્હાન કરી શકીએ છીએ.
07:26 આગળ, આપણે Animal ઇન્ટરફેસ વાપરીને Snake ક્લાસ તત્કાલિત કરીએ છીએ.
07:31 હવે આપણે દર્શાવ્યા પ્રમાણે આ object વાપરીને વિભિન્ન મેથડોનું આવ્હાન કરી શકીએ છીએ.
07:38 હવે, ચાલો આ Demo પ્રોગ્રામ run કરીએ.
07:41 તો, ક્લાસ Demo પર જમણું-ક્લિક કરો અને ત્યારબાદ પસંદ કરો Run as > Java Application.
07:48 આપણે આઉટપુટ જોઈ શકીએ છીએ.
07:52 આ પ્રિંટ થયું છે talk(), see() અને move() મેથડો દ્વારા જે કે human class object h વાપરીને આવ્હાન કરાયું છે.
08:00 આ પ્રિંટ થયું છે talk(), see() અને move() મેથડો દ્વારા જે કે Snake class object s વાપરીને આવ્હાન કરાયું છે.
08:08 હવે, interface અને abstract class વચ્ચેનાં તફાવતનું અન્વેષણ કરીએ.
08:14 ઇન્ટરફેસમાં તમામ મેથડો abstract હોવા જોઈએ.
08:18 ઇન્ટરફેસ અંતર્ગત, કોઈપણ constructors,
08:23 concrete methods, static methods અને main method હોવા ન જોઈએ.
08:28 પરંતુ abstract class પોતાનામાં આ તમામ ધરાવી શકે છે.
08:32 ઇન્ટરફેસમાં વેરીએબલો static અને final હોવા જોઈએ.
08:38 abstract class માટે આવા કોઈપણ અંકુશો નથી.
08:43 અહીં આ ટ્યુટોરીયલ સમાપ્ત થાય છે. ચાલો સારાંશ લઈએ.
08:48 આ ટ્યુટોરીયલમાં, આપણે આપેલ વિશે શીખ્યા: Interface બનાવવું
08:53 implementation class બનાવવું અને
08:56 interfaces નાં ઉપયોગ.
08:59 એસાઈનમેંટ તરીકે, Vehicle ઇન્ટરફેસ બનાવો જે brake() અને run() મેથડો ધરાવે.
09:07 બીજો એક ઇન્ટરફેસ Fuel બનાવો જે આપેલ મેથડો ધરાવે. fill(String type,int quantity), pay(int quantity,int price).
09:19 એક સબક્લાસ Car બનાવો જે બંને ઇન્ટરફેસો Vehicle અને Fuel નું અમલીકરણ કરે.
09:26 અહીં, brake મેથડે પ્રિંટ કરવું જોઈએ "Car Applies Power brake".
09:30 અને run મેથડે પ્રિંટ કરવું જોઈએ "Car is running on 4 wheels".
09:35 એજ પ્રમાણે fill() મેથડ ભરેલ બળતણનો પ્રકાર અને માત્રા પ્રિંટ કરી શકે છે.
09:41 ઉદાહરણ તરીકે: 10 લીટર પેટ્રોલ.
09:44 pay() મેથડનો ઉપયોગ ચુકવવાની કિમતને પ્રિંટ કરવા માટે કરી શકાય છે. ઉદાહરણ તરીકે: રૂ. 640 ચૂકવો.
09:53 બીજો એક સબક્લાસ Bike બનાવો જે ફરીથી બંને ઇન્ટરફેસો Vehicle અને Fuel નું અમલીકરણ કરે.
10:00 અહીં, brake મેથડ પ્રિંટ કરી શકે છે "Bike Applies hand brake".
10:05 અને run મેથડ પ્રિંટ કરી શકે છે “Bike is running on 2 wheels”.
10:10 આગળ, પહેલા સમજાવ્યા અનુસાર fill() અને pay() મેથડોનું અમલીકરણ કરો.
10:15 છેલ્લે પરિણામોને ચકાસવા માટે main મેથડ ધરાવતું એક Demo class બનાવો.
10:21 આપેલ લીંક પર ઉપલબ્ધ વિડીઓ સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટનો સારાંશ આપે છે. કૃપા કરી તે ડાઉનલોડ કરીને જુઓ.
10:29 સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટીમ: સ્પોકન ટ્યુટોરીયલોનાં મદદથી વર્કશોપોનું આયોજન કરે છે અને ઓનલાઈન પરીક્ષા પાસ કરવા પર પ્રમાણપત્રો આપે છે.
10:38 વધુ વિગતો માટે, કૃપા કરી અમને લખો.
10:41 Spoken Tutorial Project ને ફાળો એનએમઈઆઈસીટી, એમએચઆરડી, ભારત સરકાર દ્વારા અપાયો છે.
10:48 આ મિશન પર વધુ માહીતી દર્શાવેલ લીંક પર ઉપલબ્ધ છે.
10:52 ડિપાર્ટમેન્ટ ઓફ ઇન્ફર્મેશન ટેક્નોલોજી, અમલ જ્યોતિ કોલેજ ઓફ એન્જિનિયરીંગ દ્વારા: આ સ્ક્રીપ્ટને ફાળો અપાયો છે.
11:01 IIT Bombay તરફથી ભાષાંતર કરનાર હું, ચેતન સોલંકી વિદાય લઉં છું. જોડાવાબદ્દલ આભાર.

Contributors and Content Editors

Jyotisolanki