7.5Ссылки на базовый класс и объекты производных классов
C# является строго типизированным языком программирования. Помимо стандартных преобразований и автоматического продвижения простых типов значений, в этом языке строго соблюдается принцип совместимости типов. Это означает, что переменная ссылки на объект класса одного типа, как правило, не может ссылаться на объект класса другого типа.
Вообще говоря, переменная ссылки на объект может ссылаться только на объект своего типа.
Но из этого принципа строгого соблюдения типов в C# имеется одно важное исключение: переменной ссылки на объект базового класса может быть присвоена ссылка на объект любого производного от него класса. Такое присваивание считается вполне допустимым, поскольку экземпляр объекта производного типа инкапсулирует экземпляр объекта базового типа. Следовательно, по ссылке на объект базового класса можно обращаться к объекту производного класса:
using System;
namespace ConsoleApplication1
{
class ClassA
{
public int a;
public ClassA(int i)
{ a = i; }
}
class ClassB : ClassA
{
public int b;
public ClassB(int r, int i) : base(i)
{ b = r; }
}
class ClassC
{
public int a;
public ClassC(int i) { a = i; }
}
class Program
{
static void Main()
{
ClassA objA1 = new ClassA(10);
ClassA objA2 = new ClassA(5);
// Присваивание однотипных объектов правильно:
objA2 = objA1;
ClassB objB = new ClassB(8, 9);
// Присваивание объекта, имеющего тип унаследованного
// класса допускается:
objA1 = objB;
// Так нельзя objB = objA1;
// Присваивать похожие, но не связанные друг с другом
// принципом наследования объекты нельзя
ClassC objC = new ClassC(8);
// objC = objA1;
Console.ReadLine();
}
}
}
Следует особо подчеркнуть, что доступ к конкретным членам класса определяется типом переменной ссылки на объект, а не типом объекта, на который она ссылается. Это означает, что если ссылка на объект производного класса присваивается переменной ссылки на объект базового класса, то доступ разрешается только к тем частям этого объекта, которые определяются базовым классом. И в этом есть своя логика, поскольку базовому классу ничего не известно о тех членах, которые добавлены в производный от него класс.
Один из самых важных моментов для присваивания ссылок на объекты производного класса переменным базового класса наступает тогда, когда конструкторы вызываются в иерархии классов. Как вам должно быть уже известно, в классе нередко определяется конструктор, принимающий объект своего класса в качестве параметра. Благодаря этому в классе может быть сконструирована копия его объекта.
7.6Виртуальные методы, свойства и индексаторы
Полиморфизм предоставляет подклассу способ определения собственной версии метода, определенного в его базовом классе, с использованием процесса, который называется переопределением метода (method overriding). Чтобы пересмотреть текущий дизайн, нужно понять значение ключевых слов virtual и override.
Виртуальным называется такой метод, который объявляется как virtual в базовом классе. Виртуальный метод отличается тем, что он может быть переопределен в одном или нескольких производных классах. Следовательно, у каждого производного класса может быть свой вариант виртуального метода. Кроме того, виртуальные методы интересны тем, что именно происходит при их вызове по ссылке на базовый класс. В этом случае средствами языка C# определяется именно тот вариант виртуального метода, который следует вызывать, исходя из типа объекта, к которому происходит обращение по ссылке, причем это делается во время выполнения. Поэтому при ссылке на разные типы объектов выполняются разные варианты виртуального метода. Иными словами, вариант выполняемого виртуального метода выбирается по типу объекта, а не по типу ссылки на этот объект.
Так, если базовый класс содержит виртуальный метод и от него получены производные классы, то при обращении к разным типам объектов по ссылке на базовый класс выполняются разные варианты этого виртуального метода.
Метод объявляется как виртуальный в базовом классе с помощью ключевого слова virtual, указываемого перед его именем. Когда же виртуальный метод переопределяется в производном классе, то для этого используется модификатор override. А сам процесс повторного определения виртуального метода в производном классе называется переопределением метода. При переопределении имя, возвращаемый тип и сигнатура переопределяющего метода должны быть точно такими же, как и у того виртуального метода, который переопределяется. Кроме того, виртуальный метод не может быть объявлен как static или abstract.
Переопределение метода служит основанием для воплощения одного из самых эффективных в C# принципов: динамической диспетчеризации методов, которая представляет собой механизм разрешения вызова во время выполнения, а не компиляции. Значение динамической диспетчеризации методов состоит в том, что именно благодаря ей в C# реализуется динамический полиморфизм.
Если при наличии многоуровневой иерархии виртуальный метод не переопределяется в производном классе, то выполняется ближайший его вариант, обнаруживаемый вверх по иерархии.
И еще одно замечание: свойства также подлежат модификации ключевым словом virtual и переопределению ключевым словом override. Это же относится и к индексаторам.
Давайте рассмотрим пример использования виртуальных методов, свойств и индексаторов:
// Реализуем класс, содержащий информацию о шрифтах
// и использующий виртуальные методы, свойства и индексаторы
using System;
namespace ConsoleApplication1
{
// Базовый класс
class Font
{
string TypeFont;
short FontSize;
public Font()
{
TypeFont = "Arial";
FontSize = 12;
}
public Font(string TypeFont, short FontSize)
{
this.TypeFont = TypeFont;
this.FontSize = FontSize;
}
public string typeFont
{
get { return TypeFont; }
set { TypeFont = value; }
}
public short fontSize
{
get { return FontSize; }
set { FontSize = value; }
}
// Создаем виртуальный метод
public virtual string FontInfo(Font obj)
{
string s = "Информация о шрифте: \n------------------\n\n"
+"Тип шрифта: " + typeFont
+ "\nРазмер шрифта: " + fontSize + "\n";
return s;
}
}
// Производный класс 1 уровня
class ColorFont : Font
{
byte Color;
public ColorFont(byte Color, string TypeFont, short FontSize)
: base(TypeFont, FontSize)
{ this.Color = Color; }
// Переопределение для виртуального метода
public override string FontInfo(Font obj)
{
// Используется ссылка на метод определенный в базовом классе Font
return base.FontInfo(obj) + "Цвет шрифта: " + Color + "\n";
}
// Создадим виртуальное свойство
public virtual byte color
{
set { Color = value; }
get { return Color; }
}
}
// Производный класс 2 уровня
class GradientColorFont : ColorFont
{
char TypeGradient;
public GradientColorFont(char TypeGradient, byte Color,
string TypeFont, short FontSize) :
base(Color, TypeFont, FontSize)
{ this.TypeGradient = TypeGradient; }
// Опять переопределяем виртуальный метод
public override string FontInfo(Font obj)
{
// Используется ссылка на метод определенный
// в производном классе FontColor
return base.FontInfo(obj) + "Тип градиента: "
+ TypeGradient + "\n\n";
}
// Переопределим виртуальное свойство
public override byte color
{
get { return base.color; }
set { if (value < 10) base.color = 0;
else base.color = (byte)(value - 0x0A);
}
}
}
// Еще один производный класс 1 уровня
class FontStyle : Font
{
string style;
public FontStyle(string style, string TypeFont, short FontSize)
: base(TypeFont, FontSize)
{
this.style = style;
}
// Данный класс не переопределяет виртуальный метод
// поэтому при вызове метода FontInfo ()
// вызывается метод, созданный в базовом классе
}
class Program
{
static void Main()
{
ColorFont font1 = new ColorFont(Color: 0xCF, TypeFont:
"MS Trebuchet", FontSize: 16);
Console.WriteLine(font1.FontInfo(font1));
GradientColorFont font2 = new GradientColorFont(Color: 0xFF,
TypeFont: "Times New Roman", FontSize: 10,
TypeGradient: 'R');
Console.WriteLine(font2.FontInfo(font2));
font2.color = 0x2F;
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Видоизмененный цвет font2");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(font2.FontInfo(font2));
FontStyle font3 = new FontStyle(style: "oblique", TypeFont:
"Calibri", FontSize: 16);
Console.WriteLine(font3.FontInfo(font3));
Console.ReadLine();
}
}
}
Вывод программы:
------------------
Тип шрифта: Times New Roman
Размер шрифта: 10
Цвет шрифта: 255
Тип градиента: R
Видоизмененный цвет font2
Информация о шрифте:
------------------
Тип шрифта: Times New Roman
Размер шрифта: 10
Цвет шрифта: 37
Тип градиента: R
Информация о шрифте:
------------------
Тип шрифта: Calibri
Размер шрифта: 16
Диаграмма классов для данного примера:
|
Давайте рассмотрим данный пример более подробно. В базовом классе Font инкапсулируется виртуальный метод FontInfo (), возвращающий информацию о шрифте. В производном классе FontColor данный метод переопределяется с помощью ключевого слова override, поэтому при создании экземпляра данного класса и вызова метода FontInfo() в исходную информацию возвращается помимо первоначальных данных еще и цвет шрифта. Затем данный метод вновь переопределяется в классе GradientColorFont, унаследованном от класса FontColor. Обратите внимание, что здесь переопределяется не исходный метод базового класса Font, а уже переопределенный метод класса FontColor. В этом и заключается принцип динамического полиморфизма!
Так же обратите внимание, что в данном примере используется виртуальное свойство color, принцип использования которого аналогичен использованию виртуального метода.