Java/C3/Polymorphism/Gujarati

Time	Narration
00:01	જાવામાં Polymorphism પરનાં spoken-tutorial માં સ્વાગત છે.
00:06	આ ટ્યુટોરીયલમાં, આપણે આપેલ વિશે શીખીશું: જાવામાં Polymorphism , Run-time polymorphism ,Virtual Method Invocation અને Compile-time polymorphism.
00:19	અહીં આપણે વાપરી રહ્યા છીએ: Ubuntu Linux Version 12.04 ,JDK Version 1.7 અને Eclipse 4.3.1
00:31	આ ટ્યુટોરીયલનાં અનુસરણ માટે, તમને Java અને Eclipse IDE નું સાદું જ્ઞાન હોવું જરૂરી છે.
00:37	તમને Subclassing અને Method overriding તથા overloading નું જ્ઞાન હોવું અનિવાર્ય છે.
00:43	જો નથી, તો સંદર્ભિત Java ટ્યુટોરીયલો માટે, કૃપા કરી અમારી વેબસાઈટની મુલાકાત લો.
00:48	Polymorphism એ ઘણા સ્વરૂપો લેવાની object ની એક ક્ષમતા છે.
00:54	Polymorphism નાં મુખ્ય લાભો છે: 1. જટિલતામાં ઘટાડો અને 2. કોડ ફરીથી વાપરવાની ક્ષમતા.
01:03	Java માં, બે પ્રકારનાં polymorphism છે: Compile-time અને Run-time polymorphism.
01:11	Compile-time polymorphism ને આવશ્યકપણે Method overloading તરીકે સંદર્ભિત કરાવાય છે. તેને Static Binding પણ કહેવાય છે.
01:20	Run-time polymorphism ને આવશ્યકપણે Method overriding તરીકે સંદર્ભિત કરાવાય છે. તેને Dynamic Binding પણ કહેવાય છે.
01:29	આપણે પહેલાથી જ Run-time polymorphism શીખ્યા છીએ એટલે કે Method overriding.
01:35	ચાલો Eclipse IDE પર આવીએ. પાછલા ટ્યુટોરીયલમાં મેં પહેલાથી જ MyProject નામનો પ્રોજેક્ટ બનાવ્યો છે.
01:44	ચાલો Using final keyword ટ્યુટોરીયલની કોડ ફાઈલો લઈએ.
01:49	Employee ક્લાસ એ parent class છે.
01:52	Manager ક્લાસ એ subclass છે.
01:55	Manager ક્લાસ એક વધારાનું વેરીએબલ (ચલ) department ધરાવે છે.
02:01	Manager ક્લાસ getDetails() મેથડ Employee ક્લાસ getDetails(). મેથડને override કરે છે.
02:08	આપણે Manager ક્લાસ object એટલે કે Manager દ્વારા getDetails() મેથડ કોલ (આવ્હાન) કરી રહ્યા છીએ.
02:16	વિગતો પ્રિંટ કરવા માટે, ટાઈપ કરો: system.out.println Details of Manager Class.
02:28	પ્રોગ્રામને Save કરીને run કરીએ. તો, આપણે department વેરીએબલ વેલ્યુ આઉટપુટમાં જોઈ શકીએ છીએ.
02:37	તેથી subclassમેથડ runtime પર આવ્હાન કરાયું છે.
02:42	મેથડ ઇનવોકેશન (આવ્હાન પ્રક્રિયા) JVM દ્વારા નક્કી થાય છે, ન કે કમ્પાઈલર દ્વારા.
02:48	તેથી તેને Runtime polymorphism અથવા method overriding તરીકે ઓળખાવાય છે.
02:55	આપણે શીખ્યા કે Run time polymorphism શું છે.
02:58	હવે ચાલો શીખીએ Virtual Method Invocation.
03:03	Eclipse IDE માં Employee ક્લાસ પર આવીએ.
03:07	વેરીએબલ name માટે static અને final કીવર્ડ રદ્દ કરીએ.
03:13	setName મેથડને અનકમેંટ (ટીપ્પણી કાઢવી) કરીએ.
03:16	static બ્લોક રદ્દ કરીએ. ફાઈલને Save કરીએ.
03:21	TestEmployee ક્લાસ પર આવીએ. વેલ્યુ ઈન્સ્ટન્સ (દ્રષ્ટાંત), manager.setName(“Nikkita Dinesh”) ને અનકમેંટ (ટીપ્પણી કાઢવી) કરીએ;
03:31	આપણે આ ઈન્સ્ટન્સ અનકમેંટ કરી દીધું છે, જેવું કે આપણે Empolyee ક્લાસમાં setName() મેથડ અનકમેંટ કર્યું છે.
03:38	હવે, ચાલો Employee ક્લાસ સંદર્ભ માટે Employee ઓબ્જેક્ટ emp1 નો પ્રારંભ કરીએ.
03:46	ટાઈપ કરો: Employee emp1 = new Employee open and close parenthesis semicolon
03:57	ચાલો Employee ક્લાસ માટે setEmail અને setName માટેની વેલ્યુ ઈનીશલાઈઝ (પ્રારંભ કરવું) કરીએ.
04:03	ટાઈપ કરો: emp1.setName("Jayesh"); emp1.setEmail("pqr@gmail.com");
04:16	કર્મચારીઓની વિગતો પ્રિંટ કરવા માટે, ટાઈપ કરો: System.out.println("Details of Employee class:" emp1.getDetails()) semicolon
04:37	ચાલો Employee ક્લાસ સંદર્ભ માટે Manager ઓબ્જેક્ટ emp2 પ્રારંભિત કરીએ એટલે કે. ટાઈપ કરો: Employee emp2 = new Manager open and close parenthesis semicolon
04:54	આપણે આવું કરવામાં સમર્થ છીએ કારણ કે કોઈપણ Java object જે એકથી વધુ IS-A પરીક્ષા પાસ કરે છે, તે પોલીમોર્ફિક છે.
05:04	જાવામાં, તમામ ઓબ્જેક્ટો પોલીમોર્ફિક છે, કારણ કોઈપણ ઓબ્જેક્ટ તેમનાં પોતાના પ્રકાર અને ક્લાસ ઓબ્જેક્ટ માટે IS-A પરીક્ષા પાસ કરશે.
05:16	એક મેનેજર (સંચાલક) IS-A કર્મચારી એક મેનેજર (સંચાલક) IS-A મેનેજર (સંચાલક) એક મેનેજર (સંચાલક) IS-A ઓબ્જેક્ટ.
05:23	ઓબ્જેક્ટને એક્સેસ કરવાનો શક્ય માર્ગ માત્ર reference variable મારફતે છે.
05:29	Reference variables જેમ કે emp1, emp2 અને manager.
05:36	અહીં, આપણે બે Manager ઓબ્જેક્ટો પ્રારંભિત કર્યા છે: એક જે Employee ક્લાસને સંદર્ભે છે. અને બીજું જે Manager ક્લાસને સંદર્ભે છે.
05:47	ચાલો emp2 ઓબ્જેક્ટ વાપરીને setEmail, setName અને setDepartment માટેની વેલ્યુઓ ઈનીશલાઈઝ કરીએ.
05:55	ટાઈપ કરીએ, emp2.setName("Ankita"); emp2.setEmail(“xyz@gmail.com”); emp2.setDepartment(“IT”);
06:14	આપણે જોઈએ છીએ કે અહીં એક એરર મળે છે, "The method setDepartment(String) is undefined for the type Employee".
06:23	આ એટલા માટે કારણ કે, setDepartment મેથડ એ Employee ક્લાસ માટે હયાત નથી.
06:30	તો, રદ્દ કરો લાઈન: emp2.setDepartment("IT");
06:37	વિગતો પ્રિંટ કરવા માટે, ટાઈપ કરો: System.out.println("Details of Manager class:" emp2.getDetails()) semicolon
06:55	પ્રોગ્રામને Save કરીને Run કરીએ.
06:58	અહીં આઉટપુટમાં, આપણને Manager of: ખાલી મળે છે.
07:04	આ એટલા માટે કારણ કે, આપણે emp2 વાપરીને Manager ક્લાસમાં department ઈનીશલાઈઝ કર્યું નથી.
07:12	ડેમો હેતુસર, ચાલો મૂળભૂત department ને IT રહેવા દઈએ.
07:17	તો, Manager ક્લાસ પર જઈએ અને department માટે વેલ્યુ ઈનીશલાઈઝ કરીએ.
07:25	પ્રોગ્રામ Save કરીને run કરીએ.
07:28	આપણને આઉટપુટ મળે છે: Employee ઓબ્જેક્ટ એ Employee ક્લાસનો સંદર્ભ લઇ રહ્યો છે,
07:34	Manager ઓબ્જેક્ટ Employee ક્લાસનો સંદર્ભ લઇ રહ્યો છે અને Manager ઓબ્જેક્ટ Manager ક્લાસનો સંદર્ભ લઇ રહ્યો છે.
07:42	અહીં આપણે જોઈએ છીએ કે Manager ક્લાસનાં getDetails() મેથડને emp2 દ્વારા કોલ (આવ્હાન) કરાયું છે.
07:49	પરંતુ જ્યારે emp2 એ setDepartment ને કોલ કરવાનો પ્રયાસ કરે છે ત્યારે, આપણને એક એરર મળ્યો છે.
07:54	તેનું કારણ આપેલ પ્રમાણે છે: emp2.getDetails() દરમ્યાન કમ્પાઈલર Employee ક્લાસમાં getDetails() મેથડ જુએ છે.
08:05	તેથી, તે એરર દર્શાવતું નથી અને કોડને વેલીડેટ (માન્ય કરવું) કરે છે.
08:10	run સમયે, જો કે, JVM એ Manager ક્લાસમાં getDetails() આવ્હાન કરે છે કારણ કે Manager ક્લાસનું getDetails() એ Employee ક્લાસનાં getDetails() ને ઓવરરાઈડ કરે છે.
08:24	તો, આપણને આઉટપુટ Manager ક્લાસનાં getDetails() અનુસાર મળે છે. પરંતુ કમ્પાઈલરને Employee ક્લાસમાં setDepartment મેથડ દેખાતું નથી.
08:36	તેથી, emp2 દ્વારા કોલ કરેલ setDepartment કિસ્સામાં તે એક એરર દર્શાવે છે.
08:43	અહીં, Employee મેથડ getDetails() એ Employee ક્લાસ માટે આવ્હાન થયું છે.
08:49	કમ્પાઈલર emp1.getDetails() દરમ્યાન getDetails() માટે Employee ક્લાસને સંદર્ભે છે.
08:57	રન વખતે, JVM એ Employee ક્લાસમાં getDetails() ને આવ્હાન કરે છે. તો, આપણને આઉટપુટ Employee ક્લાસનાં getDetails() અનુસાર મળે છે.
09:08	આમ JVM એ object માટે યોગ્ય મેથડ કોલ કરે છે જેને પ્રત્યેક વેરીએબલમાં સંદર્ભિત કરાય છે.
09:16	આ વર્તણૂકને Virtual Method Invocation તરીકે સંદર્ભિત કરાય છે.
09:21	મેથડો Virtual Methods તરીકે સંદર્ભિત કરાવાય છે.
09:26	Java માં તમામ મેથડો આ પ્રકારે વર્તણુક કરે છે.
09:31	Virtual Method Invocation શું છે તે આપણે સફળતાપૂર્વક શીખ્યા.
09:36	Compile-time polymorphism આપણે પહેલાથી જ શીખ્યું છે એટલે કે મેથડ ઓવરલોડીંગ.
09:42	ચાલો Compile time polymorphism વિશે વિસ્તારપૂર્વક ટૂંક સમયમાં જાણીએ.
09:47	Compile time polymorphism માં, class એકથી વધુ method ધરાવી શકે છે.
09:53	મેથડો સમાન નામ ધરાવે છે પરંતુ વિવિધ આર્ગ્યુમેન્ટો (દલીલો) ની સંખ્યા સાથે.
09:59	કમ્પાઈલર કમ્પાઈલ-સમય દરમ્યાન મેથડ કોલને સુધારવામાં સક્ષમ છે. તેથી જ આને compile time polymorphism તરીકે ઓળખવામાં આવે છે.
10:09	તો, ચાલો સારાંશ લઈએ.
10:11	આ ટ્યુટોરીયલમાં, આપણે શીખ્યા: જાવામાં Polymorphism શું છે? , Run-time polymorphism , Virtual Method Invocation અને Compile-time polymorphism.
10:23	એસાઈનમેંટ તરીકે, આપણે પાછલા ટ્યુટોરીયલોમાં વાપરેલ Vehicle અને Bike class માટે મેથડો ઓવરરાઈડ કરો.
10:32	આપેલ લીંક પર ઉપલબ્ધ વિડીઓ સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટનો સારાંશ આપે છે. કૃપા કરી તે જુઓ.
10:40	સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટીમ: વર્કશોપોનું આયોજન કરે છે અને જેઓ ઓનલાઈન પરીક્ષા પાસ કરે છે તેમને પ્રમાણપત્રો આપે છે. વધુ વિગત માટે, કૃપા કરી અમને લખો.
10:51	સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ આઇસીટી, એમએચઆરડી, ભારત સરકાર દ્વારા શિક્ષણ પર નેશનલ મિશન દ્વારા આધારભૂત છે. આ મિશન પર વધુ માહિતી આ લીંક પર ઉપલબ્ધ છે.
11:03	અહીં આ ટ્યુટોરીયલ સમાપ્ત થાય છે. IIT Bombay તરફથી ભાષાંતર કરનાર હું, ચેતન સોલંકી વિદાય લઉં છું. જોવાબદ્દલ આભાર.

Contributors and Content Editors

Jyotisolanki