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

Наследование

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

Класс потомок наследует все возможности родительского класса – все поля и все методы, открытую и закрытую часть класса, статическую и динамическую части класса. Потомок может не иметь прямого доступа ко всем наследуемым полям и методам. Поля и методы родительского класса, снабженные атрибутом private, хотя и наследуются, но являются закрытыми, и методы, создаваемые потомком, не могут к ним обращаться напрямую, а только через методы, наследованные от родителя. Хорошей стратегией при проектировании класса является использование модификатора доступа protected вместо модификатора private, разрешая потомкам класса прямой доступ ко всем полям и методам родительского класса.

Потомок наследует почти все, но не все. Он не наследует конструкторы родительского класса. Конструкторы потомок должен создавать сам. В этом есть разумная идея, и я позже поясню ее суть.

Построение родительского класса Found

Рассмотрим класс, названный Found, который в наших примерах будет играть роль родительского класса:

/// <summary>
    /// Родительский класс
    /// </summary>
    class Found
    {
        //fields
        protected string name;
        protected int credit;
        static protected int count;
        const string NL = "\r\n";
        //Constructors
        public Found()
        {
            name = "Nemo";
            credit = 0;
            count++;
        }
        public Found(string name, int credit)
        {
            this.name = name;
            this.credit = credit;
            count++;
        }
	}

У класса Found три поля. Поля закрыты для клиентов класса, но открыты для потомков. Это правильная стратегия. Потомкам следует разрешать прямой доступ к полям. Одно из полей является статическим, содержательно оно будет использоваться для подсчета числа созданных объектов класса Found клиентами класса. Как и положено, помимо конструктора с аргументами, передаваемыми для инициализации экземплярных полей класса, у класса есть конструктор без аргументов, инициализирующий поля класса некоторым заданным по умолчанию способом. Оба конструктора в процессе работы увеличивают на единицу значение статического поля, которое к этому времени уже создано и инициализировано, поскольку статический конструктор класса вызывается по умолчанию до того, как вызываются конструкторы, создающие экземпляры – объекты класса.

Потомок класса, наследовав от родительского класса какой-либо метод, может его переопределить, задав собственную реализацию, отличную от реализации, которая используется родителем. Переопределяемый метод родителя должен снабжаться модификатором override.

Хотя явно для класса Found родительский класс не задан, но родитель есть у каждого класса. Если прямой родитель не задан, то таковым является класс object. Класс Found наследовал от своего родителя – класса object ряд методов. Чаще всего методы, наследуемые от object, потомок должен переопределить, и в первую очередь это касается метода ToString. Как правило, переопределение этого метода сводится к тому, что возвращаемая методом строка содержит информацию о значениях, хранящихся в полях класса. Вот как выглядит переопределяемый метод ToString для класса Found:

public override string ToString()
        {
            string s = "Поля: name = {0}, credit = {1}";
            return String.Format(s, name, credit);
        }

Начнем добавлять в класс Found собственные методы:

public string NonVirtMethod()
        {
            return "Found: " + this.ToString();
        }

Это обычный метод класса. Он возвращает некоторую строку, которая получена конкатенацией константы и строки, являющейся результатом вызова только что переопределенного метода ToString. Имя метода уточнено именем текущего объекта this, чтобы подчеркнуть тот факт, что именно текущий объект вызывает метод класса ToString.

Добавим в класс еще один похожий метод:

public virtual string VirtMethod()
        {
            return "Found: " + this.ToString(); 
        }

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

Добавим еще один метод класса:

public string Parse()
        {
            return "Выполнен разбор кода!";
        }

Метод прост и бесхитростен – возвращает некоторую строку. Реально в этом примере строятся методы, называемые заглушками. Они не выполняют никакой содержательной работы, но выдают информацию о том, что метод проработал. Для целей нашей лекции этого вполне достаточно.

Рассмотрим теперь чуть более сложный метод:

public string Job()
        {
            string res = "";
            res += "VirtMethod: " + 
                VirtMethod() + NL;
            res += "NonVirtMethod: " +
                NonVirtMethod() + NL;
            res += "Parse: " +
                Parse() + NL;
            return res;
        }

Метод Job поочередно вызывает методы класса – VirtMethod, NonVirtMethod, Parse. Строки, задающие результаты этих методов, соединяются, и полученная строка возвращается в качестве результата метода Job.

Последний метод, который добавим в класс Found, - это статический метод, возвращающий информацию из статического поля класса:

public static string NumberOfObjects()
        {
            return "Объектов создано: " + count;
        }

Не будем ограничиваться консольными проектами и для тестирования наследования создадим Windows-проект. Интерфейс проекта, который назван "WindowsParentsAndChildrenClasses", имеет традиционную для наших примеров архитектуру с главной кнопочной формой и формами, отвечающие за частные задачи. Покажем, как выглядит спроектированная форма для тестирования работы с объектами класса Found. Ее вид приведен на рис. 4.5.

Рис. 4.5. Интерфейс для работы с объектами класса Found

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