Эндрю Троелсен - ЯЗЫК ПРОГРАММИРОВАНИЯ С# 2005 И ПЛАТФОРМА .NET 2.0. 3-е издание
При создании отношения подчиненности между классами вы строите зависимость между типами. Основной идеей классического наследования является то, что новые классы могут использовать (и, возможно, расширять) функциональные возможности исходных классов. Для примера предположим, что вы хотите использовать функциональные возможности класса Employee и создать два новых класса – Salesperson (продавец) и Manager (менеджер). Иерархия классов будет выглядеть примерно так, как показано на рис. 4.7.
Рис. 4.7. Иерархия классов служащих
Из рис. 4.7 можно понять, что Salesperson (продавец) является ("is-a") Employee (работником), точно так же, как и Manager (менеджер). В классической модели наследования базовые классы (например. Employee) используются для определения общих характеристик, которые будут присущи всем потомкам. Подклассы (например, SalesPerson и Manager) расширяют общие функциональные возможности, добавляя специфические элементы поведения.
Для нашего примера мы предположим, что класс Manager расширяет Employee, обеспечивал запись числа опционов, а класс SalesPerson поддерживает информацию о числе продаж. В C# расширение класса задается в определении класса операцией, обозначаемой двоеточием (:). Так получаются производные типы класса в следующем фрагменте программного кода.
// Добавление двух подклассов в пространстве имен Employees.
namespace Employees {
public class Manager: Employee {
// Менеджер должен знать число опционов.
private ulong numberOfOptions;
public ulong NumbOpts {
get {return numberOfOptions;}
set {numberOfOptions = value;}
}
}
public class SalesPerson: Employee {
// Продавец должен знать число продаж.
private int numberOfSales;
public int NumbSales {
get {return numberOfSales;}
set {numberOfSales = value;}
}
}
}
Теперь, когда создано отношение подчиненности, SalesPerson и Manager автоматически наследуют все открытие (и защищенные) члены базового класса Employee. Например:
// Создание подкласса и доступ к функциональным возможностям
// базового класса.
static void Main (string[] args) {
// Создание экземпляра SalesPerson.
SalesPerson stan = new SalesPerson();
// Эти члены наследуют возможности базового класса Employee.
stan.ID = 100;
stan.Name = "Stan";
// Это определено классом SalesPerson.
stan.NumbSales = 42;
Console.ReadLine();
}
Следует знать, что наследование сохраняет инкапсуляцию. Поэтому производный класс не может иметь непосредственный доступ к приватным членам, определенным базовым классом.
Управление созданием базовых классов с помощью base
В настоящий момент SalesPerson и Manager можно создать только с помощью конструктора, заданного по умолчанию. Поэтому предположим, что в тип Manager добавлен новый конструктор с шестью аргументами, который вызывается так, как показано ниже.
static void Main(string[] args) {
// Предположим, что есть следующий конструктор с параметрами
// (имя, возраст, ID, плата, SSN, число опционов).
Manager chucky = new Manager("Chucky", 35, 92, 100000, "333-23-2322", 9000);
}
Если взглянуть на список аргументов, можно сразу понять, что большинство из них должно запоминаться в членах-переменных, определенных базовым классом Employee. Для этого вы могли бы реализовать этот конструктор так, как предлагается ниже.
// Если не указано иное, конструктор подкласса автоматически вызывает
// конструктор базового класса, заданный по умолчанию.
public Manager(string fullName, int age, int empID, float currPay, string ssn, ulong numbOfOpts) {
// Это наш элемент данных.
numberOfOptions = numbOfOpts;
// Использование членов, наследуемых от Employee,
// для установки данных состояния.
ID = empID;
Age = age;
Name = fullName;
SocialSecurityNumber = ssn;
Pay = currPay;
}
Строго говоря, это допустимый, но не оптимальный вариант. В C#, если вы не укажете иное, конструктор базового класса, заданный по умолчанию, вызывается автоматически до выполнения логики любого пользовательского конструктора Manager. После этого текущая реализация получает доступ к множеству открытых свойств базового класса Employee, чтобы задать его состояние. Поэтому здесь при создании производного объекта вы на самом деле "убиваете семь зайцев" (пять наследуемых свойств и два вызова конструктора)!
Чтобы оптимизировать создание производного класса, вы должны реализовать свои конструкторы подклассов так, чтобы явно вызвался подходящий пользовательский конструктор базового класса, а не конструктор, заданный по умолчанию. Таким образом можно уменьшить число вызовов инициализации наследуемых членов (что экономит время). Позвольте для этого модифицировать пользовательский конструктор.
// На этот раз используем ключевое слово C# "base" для вызова
// пользовательского конструктора с базовым классом.
public Manager (string fullName, int age, int empID, float currPay, string ssn, ulong numbOfOpts): base(fullName, age, empID, currPay, ssn) {
numberOfOptions = numbOfOpts;
}
Здесь конструктор был дополнен довольно запутанными элементами синтаксиса. Непосредственно после закрывающей скобки списка аргументов конcтруктора стоит двоеточие, за которым следует ключевое слово C# base. В этой ситуации вы явно вызываете конструктор с пятью аргументами, определенный классом Employees избавляясь от ненужных вызовов в процессе создания дочернего класса.
Конструктор SalesPerson выглядит почти идентично.
// Как правило, каждый подкласс должен явно вызывать
// подходящий конструктор базового класса.
public SalesPerson(string fullName, int age, int empID, float currPay, string ssn, int numbOfSales): base(fullName, age, empID, currPay, ssn) {
numberOfSales = numbOfSales;
}
Вы должны также знать о том. что ключевое слово base можно использовать всегда, когда подклассу нужно обеспечить доступ к открытым или защищенным членам, определённым родительским классом. Использование этого ключевого слова не ограничено логикой конструктора. В нашем следующем обсуждении полиморфизма вы увидите примеры, в которых тоже используется ключевое слово base.
Множественные базовые классы
Говоря о базовых классах, важно не забывать, что в C# каждый класс должен иметь в точности один непосредственный базовый класс. Таким образом, нельзя иметь тип с двумя или большим числом базовых классов (это называется множественным наследованием). Вы увидите в главе 7, что в C# любому типу позволяется иметь любое число дискретных интерфейсов. Таким образом класс в C# может реализовывать различные варианты поведения, избегая проблем, присущих классическому подходу, связанному с множественным наследованием. Аналогично можно сконфигурировать обычный интерфейс, как производный от множественных интерфейсов (см. главу 7).
Хранение семейных тайн: ключевое слово protected
Вы уже знаете, что открытые элементы непосредственно доступны отовсюду, а приватные элементы недоступны для объектов вне класса, определяющего эти элементы. Язык C#, занимающий лидирующие позиции среда многих других современных объектных языков, обеспечивает еще один уровень доступа: защищенный.
Если базовый класс определяет защищенные данные или защищенные члены, он может создать набор элементов, которые будут непосредственно доступны для любого дочернего класса. Например, чтобы позволить дочерним классам SalesPerson и Manager непосредственный доступ к сектору данных, определенному классом Employee, обновите оригинальное определение класса Employee так, как показано ниже.
// Защищенные данные состояния.
public class Employee {
// Дочерние классы могут иметь непосредственный доступ
// к этой информации, а пользователи объекта – нет.
protected string fullName;
protected int empID;
protected float currPay;
protected string empSSN;
protected int empAge;
…
}
Удобство определения защищенных членов в базовом классе заключается в том, что производные типы теперь могут иметь доступ к данным не только через открытые методы и свойства. Недостатком, конечно, является то, что при прямом доступе производного типа к внутренним данным родителя вполне вероятно случайное нарушение существующих правил, установленных в рамках общедоступных свойств (например, превышение допустимого числа страниц для "мини-романа"). Создавая защищенные члены, вы задаете определенный уровень доверия между родительским и дочерним классом, поскольку компилятор не сможет обнаружить нарушения правил, предусмотренных вами для данного типа.
