6. Віртуальні функції – більш детальний погляд.

Придивимось більш уважно до віртуальних функцій. З цією метою розглянемо досить загальний клас Base з віртуальним методом DoSomething(), який просто надсилає повідомляє про себе. У похідному класі SubBase визначимо відповідний метод із модифікатором override. Створимо також похідний клас наступного рівня спадкування SubSubBase. Крім того створимо зовнішню функцію fun(Base sb), яка приймає аргумент типу Base. Всередині цієї функції міститься звертання до методу DoSomething(). Оскільки функція fun може бути викликана як для екземпляру класу Base, так і для екземплярів класів SubBase та SubSubBase, рішення про те, який саме метод DoSomething() (базового чи одного з похідних класів) буде викликаний, неможливо прийняти у момент компіляції програми, а лише під час виконання. Цей механізм називається динамічним поліморфізмом або динамічною диспетчеризацією методів. (Відповідний механізм в мові С++ називають пізнім зв’язуванням.)

using System;

namespace UseOverride1

{

class Base

{

public virtual void DoSomething()

{ Console.WriteLine("Ми у базовому класi Base"); }

}

class SubBase : Base

{

public override void DoSomething()

{ Console.WriteLine("Ми у похiдному класi SubBase"); }

}

class SubSubBase : SubBase

{

public override void DoSomething()

{ Console.WriteLine("Ми у похiдному класi SubSubBase"); }

}

class Program

{ // метод може приймати аргумент типу Base (або SubBase,

// SubSubBase)

static void fun(Base sb)

{ sb.DoSomething(); }

static void Main()

{

Base b = new Base();

SubBase sb = new SubBase();

SubSubBase ssb = new SubSubBase();

// тут працює звичайний поліморфізм

b.DoSomething(); // метод класу Base

sb.DoSomething(); // метод класу SubBase

ssb.DoSomething(); // метод класу SubSubBase

Console.WriteLine("--------------------------");

// тут працює динамічний поліморфізм

fun(b); // викликається метод DoSomething() класу Base

// викликається метод DoSomething() класу SubBase

fun(sb);

// викликається метод DoSomething() класу SubSubBase

fun(ssb);

}

}

}

Запуск цієї програми призведе до наступних повідомлень на екрані:

Ми у базовому класi Base

Ми у похiдному класi SubBase

Ми у похiдному класi SubSubBase

--------------------------

Ми у базовому класi Base

Ми у похiдному класi SubBase

Ми у похiдному класi SubSubBase

Таким чином, результат роботи функції fun визначається типом аргументу, переданого їй під час виклику, тобто у момент виконання програми. В залежності від типу аргументу – Base, SubBase чи SubSubBase викликається метод DoSomething() відповідного класу.

Поля класів не можуть бути віртуальними. Заміщеними можуть бути тільки методи, властивості, індексатори та події (останній тип членів класів не обговорювався).

Крім того, якщо похідний клас заміщає деякий віртуальний член базового класу, то коли екземпляр похідного класу приводиться до типу базового класу, для нього все рівно буде викликаний (override) метод похідного класу. Для перевірки включимо у попередній приклад наступне визначення: Base bb = new SubBase(); та виклик функції fun(bb); і методу bb.DoSomething();. Екземпляр bb безперечно має тип Base, проте повідомлення, які додатково з’являться на екрані, переконують – для нього в обох випадках викликається метод DoSomething() похідного класу SubBase.

Що станеться, якщо у базовому та похідних класах визначити методи з однаковою сигнатурою, проте не помітити їх модифікаторами virtual та override відповідно? Внесемо такі зміни у текст попереднього прикладу. При компіляції одержимо зауваження від компілятора щодо методів DoSomething() похідних класів «…hides inherited member DoSomething()…» – приховує успадкований метод DoSomething(). Тим не менше програма виконується, і на екрані побачимо:

Ми у базовому класi Base

Ми у похiдному класi SubBase

Ми у похiдному класi SubSubBase

--------------------------

Ми у базовому класi Base

Ми у базовому класi Base

Ми у базовому класi Base

Це означає, що безпосереднє звертання до методів DoSomething() через екземпляри базового та похідних класів, тобто звичайний поліморфізм, спрацьовує очікуваним чином – ми дійсно звертаємось до методів різних класів. А от функція fun у даному разі завжди викликатиме лише метод базового класу, адже таким є тип її параметра – динамічного поліморфізму немає. Щоб позбавитись від зауваження компілятора у випадку, коли ви свідомо використовуєте приховування методу базового класу, досить при визначенні відповідного методу у похідних класах додати службове слово new, як уже завважувалось у попередньому розділі і як радить у своєму зауваженні компілятор.

Цілком зрозуміло також, що віртуальна функція не може мати модифікатор private – адже тоді вона не буде доступна, а отже, і не може бути заміщена у похідних класах.

Будь-який клас може зупинити заміщення віртуального методу у своїх похідних класах. Для цього необхідно використати службове слово sealed (закритий печаткою) перед словом override у визначенні такого методу. Наприклад,

class SubBase : Base

{ // Цей метод не буде заміщатись у похідних класах

public sealed override void DoSomething()

{

// код методу

}

}

Клас також може бути визначений із модифікатором sealed - такий клас не може бути базовим, таким чином від нього неможливо утворювати похідні класи. Заборона спадкування може дещо прискорити звертання до методів такого класу.

Якщо вас продовжує турбувати питання, а навіщо взагалі заміщати методи базового класу, можливо, ви не до кінця усвідомлюєте основні ідеї об’єктно-орієнтованого програмування. Заміщення методів – дуже потужний механізм, який дозволяє в ієрархії класів лише додавати та уточнювати функціональність уже існуючим класам, а не дублювати методи базових класів. До речі, код методів, які заміщають деякий віртуальний метод, найчастіше включає безпосередній виклик цього віртуального методу базового класу, саме з метою позбавитись від дублювання фрагментів коду. Для звертання до будь-якого члену базового класу (не лише віртуального) використовується службове слово base:

public class Base

{

public virtual void DoSomething()

{ // код методу

}

}

public class SubBase : Base

{

public override void DoSomething()

{ // код методу

}

}

public class SubSubBase : SubBase

{

public override void DoSomething ()

{

// викликається метод DoSomething() класу SubBase

base.DoSomething ();

// далі код, що визначає особливості класу SubSubBase

}

}

Розглянемо дещо більш складний приклад. Тут в базовому класі Base визначені 3 віртуальні методи – Meth1(), Meth2() та Meth3(). У похідному класі SubBase методи Meth1() та Meth2() заміщаються (override), а метод Meth3() перекривається (new). У наступному похідному класі SubSubBase заміщається лише метод Meth1(), а Meth2() та Meth3() – перекриваються.

using System;

namespace UseOverride1

{

class Base

{

public virtual void Meth1()

{ Console.WriteLine("Ми у базовому класi Base - Meth1");}

public virtual void Meth2()

{ Console.WriteLine("Ми у базовому класi Base - Meth2");}

public virtual void Meth3()

{ Console.WriteLine("Ми у базовому класi Base - Meth3");}

}

class SubBase : Base

{

public override void Meth1()

{ Console.WriteLine(

"Ми у похiдному класi SubBase - Meth1");}

public override void Meth2()

{ Console.WriteLine(

"Ми у похiдному класi SubBase - Meth2"); }

public new virtual void Meth3()

{ Console.WriteLine(

"Ми у похiдному класi SubBase - Meth3"); }

}

class SubSubBase : SubBase

{

public override void Meth1()

{ Console.WriteLine(

"Ми у похiдному класi SubSubBase - Meth1"); }

public new virtual void Meth2()

{ Console.WriteLine(

"Ми у похiдному класi SubSubBase - Meth2"); }

public new virtual void Meth3()

{ Console.WriteLine(

"Ми у похiдному класi SubSubBase - Meth3"); }

}

class Program

{

static void fun(Base b)

{ b.Meth1(); b.Meth2(); b.Meth3(); }

static void Main()

{

Base b = new Base();

SubBase sb = new SubBase();

SubSubBase ssb = new SubSubBase();

// тут працює ранній поліморфізм

b.Meth1(); b.Meth2(); b.Meth3(); // b має тип Base

Console.WriteLine("-----------------------------");

// sb має тип SubBase

sb.Meth1(); sb.Meth2(); sb.Meth3();

Console.WriteLine("-----------------------------");

// ssb має тип SubSubBase

ssb.Meth1(); ssb.Meth2(); ssb.Meth3();

Console.WriteLine("-------- Функцiя fun : ---------");

// тут працює пізній поліморфізм

fun(b);

fun(sb);

fun(ssb);

}

}

}

Результати роботи цього прикладу будуть такими:

Ми у базовому класi Base - Meth1

Ми у базовому класi Base – Meth2

Ми у базовому класi Base – Meth3

-----------------------------

Ми у похiдному класi SubBase - Meth1

Ми у похiдному класi SubBase – Meth2

Ми у похiдному класi SubBase – Meth2

-----------------------------

Ми у похiдному класi SubSubBase - Meth1

Ми у похiдному класi SubSubBase – Meth2

Ми у похiдному класi SubSubBase – Meth3

------------- Функцiя fun : ----------------

Ми у базовому класi Base - Meth1

Ми у базовому класi Base – Meth2

Ми у базовому класi Base – Meth3

Ми у похiдному класi SubBase - Meth1

Ми у похiдному класi SubBase – Meth2

Ми у базовому класi Base – Meth3

Ми у похiдному класi SubSubBase - Meth1

Ми у похiдному класi SubBase – Meth2

Ми у базовому класi Base – Meth3

Перші три блоки вихідних повідомлень означають, що на рівні екземплярів b, sb та ssb відповідно класів Base, SubBase та SubSubBase викликаються методи Meth1(), Meth2() та Meth3()саме цих класів. Коли ж ці методи викликаються опосередковано через деяку функцію fun(), яка приймає параметр типу Base (а отже, і будь-якого похідного класу), то метод Meth3() заміщається для аргументів будь-якого похідного класу, метод Meth2() заміщається лише для аргументу класу SubBase, а метод Meth3() завжди викликається для базового класу, оскільки в кожному похідному класі він був перекритий власними неполіморфними методами.