Java/C3/Polymorphism/Oriya

Time	Narration
00:01	Javaରେ Polymorphism ଉପରେ ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲକୁ ସ୍ୱାଗତ
00:06	ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ରେ ଆମେ : ଜାଭାରେ Polymorphism Run-time polymorphism Virtual Method Invocation ଓ Compile-time polymorphism ବିଷୟରେ ଶିଖିବା
00:19	ଏଠାରେ ଆମେ ବ୍ୟବହାର କରୁଛୁ: ଉବୁଣ୍ଟୁ ଲିନକ୍ସ OS ଭର୍ସନ୍ 12.04 JDK 1.7 Eclipse 4.3.1
00:31	ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ଅନୁସରଣ କରିବାକୁ ଆପଣଙ୍କର Java ଓ Eclipse IDE ଉପରେ ମୌଳିକ ଜ୍ଞାନ ଥିବା ଦରକାର
00:37	ଆପଣଙ୍କର ନିଶ୍ଚିତରୂପେ Subclassing & Method overriding ଓ overloading ଉପରେ ଜ୍ଞାନ ଥିବା ଆବଶ୍ୟକ
00:43	ଯଦି ନାହିଁ, ତେବେ ସମ୍ପର୍କିତ Java ଟ୍ୟୁଟୋରିଆଲ୍ସ ପାଇଁ ଦୟାକରି ଆମ ୱେବସାଇଟ୍ ଦେଖନ୍ତୁ
00:48	ଗୋଟିଏ object ବିଭିନ୍ନ ପ୍ରକାରର ଆକାର ଗ୍ରହଣ କରିପାରୁଥିବା କ୍ଷମତା, Polymorphism ଅଟେ
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()କୁ ଓଭରରାଇଡ୍ କରିଥାଏ
02:08	getDetails() ମେଥଡକୁ Manager କ୍ଲାସ୍ ଅବଜେକ୍ଟ ଯାହା Manager ଅଟେ, ଦ୍ଵାରା କଲ୍ କରନ୍ତୁ
02:16	ସମ୍ପୂର୍ଣ୍ଣ ବିବରଣୀକୁ ପ୍ରିଣ୍ଟ କରିବା ପାଇଁ ଟାଇପ୍ କରନ୍ତୁ: system.out.println Details of Manager Class
02:28	ପ୍ରୋଗ୍ରାମକୁ Save କରିବା ସହିତ run କରନ୍ତୁ. ତେଣୁ ଆଉଟପୁଟରେ ଆମେ ଭେରିଏବଲ୍ departmentର ଭେଲ୍ୟୁକୁ ଦେଖିପାରିବା
02:37	ତେଣୁ runtimeରେ subclass ମେଥଡ୍ ପ୍ରୟୋଗ ହୋଇଛି
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 ଟେଷ୍ଟ ପାସ୍ କରିଥାଏ ତାହା polymorphic ଅଟେ
05:04	Javaରେ ସମସ୍ତ ଅବଜେକ୍ଟଗୁଡିକ polymorphic ଅଟନ୍ତି ଯେହେତୁ କୌଣସି ଅବଜେକ୍ଟ ନିଜର ପ୍ରକାର ତଥା କ୍ଲାସ୍ ଅବଜେକ୍ଟ ପାଇଁ IS-A ଟେଷ୍ଟ ପାସ୍ କରିବ
05:16	ଜଣେ ମ୍ୟାନେଜର୍ IS-A ଇମ୍ପ୍ଲୋୟୀ ଜଣେ ମ୍ୟାନେଜର୍ IS-A ମ୍ୟାନେଜର୍ ଜଣେ ମ୍ୟାନେଜର୍ IS-A ଅବଜେକ୍ଟ ଅଟେ
05:23	ଗୋଟିଏ ଅବଜେକ୍ଟକୁ ଏକ reference variable ମାଧ୍ୟମରେ ଆକ୍ସେସ୍ କରିବା ଏକମାତ୍ର ସମ୍ଭାବିତ ମାର୍ଗ ଅଟେ
05:29	Reference ଭେରିଏବଲଗୁଡିକ ଯେପରି 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	ଏହାର କାରଣ ହେଉଛି, Employee କ୍ଲାସ୍ ପାଇଁ setDepartment ମେଥଡର ଅସ୍ତିତ୍ଵ ନଥାଏ
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	Employee କ୍ଲାସକୁ ରେଫର୍ କରୁଥିବା ଅବଜେକ୍ଟ Manager ଏବଂ 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 କ୍ଲାସ୍ ପାଇଁ Employee ମେଥଡ୍ getDetails()କୁ ପ୍ରୟୋଗ କରାଯାଇଛି
08:49	emp1.getDetails() ସମୟରେ କମ୍ପାଇଲର୍ getDetails() ପାଇଁ Employee କ୍ଲାସକୁ ରେଫରେନ୍ସ କରିଥାଏ
08:57	ରନ୍ ସମୟରେ, JVM, Employee କ୍ଲାସରେ getDetails()କୁ ପ୍ରୟୋଗ କରିଥାଏ. ତେଣୁ ଆମେ Employee କ୍ଲାସର getDetails() ଅନୁସାରେ ଆଉଟପୁଟ୍ ପ୍ରାପ୍ତ କରିଥାଉ
09:08	ତେଣୁ JVM ଅବଜେକ୍ଟ ପାଇଁ ଉପଯୁକ୍ତ ମେଥଡକୁ କଲ୍ କରିଥାଏ ଯାହା ପ୍ରତ୍ୟେକ ଭେରିଏବଲକୁ ରେଫର୍ କରାଯାଇଛି
09:16	ଏହି ବିହେଭିଅରକୁ Virtual Method Invocation ଭାବେ ରେଫର୍ କରାଯାଇଥାଏ
09:21	ମେଥଡଗୁଡିକୁ Virtual Methods ଭାବେ ରେଫର୍ କରାଯାଇଥାଏ
09:26	Javaରେ ଥିବା ସମସ୍ତ ମେଥଡଗୁଡିକ ଏହି ଭଳି ବ୍ୟବହାର କରନ୍ତି
09:31	ଆମେ Virtual Method Invocation କ’ଣ ଭଲ ଭାବେ ଶିଖିଲେ
09:36	ଆମେ Compile-time polymorphism ଯାହା method overloading ଅଟେ, ଶିଖିଛେ
09:42	ଖୁବ୍ ଶୀଘ୍ର Compile time polymorphismକୁ ସଂକ୍ଷେପରେ ଶିଖିବା
09:47	Compile time polymorphismରେ, classର ଏକରୁ ଅଧିକ method ରହିପାରେ
09:53	ମେଥଡଗୁଡିକର ନାମ ସମାନ ହୋଇପାରେ କିନ୍ତୁ ବିଭିନ୍ନ ସଂଖ୍ୟକ ଆର୍ଗୁମେଣ୍ଟଗୁଡିକ ରହିପାରେ
09:59	କମ୍ପାଇଲର୍, compile-timeରେ ମେଥଡର କଲକୁ ଚିହ୍ନଟ କରିବା ପାଇଁ ସକ୍ଷମ ଅଟେ. ସେଥିପାଇଁ ଏହାକୁ compile time polymorphism କୁହାଯାଏ
10:09	ସଂକ୍ଷିପ୍ତରେ
10:11	ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ରେ ଆମେ ନିମ୍ନଲିଖିତ ଶିଖିଲେ: ଜାଭାରେ Polymorphism କ’ଣ? Run-time polymorphism Virtual Method Invocation ଓ Compile-time polymorphism
10:23	ଗୋଟିଏ ଆସାଇନମେଣ୍ଟ ଭାବେ, Vehicle ଓ Bike କ୍ଲାସ୍ ପାଇଁ ମେଥଡଗୁଡିକୁ ଓଭରରାଇଡ୍ କରନ୍ତୁ ଯେଉଁଗୁଡିକ ପୂର୍ବ ଟ୍ୟୁଟୋରିଆଲଗୁଡିକରେ ବ୍ୟବହୃତ ହୋଇଛି
10:32	ନିମ୍ନ ଲିଙ୍କରେ ଉପଲବ୍ଧ ଥିବା ଭିଡିଓ ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟକୁ ସାରାଂଶିତ କରେ. ଦୟାକରି ଏହାକୁ ଦେଖନ୍ତୁ
10:40	ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟ ଟିମ୍: ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ସ ବ୍ୟବହାର କରି କର୍ମଶାଳାମାନ ଚଲାନ୍ତି. ଅନଲାଇନ୍ ଟେଷ୍ଟ ପାସ୍ କରୁଥିବା ବ୍ୟକ୍ତିମାନଙ୍କୁ ପ୍ରମାଣପତ୍ର ଦିଅନ୍ତି. ଅଧିକ ବିବରଣୀ ପାଇଁ ଦୟାକରି ଆମକୁ ଲେଖନ୍ତୁ
10:51	ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟ ଭାରତ ସରକାରଙ୍କ MHRDର ICT ମାଧ୍ୟମରେ ରାଷ୍ଟ୍ରୀୟ ସାକ୍ଷରତା ମିଶନ୍ ଦ୍ୱାରା ସମର୍ଥିତ. ଏହି ମିସନ୍ ଉପରେ ଅଧିକ ବିବରଣୀ ଏହି ଲିଙ୍କରେ ଉପଲବ୍ଧ
11:03	ଆଇଆଇଟି ବମ୍ୱେ ତରଫରୁ ପ୍ରଦୀପ ଚନ୍ଦ୍ର ମହାପାତ୍ରଙ୍କ ସହ ମୁଁ ପ୍ରଭାସ ତ୍ରିପାଠୀ ଆପଣଙ୍କଠାରୁ ବିଦାୟ ନେଉଛି. ଆମ ସହିତ ଜଡ଼ିତ ହୋଇଥିବାରୁ ଧନ୍ୟବାଦ

Contributors and Content Editors

PoojaMoolya, Pradeep