Java/C3/Polymorphism/Gujarati

From Script | Spoken-Tutorial
Jump to: navigation, search
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 પરંતુ જ્યારે emp2setDepartment ને કોલ કરવાનો પ્રયાસ કરે છે ત્યારે, આપણને એક એરર મળ્યો છે.
07:54 તેનું કારણ આપેલ પ્રમાણે છે:

emp2.getDetails() દરમ્યાન કમ્પાઈલર Employee ક્લાસમાં getDetails() મેથડ જુએ છે.

08:05 તેથી, તે એરર દર્શાવતું નથી અને કોડને વેલીડેટ (માન્ય કરવું) કરે છે.
08:10 run સમયે, જો કે, JVMManager ક્લાસમાં 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 રન વખતે, JVMEmployee ક્લાસમાં getDetails() ને આવ્હાન કરે છે. તો, આપણને આઉટપુટ Employee ક્લાસનાં getDetails() અનુસાર મળે છે.
09:08 આમ JVMobject માટે યોગ્ય મેથડ કોલ કરે છે જેને પ્રત્યેક વેરીએબલમાં સંદર્ભિત કરાય છે.
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