சி ஷார்ப்பில் இன்ஹெரிடன்ஸ் மற்றும் பாலிமார்பிசம்

ஒரு கிளாஸ் ஆனது இன்னொரு கிளாஸை இன்ஹெரிட் செய்யும் பொழுது கன்ஸ்ரக்டரை தவிர அணைத்து பேஸ் கிளாஸ் மெம்ப்ர்களும் இன்ஹெரிட் செய்யப்படுகின்றது. எனினும் அதன் access modifier கொண்டு அதை அணுகும் தன்மை மாறுபடும்.சி ஷார்ப் ஆனது இன்ஹெரிடன்ஸ் உடன் சேர்ந்து பாலிமார்பிசத்தையும் நமக்கு தருகின்றது.பாலி மார்பிசம் ஆனது சி ஷார்ப்பில் மெத்தட் ஹைடிங் மற்றும் மெத்தட் ஓவர் ரைடிங் என இரு வகைகளில் அமைகின்றது.

பேஸ் கிளாஸிலும் டெரிவ்ட் கிளாஸிலும் ஒரே பெயரில்(ஓரே சிக்னேச்சர் கொண்ட) மெத்தட் அமைந்த்தாலும்  எந்த மெத்தட் அழைக்கப்படும் என்பது அதற்கு நாம் ஒரு உருவாக்கும் ஆப்ஜெக்ட் எந்த கிளாஸை கொண்டது என்பதை பொறுத்து தான் அமைகின்றது.

கீழே உள்ளது பேஸ் கிளாஸ்

class Animal

{

    public Animal()

    {

        Console.WriteLine("Animal constructor");

    }

    public void Greet()

    {

        Console.WriteLine("Animal says Hello");

    }

    public void Talk()

    {

        Console.WriteLine("Animal talk");

    }

    public virtual void Sing()

    {

        Console.WriteLine("Animal song");

    }

};

இப்பொழுது அதன் டெரிவ்ட் கிளாஸ்

class Dog : Animal

{

    public Dog()

    {

        Console.WriteLine("Dog constructor");

    }

    public new void Talk()

    {

        Console.WriteLine("Dog talk");

    }

    public override void Sing()

    {

        Console.WriteLine("Dog song");

    }

};

மேலே உள்ள நிரலாக்க வரிகளில்  பேஸ் கிளாஸில் Talk எங்கின்ற மெத்தட் ஆனது டெரிவ்ட் கிளாஸில் new என்ற கீவேர்டு மூலம் மறைக்கப்படுகின்றது. அதாவது மெத்தட் ஹைடிங் செய்யப்படுகின்றது. பேஸ் கிளாஸில் உள்ள Sing என்கின்ற மெத்தட் டெரிவ்ட் கிளாஸில் ஒவர் ரைடிங்   செய்யப்படுகின்றது.

Animal a1=new Animal();

a1.Talk();

a1.Sing();

a1.Greet();

வெளியீடு:

Animal constructor

Animal talk

Animal song

Animal says Hello

இப்பொழுது பேஸ் கிளாஸ் ஆப்ஜெக்ட் ஆனது டெரிவ்ட் கிளாஸை பாயிண்ட் செய்கின்றது

Animal a2 = new Dog();

a2.Talk();

a2.Sing();

a2.Greet();

//Output

Animal constructor

Dog constructor

Animal talk

Dog song

Animal says Hello

இப்போது வெளியீட்டை கவனிக்கவும்.ஹைட் செய்யப்பட்ட மெத்தட் ஆனது பேஸ் கிளாஸில் உள்ள மெத்தட்டையே . அழைக்கின்றது.எனினும் ஒவர்ரைடிங் செய்யப்பட்ட மெத்தட் ஆனது (Sing) டெரிவ்ட் கிளாஸில் உள்ள மெத்த்டையே அழைக்கின்றது.

இப்போது டெரிவ்ட் கிளாஸிற்கு நேரடியாக ஆப்ஜெக்ட் உருவாக்குவோம்.

Dog d1 = new Dog();

d1.Talk();

d1.Sing();

d1.Greet();

 வெளியீடு:

Animal constructor

Dog constructor

Dog talk

Dog song

Animal says Hello

இப்போது வெளியீட்டைக் கவனிக்கவும். ஹைட் செய்யப்பட்ட மற்றும் ஓவர் ரைட் செய்யப்பட்ட இரண்டு மெத்தடுமே டெரிவ்டு கிளாஸில் உள்ள மெத்தடையே அழைத்திருக்கின்றது.

கம்பைல் டைம் பாலிமார்பிசமான மெத்தட் ஓவர் லோடிங் கீழே உள்ள கோடிங்கில் அமல்படுத்தப்பட்டிருக்கின்றது.அதாவது ஒரே கிளாஸிற்க்குள் ஒன்றுக்கும் மேற்ப்பட்ட மெத்தட் ஒரே பெயரில் அமைந்திருக்கும்.எனினும் அதன் பாராமீட்ட்ரானது மாறுபடும். அதாவது வெவ்வேறு  டேட்டா டைப்போ அல்லது பாராமீட்டரின் எண்னிக்கையோ மாறுபடும்.

class Color

{

    public virtual void Fill()

    {

        Console.WriteLine("Fill me up with color");

    }

    public void Fill(string s)

    {

        Console.WriteLine("Fill me up with {0}",s);

    }

};

Fill என்கின்ற மெத்தட் ஆனது ஒன்று பாராமீட்டர் எதுவும் இன்றிலும் மற்றொன்று ஒரு ஸ்ட்ரிங் டைப்பிலும் அமைந்துள்ளது

Color c1 = new Color();

c1.Fill();

c1.Fill("red");

வெளியீடு:

Fill me up with color

Fill me up with red

இப்பொழுது டெரிவ்ட் கிளாஸ்

class Green : Color

{

    public override void Fill()

    {

        Console.WriteLine("Fill me up with green");

    }

};

மெத்தட் ஓவர் ரைடிங்  எனப்படுவது பேஸ் கிளாஸிலும் டெரிவ்ட் கிளாஸிலும் ஓரெ பெயரிலும் ஒரே பாரமீட்டர் வகையிலும் அமைந்திருக்கும்.அதாவது ஒரே சிக்னேச்சர் கொண்ட மெத்தட்  .

ஒரு மெத்தடின் சிக்னேச்சர் எனப்படுவது அதன் பெயர் மற்றும் அதன் பாராமீட்டரின் டைப் ஆகும். பேஸ் கிளாஸில் உள்ள மெத்தட் virtual என்கின்ற கீவேர்ட் உடனும் டெரிவ்ட் கிளாஸில் உள்ள மெத்தட் override

கீவேர்டுடனும்இருக்கும்,. பேஸ் கிளாஸ் ஆப்ஜெக்ட் மூலம் அழைக்கப்படும் மெத்தட் பேஸ் கிளாஸில் உள்ள மெத்த்டையும் டெரிவ்ட் கிளாஸ் ஆப்ஜெக்ட் மூலம் அழைக்கப்படும் மெத்தட் டெரிவ்ட் கிளாஸில் உள்ள மெத்தடையும் அழைக்கும்.

Green g1 = new Green();

g1.Fill();

g1.Fill("violet");

வெளியீடு:

Fill me up with green

Fill me up with violet

சரி இப்பொழுது கன்ஸ்ட்ரக்டர் ஒவர் லோடிங்க் மற்றும் ஒவர்ரைடிங் பற்றி பார்ப்போம். கன்ஸ்ட்ரக்டரும் ஒரு மெத்தட்போன்று தான்.

class Software

{

    public Software()

    {

        m_x = 100;

    }

    public Software(int y)

    {

        m_x = y;

    }

    protected int m_x;

};

மேலே உள்ள நிரலாக்க வரிகளில் software கிளாசிற்கு இரண்டு கன்ஸ்ட்ரக்டர்களும் மற்றும் ஒரு இன்டிஜர் வேரியபிளும் உள்ளது

கவனிக்கவும் வேரியபிளின்  ஆக்சஸ் மாடிஃபையர் public அல்லது private  கிடையாது. அது protect ஆகும் அப்பொழுது  தான் அதை இன்ஹெரிட் செய்யும் கிளாஸில் ஆக்சஸ் செய்ய முடியும்.

class MicrosoftSoftware : Software

{

    public MicrosoftSoftware()

    {

        Console.WriteLine(m_x);

    }

};

இப்போது அதற்கு ஆப்ஜெக்ட் உருவாக்குவோம்.

MicrosoftSoftware m1 = new MicrosoftSoftware();

//MicrosoftSoftware m2 = new MicrosoftSoftware(300); //won't compile

வெளியீடு:

100

கவனிக்கவும்,இரண்டாவது வரியானது கம்பைல் ஆகாது.ஏனெனில் கன்ஸ்ட்ரக்டரானது இன்ஹெரிட் ஆகாது என்று கூறினோம் அல்லவா அதற்காகத் தான்.

class DundasSoftware : Software

{

    public DundasSoftware(int y) : base(y)

    {

        Console.WriteLine(m_x);

    }

   

    public DundasSoftware(string s, int f) : this(f)

    {

        Console.WriteLine(s);

    }

};

இப்போது மேலே உள்ள கிளாஸ் ஆனது Software கிளாசை இன்ஹெரிட் செய்கின்றது. இரண்டு கன்ஸ்ட்ரக்டர்கள் உள்ளன.அவை ஓவர் லோட் செய்யப்பட்டுள்ளன. முதலில் உள்ள கன்ஸ்ட்ரக்டர் ஆனது base கீவேர்டு மூலம் பேஸ் கிளாஸ் கன்ஸ்ரக்டரை அழைக்கின்றது

DundasSoftware du1 = new DundasSoftware(50);

வெளியீடு:

50

இரண்டாவது கன்ஸ்ட்ரக்டர் ஆனது this கீவேர்டு மூலம் அதே கிளாஸில் உள்ள முதல் கன்ஸ்ட்ரக்டரை அழைக்கின்றது.

DundasSoftware du2 = new DundasSoftware("test",75);

வெளியீடு:

75

test

                                                              -முத்து கார்த்திகேயன்,மதுரை.