Java/C3/Java-Interfaces/Gujarati

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	સાથે જ interface એ constant 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