ආයුබෝවන්! ඔන්න යාලුවනේ මං අදත් ආවා object oriented concept එකේ තියන අලුත් පාඩමක් එක්ක.සුපුරුදු විදියට ඔයාලා හැමෝම සාදරයෙන් පිලිගන්නවා.අද පාඩම පටන් ගන්න ඉස්සරින් කලින් පාඩම පොඩ්ඩක් මතක් කරලා ඉන්නම්කෝ.කලින් පාඩමේදී අපි කතා කලා method overriding ගැනයි super keyword එක ගැනයි.method overriding කියලා අපි කිව්වේ මොකක්ද…method overriding කියලා අපි කිව්වේ super class එකේ තියන method එකක් sub class එකේදි ඒ method එකේ body එක වෙනස් කරලා පාවිච්චි කරන එකට.super keyword එකෙන් කරන්නේ , super class එකේ method එකක් sub class එකේදි override කලාම ඒ override කරපු එකෙන් super class එකේ ඒ method එක සැගවෙනවා. ඒ සැගවුනු super class method එක එලියට ඇදලා ගන්න තමයි අපි super keyword එක පාවිච්චි කලේ.ඔන්න ඕවා දෙක ගැන තමයි අපි කලින් පාඩමේදී කතා කලේ..තවත් හරියට මතක නැතිනම් අපේ කලින් පාඩම ගිහින් බලන් එන්නකෝ.
හරි එහෙනම් ඕං මං අද පාඩම පටන් ගන්නවා.oop වල තියෙන මීලඟ feature එක හරි හැටි තේරුම් ගන්න නම් මේ පාඩම හරියටම දැනගෙන ඉන්න වෙනවා..අද පාඩම හරි හැටි තේරුම් ගන්න නම් inheritance පාඩම හොදටම මතක තියෙන්න ඕනි.. inheritance කියන්නෙ මොකද්ද කියලා පොඩි හරි අමතක වීමක් තියනවානම් ඒ පාඩමත් ඉක්මනින් බලන් එන්නකෝ..හරි ඉස්සරෝම කියන්නම් මං upcasting කියන්නෙ මොකක්ද කියලා.upcasting කියලා කියන්නෙ, class දෙකක් inherit කලාම super class එකකුයි sub class එකකුයි හැදෙනවනේ ඒ හැදෙන sub class object එකක් super class reference variable එකක store කර ගන්න එකට තමයි upcasting කියලා කියන්නේ.
හරි මං ගන්නම්කො මෙන්න මේ උදාහරණය ඔයාලට මේක පැහැදිලි කරන්න.මම හදනවා class දෙකක්..එකක් doctor කියලා ගන්නවා අනික teacher කියලා ගන්නවා.මෙන්න මේ classes දෙකේ තියන attributes හා methods මේ විදියට define කරලා teacher class එකයි doctor class එකයි හදා ගන්නවා.
දැන් ඔයාලට පේනවා මේ class දෙකේම පොදු attributes හා methods තියනවා කියලා.ඒ ටික පොදු class එකකට මං දා ගන්නවා.ඒ දා ගත්තු පොදු class එකට මං නමක් දෙනවා person කියලා..ඒ person class එකෙන් doctor හා teacher කියන classes දෙකම inherit කරනවා.එතකොට code එක මෙන්න මේ විදියයි නේද..
class Person{
String name;
int age;
String Gender;
void eat(){
// statements
}
void walk(){
// statements
}
}
class Teacher extends Person{
Teacher(){
System.out.println("teacher object is created !");
}
String Designation;
int salary;
void teach(){
// statements
}
void takeExams(){
// statements
}
}
class Doctor extends Person{
String Designation;
String salary;
void ChackUp(){
// statements
}
void presribe(){
// statements
}
}
ඔතනට එනකන් තේරුනානෙ නේද…ඔතනට එනකන්ම තිබ්බෙ inheritance ගැන..අන්න ඒකයි මං කලින්ම කිව්වෙ මේ පාඩම තේරුම් ගන්න නම් inheritance පාඩම හොදට මතක තියෙන්න ඔනි කියලා..හරි අපි දැන් class දෙක inherit කලානෙ.එතකොට අපෙ super class එක වෙනවා person class එක.sub classes වෙනවා teacher class එකයි doctor class එකයි.එතනට එනකන් නම් අව්ලක් නෑනෙ නේද..එහෙනම් අපි ඊලග පියවරට යං.අපිට දැන් sub classes දෙකක් තියනවනේ.ඒකෙන් එකක් මං ගන්නවා…ඔයාලට මේ දෙකෙන් කැමති එකක් ගන්න පුලුවන්..හරි මං ගන්නවා teacher කියන class එක.තව super class එකත් මං ගන්නවා. එතකොට මං ගත්තා super class එකයි teacher කියන sub class එකයි.දැන් මං හදා ගන්නවා අපේ super class එකේ reference එකක් මෙන්න මේ විදියට.
class Upcasting&Downcasting{
public static void main(String a[]){
Person person1;
}
}
හරි ඔන්න ඔය විදියට super class reference variable එකක් හදා ගත්තා.ඊට පස්සෙ මං අපි අර ගත්ත sub class එක තියෙන්නෙ, ඒ කිව්වෙ අපෙ අර teacher class එක, අන්න ඒ teacher class එකේ object එකක් හදලා අපි අර හදා ගත්ත super class reference variable එකට දා ගන්නවා මෙන්න මේ වගේ.
class Upcasting&Downcasting{
public static void main(String a[]){
Person person1 = new Teacher();
}
}
ඔන්න ඕකට තමයි upcasting කියන්නේ.කෙටියෙන් කියනවානම්, upcasting කියලා කියන්නෙ, class දෙකක් inherit කලාම super class එකකුයි sub class එකකුයි හැදෙනවනේ ඒ හැදෙන sub class object එකක් super class reference variable එකක store කර ගන්න එකට තමයි upcasting කියලා කියන්නේ.
ඇත්ටම තව පොඩ්ඩක් practicaly හිතලා බලන්නකෝ මේක ගැන.අපි cast කරන්න ගත්තේ super class එක විදියට Person class එකයි Sub class එක විදියට teacher class එකයි.upcasting වලදි කලේ sub class එකේ object එකක් හදාගෙන ඒ object එක super class reference variable එකකට දා ගත්ත එකනේ.ඔන් ඕක පොඩ්ඩක් මෙහෙමත් හිතන්නකෝ… අපෙ sub class එකේ object එකක් හදනවා කියන්නේ teacher object එකක් හදන එකටනේ..අපෙ උදාහරනයේ හැටියට super class reference එකක් කියන්නේ person කෙනෙක් තියා ගන්න පුලුවන් variable එකක් හදනවා කියන එකටයි.හැබැයි teacher කියන්නෙත් තවත් එක්තරා ආකාරයක person කෙනෙක් නේද…තවත් විදියකින් කියනවානම් teacher කියන්නේ person කියන ලොකු කුලකයේ තියන පොඩ් උපකුලකයක්…ඒ කියන්නෙ person කෙනෙක් තියා ගන්න හදපු reference variable එකකට teacher කෙනෙක් තියා ගන්න පුලුවන්..ඇයියේ කියනවා නම් teacher කියන්නෙත් එක්තරා විදියක person කෙනෙක් නිසා..ඔන්න ඔය super class reference variable එකක sub class object එකක් තියා ගන්න එකට අපි කියනවා upcasting කියලා .
පොඩ්ඩක් හිතන්න ඕකෙ අනික් පැත්ත ගැන..ඒ කියන්නෙ..sub class reference variable එකක super class object එකක් store කරන්න පුලුවන්ද කියලා.හරියට මෙන්න මේ වගේ.
Teacher teacher1 = new Person();
අපෙ උදාහරනයේ හැටියට නම් teacher කෙනෙක් තියා ගන්න reference variable එකක් හදලා ඒකේ person කෙනෙක් store කරනවා වගේ දෙයක්.ඇත්තටම පුලුවන්ද මේ වැඩේ කරන්න???.බැහැ නේද…ඇයි යාලුවනේ හිතලා බලන්නකෝ teacher කෙනෙක් තියා ගන්න ඔයා හදනවා reference variable එකක්. ඒකෙ ඕනෑම person කෙනෙක් දාන්න පුලුවන්ද? බැහැ නේද..කොටින්ම කිව්වොත් teacher කියන කුලකය ඇතුලේ හැම person කෙනෙක්ම ඉන්නවද?? නැහැ නේද…
Teacher teacher1 = new Person();
ඔන්න ඔය හේතුව නිසා තමයි බැරි sub class reference variable එකක super class object එකක් තියා ගන්න..එහෙනම් යාලුවනේ මොකද්ද downcasting කියන්නේ????
ඇත්තටම යාලුවනෙ downcasting කියන්නෙ sub class reference variable එකක super class object එකක් store කරන එකට නම් නෙවෙයි..downcasting කියන්නෙ, upcasting කරලාම sub class object එකක් super class reference variable එකක store කරනවනේ ඒ store කරපු object එක අයෙම sub class reference එකකට දාන එකට තමයි downcasting කියන්නෙ.ඒ කියන්නෙ අපෙ උදාහරණයේ හැටියට නම් , teacher class එකෙන් හදාගත්ත object එක store කරේ person raference variable එකකනේ…ඒ විදියට store කරගත්තු sub class object එක අයෙත් sub class reference variable එකකම store කර ගන්න එකට.code එක ලිව්වොත් මෙන්න මේ වගේ..
class Upcasting&Downcasting{
public static void main(String a[]){
Person person1 = new Teacher() ; // upcasting
// downcasting
Teacher teacher1 = person1 ;
}
}
output :
output එක බලන්නකෝ..error එකක් දෙනවා නේද.ඇත්තටම මෙතනදි වෙන්නේ copiler එක හිතනවා super class reference variable එකේ store කරලා තියෙන්නේ super class object එකක් කියලා.sub class reference variable එකක super class variable එකක් store කරන්න බැරි නිසා තමයි එහෙම error එකක් දුන්නේ.
ඔන්න ඔය error එක නැති කර ගන්න පුලුවන් casting කරලා මෙන්න මේ විදියට..
class Upcasting&Downcasting{
public static void main(String a[]){
Person person1 = new Teacher() ; // upcasting
// downcasting
Teacher teacher1 = (Teacher) person1 ;
}
}
output:
දැන්නම් හරි නේද යාලුවනේ.ඇත්තටම casting කරන එකෙන් මෙතනදි වෙන්නෙ super class referance variable එකේ store කරලා තියෙන්නේ sub class එකෙන් හදපු object එකක් කියලා compiler එකට පෙන්නන එක.sub class object එකක් sub class reference variable එකක store කරන එක අව්ලක් නෑනෙ..අන්න එතකොට තමයි error එකක් නැති out put එකක් දෙනවා.ඔන්න ඕකට තමයි downcasting කියලා කිව්වේ.
හැමෝටම තේරෙන්න ඇති කියලා හිතනවා අද පාඩම . මීලග පාඩමේදී හමුවෙමු.ස්තූතියි!
