protected string empSSN;
protected int empAge;
…
}
Удобство определения защищенных членов в базовом классе заключается в том, что производные типы теперь могут иметь доступ к данным не только через открытые методы и свойства. Недостатком, конечно, является то, что при прямом доступе производного типа к внутренним данным родителя вполне вероятно случайное нарушение существующих правил, установленных в рамках общедоступных свойств (например, превышение допустимого числа страниц для "мини-романа"). Создавая защищенные члены, вы задаете определенный уровень доверия между родительским и дочерним классом, поскольку компилятор не сможет обнаружить нарушения правил, предусмотренных вами для данного типа.
Наконец, следует понимать, что с точки зрения пользователя объекта защищенные данные воспринимаются, как приватные (поскольку пользователь находится "за пределами семейства"). Так, следующий вариант программного кода некорректен.
static void Main(string[] args) {
// Ошибка! Защищенные данные недоступны на уровне экземпляра.
Employee emp = new Employee();
emp.empSSN = "111-11-1111";
}
Запрет наследования: изолированные классы
Создавая отношения базовых классов и подклассов, вы получаете возможность использовать поведение существующих типов. Но что делать, когда нужно определить класс, не позволяющий получение подклассов? Например, предположим, что в наше пространство имен добавлен еще один класс, расширяющий уже существующий тип SalesPerson. На рис. 4.8 показана соответствующая схема.
Рис. 4.8. Расширенная иерархия служащих
Класс PTSalesPerson является классом, представляющим продавца, работающего на неполную ставку, и предположим, например, что вы хотите, чтобы никакой другой разработчик не мог создавать подклассы из PTSalesPerson. (В конце концов, какую еще неполную ставку можно получить на основе неполной ставки?) Чтобы не допустить возможности расширения класса, используйте ключевое слово C# sealed.
// Класс PTSalesPerson не сможет быть базовым классом.
public sealed class PTSalesPerson: SalesPerson {
public PTSalesPerson(string fullName, int age, int empID, float currPay, string ssn, int numbOfSales): base (fullName, age, empID, currPay, ssn, numbOfSales) {
// Логика конструктора…
}
// Другие члены…
}
Поскольку класс PTSalesPerson изолирован, он не может служить базовым Классам никакому другому типу. Поэтому при попытке расширить PTSalesPersоn вы получите сообщение об ошибке компиляции.
// Ошибка компиляции!
public class ReallyPTSalesPerson: PTSalesPerson {…}
Наиболее полезным ключевое слово sealed оказывается при создании автономных классов утилит. Класс String, определённый в пространстве имен Sуstem, например, явно изолирован.
public sealed class string: object, IComparable, ICloneable, IConvertible, IEnumerable {…}
Поэтому вы не сможете создать новый класс, производный от System.String:
// Снова ошибка!
public class MyString: string
Если вы хотите создать новый класс, использующий функциональные возможности изолированного класса, единственным вариантом будет отказ от классического наследования и использование модели локализации/делегирования (известной еще как отношение локализации, "has-a").
Модель локализации/делегирования
Как уже отмечалось в этой главе, наследование можно реализовать двумя способами. Только что мы исследовали классическое отношение подчиненности ("is-a"). Чтобы завершить обсуждение второго принципа ООП, давайте рассмотрим отношение локализации (отношение "has-a", также известное под названием модели локализации/делегирования). Предположим, что мы создали новый класс, моделирующий пакет льгот работника.
// Этот тип будет функционировать, как вложенный класс.
public class BenefitPackage {
// Другие члены, представляющие пакет страховок,
// медицинского обслуживания и т.д.
public double ComputePayDeduction() {return 125.0;}
}
Ясно, что отношение подчиненности ("is-a") между типами BenefitPackage (пакет льгот) и Employee (работник) выглядело бы достаточно странно. (Является ли менеджер пакетом льгот? Вряд ли.) Но должно быть ясно и то, что какая-то связь между этими типами необходима. Короче, вы должны выразить ту идею, что каждый работник имеет ("has-a") пакет льгот. Для этого определение класса Employee следует обновить так", как показано ниже.
// Работники теперь имеют льготы.
public class Employee {
…
// Содержит объект BenefitPackage.
protected BenefitPackage empBenefits = new BenefitPackage();
}
Здесь вы успешно создали вложенный объект. Но чтобы открыть функциональные возможности вложенного объекта внешнему миру, требуется делегирование. Делегирование означает добавление в класс-контейнер таких членов, которые будут использовать функциональные возможности содержащегося в классе объекта. Например, можно изменить класс Employee так, чтобы он открывал содержащийся в нем объект empBenefits с помощью некоторого свойства, а также позволял использовать функциональные возможности этого объекта с помощью нового метода GetBenefitCost().
public class Employee {
protected BenefitPackage empBenefits = new BenefitPackage();
// Открытие некоторых функциональных возможностей объекта.
public double GetBenefitCost() {
return empBenefits.ComputePayDeduction();
}
// Доступ к объекту через пользовательское свойство.
public BenefitPackage Benefits {
get {return empBenefits;}
set {empBenefits = value;}
}
}
В следующем обновленном методе Main() обратите внимание на то, как можно взаимодействовать с внутренним типом BenefitsPackage, определяемым типом Employee.
static void Main(string[] args) {
Manager mel;
mel = new Manager();
Console.WriteLine (mel.Benefits.ComputerPayDeduction());
…
Consolе.ReadLine();
}
Вложенные определения типов
Перед тем как рассмотреть заключительный принцип ООП (полиморфизм), давайте обсудим технику программирования, называемую вложением типов. В C# можно определить тип (перечень, класс, интерфейс, структуру или делегат) в пределах области видимости класса или структуры. При этом вложенный ("внутренний") тип считается членом содержащего его ("внешнего") класса, с точки зрения среды выполнения ничем не отличающимся от любого другого члена (поля, свойства, метода, события и т.п.). Синтаксис, используемый для вложения типа, исключительно прост.
public class OuterClass {
// Открытый вложенный тип могут использовать все.
public class PublicInnerClass{}
// Приватный вложенный тип могут использовать только члены
// содержащего его класса.
private class PrivateInnerClass{}
}
Синтаксис здесь ясен, но понять, почему вы можете это делать, не так просто. Чтобы прийти к пониманию этого подхода, подумайте над следующим.
• Вложение типов подобно их композиции ("has-a"), за исключением того, что вы имеете полный контроль над доступом на уровне внутреннего типа, а не содержащегося объекта.
• Ввиду того, что вложенный тип является членом класса-контейнера, этот тип может иметь доступ к приватным членам данного класса.
• Часто вложенный тип играет роль вспомогательного элемента для класса-контейнера, и его использование "внешним миром" не предполагается.
Когда некоторый тип содержит другой тип класса, он может создавать члены-переменные вложенного типа, точно так же, как для любого другого своего элемента данных. Но если вы пытаетесь использовать вложенный тип из-за границ внешнего типа, вы должны уточнить область видимости вложенного типа, указав его абсолютное имя. Изучите следующий пример программного кода.
static void Main (string[] args) {
// Создание и использование открытого внутреннего класса. Все ОК!
OuterClass.PublicInnerClass inner;
inner = new OuterClass.PublicInnerClass();
// Ошибка компиляции! Нет доступа к приватному классу.
OuterClass.PrivateInnerClass inner2;
inner2 = new OuterClass.PrivateInnerClass();
}
Чтобы использовать этот подход в нашем примере, предположим, что мы вложили BenefitPackage непосредственно в тип класса Employee.
// Вложение BenefitPackage.
public class Employee {
...
