Отношения между классами. Клиенты и наследники

Построение класса потомка Derived

Создадим теперь класс Derived - потомка класса Found. В простейшем случае объявление класса может выглядеть так:

public class Derived:Found
   {
   }

Тело класса Derived пусто, но это вовсе не значит, что объекты этого класса не имеют полей и методов: они наследуют все поля и методы (кроме конструктора) класса Found и поэтому могут делать все, что могут делать объекты родительского класса. Можно даже не создавать собственных конструкторов класса. В этом случае автоматически добавляется конструктор по умолчанию - конструктор без аргументов, который будет вызывать конструктор без аргументов родительского класса. Заметьте, такой конструктор у родителя должен быть, иначе возникнет ошибка. Но в нашем случае такой конструктор предусмотрительно создан.

Рис. 4.6. Форма для работы с объектами класса Derived

На рис. 4.6 показана знакомая нам форма, расширенная для работы с объектами класса Derived. Как видите, несмотря на то, что тело класса пусто, можно создать объект и вызывать многочисленные его методы, наследованные от родителя. На рисунке показаны результаты работы метода Job для объектов классов Found и Derived, созданных по умолчанию. Результаты совпадают. Если потомок ничего не делает, то его объекты ведут себя так же, как и объекты родительского класса. Каждый объект потомка "является" объектом родительского класса.

Потомки, которые только наследуют свойства и поведение родителя, не интересны, от них мало проку. Потомок должен идти дальше родителя - вводить новые свойства, новое поведение, изменять старые методы работы. Давайте этим и займемся на примере класса Derived.

Добавление и скрытие полей потомком

Что может делать потомок с полями? Прежде всего, он может добавить новые свойства - поля класса. Он может скрыть поле родителя, добавив собственное поле с тем же именем, что и поле родителя, возможно, изменив тип этого поля и его модификаторы. Скрытие родительского поля не означает, что потомок удаляет поле, наследованное от родителя. Это поле у потомка остается и доступно для вызова, но скрыто, и чтобы добраться до него, необходимо имя поля уточнить именем родителя, задаваемым ключевым словом base.

Итак, потомок не может ни удалить, ни изменить поля, наследованные от родителя, он может только добавить собственные поля и может скрыть поля родителя.

Модифицируем наш класс Derived. Добавим новое поле класса debit. Будем также полагать, что поля debit и credit должны иметь тип double, а не int. По этой причине скроем родительское поле credit, добавив собственное поле с тем же именем, но изменив его тип:

//добавление и скрытие полей
        protected double debit;
        new protected double credit;

Скрываемые поля следует снабжать модификатором new. Если этого не сделать, то родительское поле все равно будет скрыто, и на этапе компиляции будет выдано предупреждение о возникшей ситуации.

Для обоих полей задан модификатор доступа protected. Напомню, хорошей стратегией является стратегия "ничего не скрывать от потомков". Какой родитель знает, что именно из сделанного им может понадобиться потомкам?

Конструкторы родителей и потомков

Каждый класс должен позаботиться о создании собственных конструкторов. Он не может в этом вопросе полагаться на родителя, поскольку, как правило, добавляет собственные поля, о которых родитель ничего знать не может. Конечно, если не задать конструкторов класса, то будет добавлен конструктор по умолчанию, инициализирующий все поля значениями по умолчанию, как это мы видели в предыдущем примере. Но это редкая ситуация. Чаще всего класс создает собственные конструкторы и, как правило, не один, задавая разные варианты инициализации полей.

При создании конструкторов классов потомков есть одна важная особенность. Всякий конструктор создает объект класса - структуру, содержащую поля класса. Но потомок не может самостоятельно создать объект, ему нужна помощь родителя. Конструктор потомка начинает свою работу с вызова конструктора родителя, который создает родительский объект, а затем уже конструктор потомка дополняет этот объект полями потомка. Ввиду транзитивности этого процесса конструктор родителя вызывает конструктор своего родителя, и этот процесс продолжается, пока первым делом не будет создан объект прародителя. Так что вызов конструктора потомка приводит к подъему по цепочке вызовов конструкторов родительских классов от потомков к предкам, а затем происходит спуск по цепочке, когда каждый из конструкторов создает свою часть объекта. Последним свою часть работы выполняет конструктор потомка.

Чтобы подчеркнуть синтаксически такую семантику работы конструктора, вызов конструктора родителя встроен не в тело конструктора, а в его заголовок. Для вызова конструктора используется ключевое слово base, именующее родительский класс. Как это делается, покажу на примере конструкторов класса Derived:

//Конструкторы
        public Derived(): base()
        {
            debit = 0; credit = 0;
        }
        public Derived(string name, double debit,
            double credit)
            : base(name, (int)credit)
        {
            this.debit = debit; 
            this.credit = credit;
        }

Вызов конструктора родительского класса с именем base синтаксически следует сразу за списком аргументов конструктора, будучи отделен от этого списка символом двоеточия. Все аргументы, необходимые для инициализации полей объекта, передаются конструктору потомка. Часть из этих аргументов передается конструктору родителя для инициализации родительских полей.

Итак, вызов конструктора потомка приводит к цепочке вызовов конструкторов предков, заканчивающейся вызовом конструктора прародителя. Затем в обратном порядке создаются объекты, начиная с объекта прародителя, и выполняются тела соответствующих конструкторов, инициализирующие поля и выполняющие другую работу этих конструкторов. Последним создается объект потомка и выполняется тело конструктора потомка.

Добавление методов и изменение методов родителя

Потомок может создать новый собственный метод с именем, отличным от имен наследуемых методов. В этом случае никаких особенностей нет. Вот пример такого метода, создаваемого в классе Derived и возвращающего значение, которое хранится в скрытом поле credit:

//Методы
        public string MyBaseCredit()
        {
            return base.credit.ToString();
        }

Класс потомок может добавлять собственные методы, скрывать методы родителя. Но ситуация с методами более сложная, чем с полями, поскольку потомок может изменять реализацию родителя, задавая собственную реализацию метода. Если потомок создает метод с именем, совпадающим с именем метода предков, то возможны три ситуации:

1. перегрузка метода. Она возникает, когда сигнатура создаваемого метода отличается от сигнатуры наследуемых методов предков. В этом случае в классе потомка будет несколько перегруженных методов с одним именем, и вызов нужного метода определяется обычными правилами перегрузки методов;
2. переопределение метода. Метод родителя в этом случае должен иметь модификатор virtual, abstract или override. Это наиболее интересная ситуация, и она будет подробно рассмотрена. При переопределении сохраняется сигнатура и модификаторы доступа наследуемого метода;
3. скрытие метода. Если родительский метод не является виртуальным или абстрактным, то потомок может создать новый метод с тем же именем и той же сигнатурой, скрыв родительский метод в данном контексте. Здесь ситуация такая же, как и со скрытием полей. При вызове метода по его имени предпочтение будет отдаваться методу потомка. Это не означает, что метод родителя становится недоступным. Скрытый родительский метод всегда может быть вызван, если при вызове уточнить имя метода родительским именем base.

Метод потомка, скрывающий метод родителя, следует сопровождать модификатором new, указывающим на новый метод. Если этот модификатор опущен, но из контекста ясно, что речь идет о новом методе, то выдается предупреждающее сообщение при компиляции проекта.

Вернемся к нашему примеру. Класс Found имел в своем составе метод Parse. Его потомок класс Derived расширил возможности метода, добавив проверку в метод разбора. Поскольку родительский метод Parse не был ни виртуальным, ни абстрактным, то новый метод Parse, добавленный потомком, скрывает родительский метод:

new public string Parse()
        {
            string res = base.Parse() + NL;
            res += "Выполнена проверка кода!";
            return res; 
        }

В этом примере демонстрируется типичная ситуация, когда потомок в переопределяемом им методе родителя первым делом вызывает метод родителя, а затем уже выполняет свою часть работы, улучшающую результат.

Осталось рассмотреть наиболее интересную ситуацию, когда переопределяется родительский метод изначально объявленный как виртуальный или абстрактный. Но об этом стоит поговорить подробнее.