Файл: 1_C#_Введение_в_программирование_Уч_пособ_(Марченко-2005).pdf
ВУЗ: Не указан
Категория: Не указан
Дисциплина: Не указана
Добавлен: 11.12.2025
Просмотров: 1389
Скачиваний: 3
public override void f0()
{
::::::::::
return 0;
}
}
::::::::::
static void Main(string[] args)
{
X x = new X(); // NO! Y y0 = new Y(125);
// Работает переопределённая абстрактная функция! y0.f0();
}
Ещё пример
using System; namespace Interface01
{
//Абстрактный класс. abstract class aX1
{
public int xVal;
//Его конструкторы могут использоваться при построении
//объектов класов - наследников.
public aX1(int key)
{
Console.WriteLine("aX1({0})...", key); xVal = key;
}
public aX1()
{
Console.WriteLine("aX1()..."); xVal = 0;
}
public void aX1F0(int xKey)
{
xVal = xKey;
}
public abstract void aX2F0();
}
class bX1:aX1
{
new public int xVal;
public bX1():base(10)
{
xVal = 125;
Console.WriteLine("bX1():base(10)... xVal=={0},base.xVal=={1}...", xVal, base.xVal);
}
public bX1(int key):base(key*10)
{
xVal = key;
Console.WriteLine("bX1({0}):base({1})...", xVal, base.xVal);
}
public override void aX2F0()
{
xVal = xVal*5;
base.xVal = base.xVal*100;
}
}
class Class1
{
77
static void Main(string[] args)
{
//Ни при каких обстоятельствах не может служить основой для
//построения объектов. Даже если не содержит ни одного объявления
//абстрактной функции.
//aX1 x = new aX1();
bX1 x0 = new bX1();
x0.aX1F0(10); // Вызвали неабстрактную функцию базового абстрактного класса. bX1 x1 = new bX1(5);
x1.aX2F0();//Вызвали переопределённую функцию. В базовом классе это // абстрактная функция.
}
}
}
Ссылка на объект базового класса
Это универсальная ссылка для любого объекта производного типа, наследующего данный базовый класс.
using System; namespace Inheritance_3
{
class X {//=================================================== public int q0 = 0;
public int q = 0;
public void fun0()
{
Console.WriteLine(“class X, function fun0()”);
}
public void fun1()
{
Console.WriteLine(“class X, function fun1()”);
}
}//===================================================
class Y:X {//=================================================== new public int q = 0;
new public void fun1()
{
Console.WriteLine(“class Y, function fun1()”);
}
public void fun00()
{
Console.WriteLine(“class Y, fun00()”);
}
}//===================================================
class Z:X {//=================================================== new public int q = 0;
new public void fun1()
{
Console.WriteLine(“class Z, function fun1()”);
}
public void fun00()
{
Console.WriteLine(“class Z, fun00()”);
}
}//===================================================
class StartClass {//=================================================== static void Main(string[] args)
78
{
X x = null; // Просто ссылка!
//Объекты-представители производных классов-наследников. Y y = new Y(); y.fun0(); y.fun00(); y.fun1();
Z z = new Z(); z.fun0(); z.fun00(); z.fun1();
//Настройка базовой ссылки.
x = y; x.fun0(); x.fun1(); x.q = 100; x.q0 = 125; x = z; x.fun0(); x.fun1(); x.q = 100; x.q0 = 125;
}
}//===================================================
}
Результат:
class X, fun0() class Y, fun00() class Y, fun1() class X, fun0() class Z, fun00() class Z, fun1() class X, fun0() class X, fun1() class X, fun0() class X, fun1()
Вопросов не будет, если рассмотреть схему объекта-представителя класса Y.
X X
public int q0 = 0; public int q = 0; public void fun0(){…} public void fun1(){…}
Y
new public int q = 0; new public void fun1(){…} public void fun00(){…}
Y
Вот что видно от ссылки на объект класса X, настроенного на объектпредставитель производного класса. Схема объекта-представителя класса Z и соответствующий “вид” от ссылки x выглядят аналогичным образом.
Операции is и as
Вот код, иллюстрирующий особенности применения операций is и as.
using System;
namespace derivation01
{
//Базовый класс...
class X {//_____________________________. public int f1(int key)
{
Console.WriteLine("X.f1"); return key;
}
}//_____________________________.
//Производный...
class Y:X
79
{//_____________________________. new public int f1(int key)
{
Console.WriteLine("Y.f1");
base.f1(key); return key;
}
public int yf1(int key)
{
Console.WriteLine("Y.yf1"); return key;
}
}//_____________________________.
// Производный...
class Z:X {//_____________________________. public int zf1(int key)
{
Console.WriteLine("Z.zf1"); return key;
}
}//_____________________________.
class Class1
{
static void Main(string[] args)
{
int i;
// Всего лишь ссылки на объекты...
Xx;
Yy;
Zz;
Random rnd = new Random();
//И вот такой тестовый пример позволяет выявить особенности применения
//операций is и as.
for (i = 0; i < 10; i++) {//=================================================================================.
//Ссылка на объект базового класса случайным образом
//настраивается на объекты производного класса.
if (rnd.Next(0,2) == 1) x = new Y();
else
x = new Z();
//Вызов метода f1 не вызывает проблем.
//Метод базового класса имеется у каждого объекта. x.f1(0);
//А вот вызвать метод, объявленный в производном классе
//(с использованием операции явного приведения типа)
//удаётся не всегда. Метод yf1 был объявлен лишь в классе Y.
//Ниже операция is принимает значение true лишь в том случае,
//если ссылка на объект базового класса была настроена на объект класса Y. if (x is Y)
{
((Y)x).yf1 (0); // И только в этом случае можно вызвать метод,
// объявленный в Y.
}
else
{
((Z)x).zf1 (1); // А в противном случае попытка вызова yf1 // привела бы к катастрофе.
try
{
((Y)x).yf1 (0);
80
}
catch (Exception ex)
{
Console.WriteLine("-1-" + ex.ToString());
}
}
//А теперь объект, адресуемый ссылкой на базовый класс надо попытаться
//ПРАВИЛЬНО переадресовать на ссылку соответствующего типа. И это тоже
//удаётся сделать не всегда. Явное приведение может вызвать исключение.
try
{
z = (Z)x;
}
catch (Exception ex)
{
Console.WriteLine("-2-" + ex.ToString());
}
try
{
y = (Y)x;
}
catch (Exception ex)
{
Console.WriteLine("-3-" + ex.ToString());
}
//Здесь помогает операция as.
//В случае невозможности переадресации соответствующая ссылка оказывается
//установленной в null. А эту проверку выполнить проще...
if (rnd.Next(0,2) == 1)
{
z = x as |
Z; |
if (z != |
null) z.zf1(2); |
else |
Console.WriteLine("?????"); |
} |
|
else |
|
{ |
Y; |
y = x as |
|
if (y != |
null) y.yf1(3); |
else |
Console.WriteLine("!!!!!"); |
}
}//=================================================================================.
}
}
}
Виртуальные функции. Принцип полиморфизма
Основа реализации принципа полиморфизма – наследование. Ссылка на объект базового класса, настроенная на объект производного может обеспечить выполнение методов ПРОИЗВОДНОГО класса, которые НЕ БЫЛИ ОБЪЯВЛЕНЫ В БАЗОВОМ КЛАССЕ. При реализации принципа полиморфизма происходят вещи, которые не укладываются в ранее описанную схему.
Одноимённые функции с одинаковой сигнатурой в базовом и производном классах: между ними может быть установлено отношение замещения. Замещаемая функция
базового |
класса |
должна |
при |
этом |
дополнительно |
специфицироваться |
спецификатором virtual. |
|
|
|
|
||
Отношение замещения между функциями базового и производного класса устанавливается, если соответствующая (одноименная функция с соответствующей сигнатурой) функция производного класса специфицируется дополнительным спецификатором override.
81
class A
{
public virtual void F() { }
}
class B:A
{
new public virtual void F() { }
}
class B:A
{
public override void F() { }
}
class B:A
{
new public void F() { }
}
class A
{
public void F(){ }
}
class B:A
{
new public void F() { }
}
class B:A
{
new public virtual void F() { }
}
Введём следующие обозначения и построим схему наследования.
Спецификация и заголовок функциичлена |
Уровень наследования |
Обозначение |
|
public void F(){ } |
|
0 |
|
public virtual void F() |
{ } |
0 |
|
new public virtual void |
F() { } |
1..N |
|
new public void F() { } |
|
1..N |
|
public override void F() { } |
1..N |
|
|
Схема возможных вариантов объявления методов в иерархии наследования трёх уровней.
Наконец, замечательный пример,
82
using System; namespace Implementing
{
class A
{
public virtual void F() { Console.WriteLine(“A”);}
}
class B:A
{
public override void F() { Console.WriteLine(“B”); }
}
class C:B
{
new public virtual void F() { Console.WriteLine(“C”); }
}
class D:C
{
public override void F() { Console.WriteLine(“D”); }
}
class Starter
{
static void Main(string[] args)
{
D d = new D(); C c = d;
B b = c; A a = b;
d.F(); /* D */ c.F(); /* D */ b.F(); /* B */ a.F(); /* B */
}
}
}
в котором становится ВСЁ понятно, если ПОДРОБНО нарисовать схемы классов, структуру объекта-представителя класса D и посмотреть, КАКАЯ ссылка ЗА КАКОЕ место этот самый объект удерживает.
Интерфейсы
Фактически это те же самые абстрактные классы, НЕ СОДЕРЖАЩИЕ объявлений данных – членов и объявлений ОБЫЧНЫХ функций.
Все без исключения функции-члены интерфейса – абстрактные. Поэтому интерфейс объявляется с особым ключевым словом interface, а функции интерфейса, несмотря на свою “абстрактность” объявляются без ключевого слова abstract.
Основное отличие интерфейса от абстрактного класса заключается в том, что производный класс может наследовать одновременно несколько интерфейсов.
using System;
namespace Interface01
{
//Интерфейсы.
//Этот интерфейс характеризуется уникальными
//именами объявленных в нём методов. interface Ix
{
void IxF0(int xKey); void IxF1();
}
83