Java/C3/Polymorphism/Gujarati
From Script | Spoken-Tutorial
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 તરફથી ભાષાંતર કરનાર હું, ચેતન સોલંકી વિદાય લઉં છું. જોવાબદ્દલ આભાર. |