basic of C# (part 25)

Function Overloading Vs Function Overriding

ကြၽန္ေတာ္တို႔ ဒီေန႔ function overloading နဲ႔ function overriding အေၾကာင္းေလး ေျပာၾကရေအာင္။ အရင္ဆံုး function overloading အေၾကာင္းေျပာရေအာင္။ overload ဆိုတာ အလုပ္တစ္ခုထက္ပိုျပီး လုပ္တာကို ေျပာခ်င္တာပါ။ function overloading ဆိုေတာ့ ကြၽန္ေတာ္တို႔ ေရးလိုက္တဲ႔ function က တာ၀န္ တစ္ခုထက္ပိုျပီး လုပ္ေဆာင္ေပးတာကိုရည္ရြယ္တာပါ။ function name က တစ္ခုထဲပဲ ဒါေပမယ့္ လုပ္ေဆာင္မႈအမ်ားၾကီး လုပ္နိုင္ေအာင္ေပါ့။ ဥပမာဗ်ာ.. ကြၽန္ေတာ္က string ကေန integer ေျပာင္းတဲ႔ function ေလးတစ္ခုေလာက္ ေရးခ်င္တယ္။

static int ConvertToInteger(string st)
{
    try
    {
        return Convert.ToInt32(st);
    }
    catch
    {
        return 0;
    }
}

ကဲ.. ဒီ function ေလး ေရးလိုက္ျခင္းအားျဖင့္ ကြၽန္ေတာ္တို႔ string ကေန integer ေျပာင္းခ်င္တိုင္း လြယ္လြယ္ကူကူ ေခၚလို႔ ရသြားမယ္။ ဒါေပမယ့္ တျခား type ေတြကေနေျပာင္းခ်င္ရင္ ဒီ function သံုးလို႔ ရမလား။ မရပါဘူး။ ဒါဆို ကြၽန္ေတာ္က တျခားtype ေတြ အတြက္ကိုလည္း ဒီလိုမ်ိဳး function ေတြ ထပ္ေရးေပးဖို႔ လိုပါလိမ့္မယ္။

static int ConvertToInteger(decimal dec)
{
    try
    {
        return Convert.ToInt32(dec);
    }
    catch
    {
        return 0;
    }
}
static int ConvertToInteger(long l)
{
    try
    {
        return Convert.ToInt32(l);
    }
    catch
    {
        return 0;
    }
}

ဟုတ္ျပီေနာ္.. အခုလိုမ်ိဳး function name တူျပီး parameter မတူတဲ႔ function ေတြ တစ္ခုထက္ပိုျပီး ေရးလိုက္တာကို function overloading လုပ္တယ္လို႔ ေခၚပါတယ္။ function overloading လုပ္ျခင္း အားျဖင့္ ဘာပိုေကာင္းလာမလဲ။ ဟုတ္ကဲ႔ ကြၽန္ေတာ္တို႔ program ေရးတဲ႔ေနရာမွာ အမ်ားၾကီးပိုျပီး လြယ္ကူေစပါတယ္။ အကယ္လို႔သာ function overload မလုပ္ရဘူးဆိုရင္ ကြၽန္ေတာ္တို႔ string ကေန integer ေျပာင္းဖို႔အတြက္က function name တစ္ခု၊ decimal ကေန integer ေျပာင္းဖို႔အတြက္က function name တစ္ခု၊ long ကေန integer ေျပာင္းဖို႔အတြက္က function name တစ္ခု စသည္ျဖင့္ name ေတြ အမ်ားၾကီး သံုးေနမွတ္ေနရမွာေပါ့။ အခု overloading လုပ္ျခင္းအားျဖင့္ function name တစ္ခုထဲကိုပဲ သိဖို႔ လိုပါေတာ့တယ္။ Framework class library ထဲမွာလည္း overload လုပ္ထားတဲ႔ function ေတြ အမ်ားၾကီး ေတြရမွာပါ။ ကဲ အႏွစ္ခ်ဳပ္ျပန္ေျပာပါမယ္ function overloading ျဖစ္ဖို႔အတြက္ function name တူရပါမယ္၊ argument (parameter) မတူရပါဘူး။ parameter မတူရဘူး ဆိုတာမွာ parameter ရဲ႕ datatype ျဖစ္ေစ၊ အရည္အတြက္ ျဖစ္ေစမတူရင္ ရပါတယ္။

ေနာက္တစ္ခုကေတာ့ function overriding။ overriding လို႔ ေျပာတဲ႔ အတိုင္းပါပဲ၊ function overrideing ဆိုတာက function တစ္ခုေပၚမွာ ေနာက္ထပ္ function တစ္ခုနဲ႔ ထပ္ျပီး အုပ္လိုက္တာကို ေျပာခ်င္တာပါ။ ဒီလိုလုပ္လိုက္ရင္ function ၂ ခု ျဖစ္သြားမလား၊ မျဖစ္ပါဘူး။ override လုပ္ျခင္းခံရတဲ႔ function က ေပ်ာက္သြားမွာပါ။ function overrideing ကို အဓိကအားျဖင့္ polymorphism နဲ႔ တြဲျပီးသံုးေလ့ ရွိပါတယ္။ parent class ထဲမွာ ရွိျပီးသား function တစ္ခုကို child class ထဲမွာျပန္ျပီးေရးခ်င္တယ္ ဆိုရင္ override လုပ္ဖို႔ လိုလာပါျပီ။ ဒီလို အခ်ိန္မ်ိဳးမွာ function overriding ကိုသံုးပါတယ္။ ဥပမာေလးနဲ႔ ေျပာရရင္… ကြၽန္ေတာ္မွာ animal ဆိုတဲ႔ class ရွိတယ္ဗ်ာ၊ parent class ေပါ့၊ အဲ့ဒီ animal class ထဲမွာ eat() ဆိုတဲ႔ function ေလးပါတယ္။

class animal
{
    public void eat()
    {
        Console.WriteLine("Eat something");
    }
}

အိုေက.. အဲ့ဒီ animal class မွာ child class ၂ ခုရွိတယ္။ dog class နဲ႔ ant class ေပါ့။ အဲ့ဒီ dog class နဲ႔ ant class က animal class ကေန inheritance လုပ္ထားတာျဖစ္တဲ႔ အတြက္ သူတို႔ဆီမွာ eat() function အလိုအေလွ်ာက္ ပါလာပါတယ္။ အဲ့ဒီ parent class ကေနပါလာတဲ႔ eat() function ထဲက statement ေတြကို child class မွာ မလိုခ်င္ဘူး။ ပိုျပီး detail ၾကတဲ႔ message နဲ႔ အစားထိုးခ်င္တယ္ဆိုပါေတာ့ (ဥပမာ.. Eat something အစား၊ Eat Bone တို႔ Eat sugur တို႔နဲ႔ အစားထိုးခ်င္ျပီဆိုရင္)၊ ဒါဆို ဘယ္လိုလုပ္မလဲ? ေနာက္ထပ္ function တစ္ခုထပ္ေဆာက္ခ်င္တာ မဟုတ္ဘူးေနာ္၊ parameter လည္း မေျပာင္းတဲ႔ အတြက္ overloading လည္း လုပ္လို႔ မရဘူး။ ဒီလို အေျခအေနမ်ိဳးမွာ ကြၽန္ေတာ္တို႔ မျဖစ္မေန function overriding လုပ္ဖို႔ လိုလာပါျပီ။

ဒါဆို function overriding လုပ္ဖို႔ ဘာလိုမလဲ? Parent class ထဲမွာ ဒီတိုင္းေရးထားတဲ႔ function တိုင္းကိုေတာ့ override လုပ္လို႔ မရပါဘူး။ override လုပ္ဖို႔ ခြင့္ျပဳထားတဲ႔ function ေတြကိုပဲ လုပ္လို႔ရတာပါ။ ဒီလို override လုပ္ဖို႔ ခြင့္ျပဳခ်င္တယ္ဆိုရင္ parent class ထဲက function ရဲ႕ေရွ႕မွာ virtual ဆိုတဲ႔ keyword ေလးထည့္ေရးေပးလိုက္ရပါတယ္။

class animal
{
    public virtual void eat()
    {
        Console.WriteLine("Eat something");
    }
}

override ျပန္လုပ္မယ့္ child class က function ေရွ႕မွာေတာ့ override ဆိုတဲ႔ keywordကို ထည့္ေပးရပါတယ္။

class dog : animal
{
    public override void eat()
    {
        Console.WriteLine("Eat Bone!");
    }
}

ကဲ… example program ေလး တစ္ခုေလာက္ေရးၾကည့္ပါဦး။

class animal
{
    public virtual void eat()
    {
        Console.WriteLine("Animal: Eat something");
    }
}
class dog : animal
{
    public override void eat() // function overriding
    {
        Console.WriteLine("Dog: Eat Bone!");
    }
}
class ant : animal
{
    public override void eat()
    {
        Console.WriteLine("Ant: Eat Sugar");
    }
}
class Program
{
    static void Main()
    {
        animal obj;
        obj = new animal();
        obj.eat();

        obj = new dog(); //polymorphism
        obj.eat();

        obj = new ant();
        obj.eat();

        Console.Read();
    }
}

Basic of C# ကို ကြၽန္ေတာ္ဒီမွာပဲ ရပ္လိုက္ပါေတာ့မယ္။ အခုေလာက္ဆိုရင္ ကြၽန္ေတာ္တို႔ C# ဆိုတာ ဘာလဲသိေလာက္ပါျပီ။ OOP အေၾကာင္းလည္း နည္းနည္းေတာ့ နားလည္ေလာက္ျပီလို႔ ယူဆပါတယ္။ ေနာက္ပိုဒ႔္ေတြမွာ window application အပိုင္းနဲ႔ web application အပိုင္းကို ဆက္ေရးသြားပါ့မယ္ခင္ဗ်ာ။