Текст книги "C# 4.0: полное руководство"
Автор книги: Герберт Шилдт
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 24 (всего у книги 83 страниц)
В предыдущих примерах программ был продемонстрирован основной принцип действия индексаторов и свойств, но их возможности не были раскрыты в полную силу. Поэтому в завершение этой главы обратимся к примеру класса RangeArray, в котором индексаторы и свойства используются для создания типа массива с пределами индексирования, определяемыми пользователем.
Как вам должно быть уже известно, индексирование всех массивов в C# начинается с нуля. Но в некоторых приложениях индексирование массива удобнее начинать с любой произвольной точки отсчета: с 1 или даже с отрицательного числа, например от -5 и до 5. Рассматриваемый здесь класс RangeArray разработан таким образом, чтобы допускать подобного рода индексирование массивов.
Используя класс RangeArray, можно написать следующий фрагмент кода.
RangeArray ra = new RangeArray(-5, 10); // массив с индексами от -5 до 10
for(int i=-5; i <= 10; i++) ra[i] = i; // индексирование массива от -5 до 10
Нетрудно догадаться, что в первой строке этого кода конструируется объект класса RangeArray с пределами индексирования массива от -5 до 10 включительно. Первый аргумент обозначает начальный индекс, а второй – конечный индекс. Как только объект ra будет сконструирован, он может быть проиндексирован как массив в пределах от -5 до 10.
Ниже приведен полностью класс RangeArray вместе с классом RangeArrayDemo, в котором демонстрируется индексирование массива в заданных пределах. Класс RangeArray реализован таким образом, чтобы поддерживать массивы типа int, но при желании вы можете изменить этот тип на любой другой.
/* Создать класс со специально указываемыми пределами индексирования массива. Класс RangeArray допускает индексирование массива с любого значения, а не только с нуля. При создании объекта класса RangeArray указываются начальный и конечный индексы. Допускается также указывать отрицательные индексы. Например, можно создать массивы, индексируемые от -5 до 5, от 1 до 10 или же от 50 до 56. */
using System;
class RangeArray {
// Закрытые данные.
int[] a; // ссылка на базовый массив
int lowerBound; // наименьший индекс int
int upperBound; // наибольший индекс
// Автоматически реализуемое и доступное
//только для чтения свойство Length,
public int Length { get; private set; }
// Автоматически реализуемое и доступное
//только для чтения свойство Error,
public bool Error { get; private set; }
// Построить массив по заданному размеру,
public RangeArray(int low, int high) {
high++;
if (high <= low) {
Console.WriteLine(«Неверные индексы»);
high = 1; // создать для надежности минимально допустимый массив
low = 0;
}
a = new int[high – low];
Length = high – low;
lowerBound = low;
upperBound = –high;
}
// Это индексатор для класса RangeArray.
public int this[int index] {
// Это аксессор get.
get {
if (ok(index)) {
Error = false;
return a[index – lowerBound];
}
else {
Error = true;
return 0;
}
}
// Это аксессор set.
set {
if (ok(index)) {
a[index – lowerBound] = value;
Error = false;
}
else
Error = true;
}
}
// Возвратить логическое значение true, если
// индекс находится в установленных границах,
private bool ok(int index) {
if (index >= lowerBound & index <= upperBound) return true;
return false;
}
}
// Продемонстрировать применение массива с произвольно
// задаваемыми пределами индексирования,
class RangeArrayDemo {
static void Main() {
RangeArray ra = new RangeArray(-5, 5);
RangeArray ra2 = new RangeArray(1, 10);
RangeArray ra3 = new RangeArray(-20, -12);
// Использовать объект ra в качестве массива.
Console.WriteLine("Длина массива ra: " + ra.Length);
for (int i = -5; i <= 5; i++) ra[i] = i;
Console.Write("Содержимое массива ra: ");
for (int i = -5; i <= 5; i++)
Console.Write(ra[i] + " ");
Console.WriteLine(«n»);
// Использовать объект ra2 в качестве массива.
Console.WriteLine("Длина массива га2: " + ra2.Length);
for (int i = 1; i <= 10; i++) ra2[i] = i;
Console.Write("Содержимое массива ra2: ");
for (int i = 1; i <= 10; i++)
Console.Write(ra2[i] + " ");
Console.WriteLine(«n»);
// Использовать объект ra3 в качестве массива.
Console.WriteLine("Длина массива ra3: " + ra3.Length);
for (int i = -20; i <= -12; i++) ra3[i] = i;
Console.Write("Содержимое массива ra3: ");
for (int i = -20; i <= -12; i++)
Console.Write(ra3[i] + " ");
Console.WriteLine(«n»);
}
}
При выполнении этого кода получается следующий результат.
Длина массива rа: 11
Содержимое массива rа: -5 -4 -3 -2 -1 0 1 2 3 4 5
Длина массива rа2: 10
Содержимое массива rа2: 1 2 3 4 5 6 7 8 9 10
Длина массива rа3: 9
Содержимое массива ra3: -20 -19 -18 -17 -16 -15 -14 -13 -12
Как следует из результата выполнения приведенного выше кода, объекты типа RangeArray можно индексировать в качестве массивов, начиная с любой точки отсчета, а не только с нуля. Рассмотрим подробнее саму реализацию класса RangeArray.
В начале класса RangeArray объявляются следующие закрытые переменные экземпляра.
// Закрытые данные.
int[] а; // ссылка на базовый массив
int lowerBound; // наименьший индекс
int upperBound; // наибольший индекс
Переменная а служит для обращения к базовому массиву по ссылке. Память для него распределяется конструктором класса RangeArray. Нижняя граница индексирования массива хранится в переменной lowerBound, а верхняя граница – в переменной upperBound.
Далее объявляются автоматически реализуемые свойства Length и Error.
// Автоматически реализуемое и доступное
//только для чтения свойство Length,
public int Length { get; private set; }
// Автоматически реализуемое и доступное
//только для чтения свойство Error,
public bool Error { get; private set; }
Обратите внимание на то, что в обоих свойства аксессор set обозначен как private. Как пояснялось выше, такое объявление автоматически реализуемого свойства, по существу, делает его доступным только для чтения.
Ниже приведен конструктор класса RangeArray.
// Построить массив по заданному размеру,
public RangeArray(int low, int high) {
high++;
if(high <= low) {
Console.WriteLine(«Неверные индексы»);
high = 1; // создать для надежности минимально допустимый массив
low = 0;
}
а = new int[high – low];
Length = high – low;
lowerBound = low;
upperBound = –high;
}
При конструировании объекту класса RangeArray передается нижняя граница массива в качестве параметра low, а верхняя граница – в качестве параметра high. Затем значение параметра high инкрементируется, поскольку пределы индексирования массива изменяются от low до high включительно. Далее выполняется следующая проверка: является ли верхний индекс больше нижнего индекса. Если это не так, то выдается сообщение об ошибке и создается массив, состоящий из одного элемента. После этого для массива распределяется память, а ссылка на него присваивается переменной а. Затем свойство Length устанавливается равным числу элементов массива. И наконец, устанавливаются переменные lowerBound и upperBound.
Далее в классе RangeArray реализуется его индексатор, как показано ниже.
// Это индексатор для класса RangeArray.
public int this[int index] {
// Это аксессор get.
get {
if(ok(index) ) {
Error = false;
return a[index – lowerBound];
}
else {
Error = true;
return 0;
}
}
// Это аксессор set.
set {
if(ok(index)) {
a[index – lowerBound] = value;
Error = false;
}
else
Error = true;
}
}
Этот индексатор подобен тому, что использовался в классе FailSoftArray, за одним существенным исключением. Обратите внимание на следующее выражение, в котором индексируется массив а.
index – lowerBound
В этом выражении индекс, передаваемый в качестве параметра index, преобразуется в индекс с отсчетом от нуля, пригодный для индексирования массива а. Данное выражение действует при любом значении переменной lowerBound: положительном, отрицательном или нулевом.
Ниже приведен метод ok().
// Возвратить логическое значение true, если
// индекс находится в установленных границах,
private bool ok(int index) {
if(index >= lowerBound & index <= upperBound) return true;
return false;
}
Этот метод аналогичен использовавшемуся в классе FailSoftArray, за исключением того, что в нем контроль границ массива осуществляется по значениям переменных lowerBound и upperBound.
Класс RangeArray демонстрирует лишь одну разновидность специализированного массива, который может быть создан с помощью индексаторов и свойств. Существуют, конечно, и другие. Аналогичным образом можно, например, создать динамические массивы, которые расширяются или сужаются по мере надобности, ассоциативные и разреженные массивы. Попробуйте создать один из таких массивов в качестве упражнения.
Наследование является одним из трех основополагающих принципов объектно-ориентированного программирования, поскольку оно допускает создание иерархических классификаций. Благодаря наследованию можно создать общий класс, в котором определяются характерные особенности, присущие множеству связанных элементов. От этого класса могут затем наследовать другие, более конкретные классы, добавляя в него свои индивидуальные особенности.
В языке C# класс, который наследуется, называется базовым, а класс, который наследует, – производным. Следовательно, производный класс представляет собой специализированный вариант базового класса. Он наследует все переменные, методы, свойства и индексаторы, определяемые в базовом классе, добавляя к ним свои собственные элементы.
Поддержка наследования в C# состоит в том, что в объявление одного класса разрешается вводить другой класс. Для этого при объявлении производного класса указывается базовый класс. Рассмотрим для начала простой пример. Ниже приведен класс TwoDShape, содержащий ширину и высоту двухмерного объекта, например квадрата, прямоугольника, треугольника и т.д.
// Класс для двумерных объектов,
class TwoDShape {
public double Width;
public double Height;
public void ShowDimO {
Console.WriteLine("Ширина и высота равны " +
Width + " и " + Height);
}
}
Класс TwoDShape может стать базовым, т.е. отправной точкой для создания классов, описывающих конкретные типы двумерных объектов. Например, в приведенной ниже программе класс TwoDShape служит для порождения производного класса Triangle. Обратите особое внимание на объявление класса Triangle.
// Пример простой иерархии классов,
using System;
// Класс для двумерных объектов.
class TwoDShape {
public double Width;
public double Height;
public void ShowDim() {
Console.WriteLine("Ширина и высота равны " +
Width + " и " + Height);
}
}
// Класс Triangle, производный от класса TwoDShape.
class Triangle : TwoDShape {
public string Style; // тип треугольника
// Возвратить площадь треугольника,
public double Area() {
return Width * Height / 2;
}
// Показать тип треугольника,
public void ShowStyle() {
Console.WriteLine("Треугольник " + Style);
}
}
class Shapes {
static void Main() {
Triangle t1 = new Triangle();
Triangle t2 = new Triangle();
t1.Width = 4.0;
t1.Height = 4.0;
t1.Style = «равнобедренный»;
t2.Width = 8.0;
t2.Height = 12.0;
t2.Style = «прямоугольный»;
Console.WriteLine("Сведения об объекте t1: ");
t1.ShowStyle();
t1.ShowDim();
Console.WriteLine ("Площадь равна " + t1.Area());
Console.WriteLine();
Console.WriteLine("Сведения об объекте t2: ");
t2.ShowStyle();
t2.ShowDim();
Console.WriteLine("Площадь равна " + t2.Area());
}
}
При выполнении этой программы получается следующий результат.
Сведения об объекте t1:
Треугольник равнобедренный
Ширина и высота равны 4 и 4
Площадь равна 8
Сведения об объекте t2:
Треугольник прямоугольный
Ширина и высота равны 8 и 12
Площадь равна 48
В классе Triangle создается особый тип объекта класса TwoDShape (в данном случае – треугольник). Кроме того, в класс Triangle входят все члены класса TwoDShape, к которым, в частности, добавляются методы Area() и ShowStyle(). Так, описание типа треугольника сохраняется в переменной Style, метод Area() рассчитывает и возвращает площадь треугольника, а метод ShowStyle() отображает тип треугольника.
Обратите внимание на синтаксис, используемый в классе Triangle для наследования класса TwoDShape.
class Triangle : TwoDShape {
Этот синтаксис может быть обобщен. Всякий раз, когда один класс наследует от другого, после имени базового класса указывается имя производного класса, отделяемое двоеточием. В C# синтаксис наследования класса удивительно прост и удобен в использовании.
В класс Triangle входят все члены его базового класса TwoDShape, и поэтому в нем переменные Width и Height доступны для метода Area(). Кроме того, объекты t1 и t2 в методе Main() могут обращаться непосредственно к переменным Width и Height, как будто они являются членами класса Triangle. На рис. 11.1 схематически показано, каким образом класс TwoDShape вводится в класс Triangle.
Рис. 11.1. Схематическое представление класса Triangle
Несмотря на то что класс TwoDShape является базовым для класса Triangle, в то же время он представляет собой совершенно независимый и самодостаточный класс. Если класс служит базовым для производного класса, то это совсем не означает, что он не может быть использован самостоятельно. Например, следующий фрагмент кода считается вполне допустимым.
TwoDShape shape = new TwoDShape();
shape.Width = 10;
shape.Height = 20;
shape.ShowDim();
Разумеется, объект класса TwoDShape никак не связан с любым из классов, производных от класса TwoDShape, и вообще не имеет к ним доступа.
Ниже приведена общая форма объявления класса, наследующего от базового класса.
class имя_производного_класса : имя_базового_класса {
// тело класса
}
Для любого производного класса можно указать только один базовый класс. В C# не предусмотрено наследование нескольких базовых классов в одном производном классе. (В этом отношении C# отличается от C++, где допускается наследование нескольких базовых классов. Данное обстоятельство следует принимать во внимание при переносе кода C++ в С#.) Тем не менее можно создать иерархию наследования, в которой производный класс становится базовым для другого производного класса. (Разумеется, ни один из классов не может быть базовым для самого себя как непосредственно, так и косвенно.) Но в любом случае производный класс наследует все члены своего базового класса, в том числе переменные экземпляра, методы, свойства и индексаторы.
Главное преимущество наследования заключается в следующем: как только будет создан базовый класс, в котором определены общие для множества объектов атрибуты, он может быть использован для создания любого числа более конкретных производных классов. А в каждом производном классе может быть точно выстроена своя собственная классификация. В качестве примера ниже приведен еще один класс, производный от класса TwoDShape и инкапсулирующий прямоугольники.
// Класс для прямоугольников, производный от класса TwoDShape.
class Rectangle : TwoDShape {
// Возвратить логическое значение true, если
// прямоугольник является квадратом,
public bool IsSquare() {
if(Width == Height) return true;
return false;
}
// Возвратить площадь прямоугольника,
public double Area() {
return Width * Height;
}
}
В класс Rectangle входят все члены класса TwoDShape, к которым добавлен метод IsSquare(), определяющий, является ли прямоугольник квадратом, а также метод Area(), вычисляющий площадь прямоугольника.
Как пояснялось в главе 8, члены класса зачастую объявляются закрытыми, чтобы исключить их несанкционированное или незаконное использование. Но наследование класса не отменяет ограничения, накладываемые на доступ к закрытым членам класса. Поэтому если в производный класс и входят все члены его базового класса, в нем все равно оказываются недоступными те члены базового класса, которые являются закрытыми. Так, если сделать закрытыми переменные класса TwoDShape, они станут недоступными в классе Triangle, как показано ниже.
// Доступ к закрытым членам класса не наследуется.
// Этот пример кода не подлежит компиляции.
using System;
// Класс для двумерных объектов,
class TwoDShape {
double Width; // теперь это закрытая переменная
double Height; // теперь это закрытая переменная
public void ShowDim() {
Console.WriteLine("Ширина и высота равны " +
Width + " и " + Height);
}
}
// Класс Triangle, производный от класса TwoDShape.
class Triangle : TwoDShape {
public string Style; // тип треугольника
// Возвратить площадь треугольника,
public double Area() {
return Width * Height /2; // Ошибка, доступ к закрытому
// члену класса запрещен
}
// Показать тип треугольника,
public void ShowStyle() {
Console.WriteLine("Треугольник " + Style);
}
}
Класс Triangle не будет компилироваться, потому что обращаться к переменным Width и Height из метода Area() запрещено. А поскольку переменные Width и Height теперь являются закрытыми, то они доступны только для других членов своего класса, но не для членов производных классов.
–
ПРИМЕЧАНИЕ
Закрытый член класса остается закрытым в своем классе. Он не доступен из кода за пределами своего класса, включая и производные классы.
–
На первый взгляд, ограничение на доступ к частным членам базового класса из производного класса кажется трудно преодолимым, поскольку оно не дает во многих случаях возможности пользоваться частными членами этого класса. Но на самом деле это не так. Для преодоления данного ограничения в C# предусмотрены разные способы. Один из них состоит в использовании защищенных (protected) членов класса, рассматриваемых в следующем разделе, а второй – в применении открытых свойств для доступа к закрытым данным.
Как пояснялось в предыдущей главе, свойство позволяет управлять доступом к переменной экземпляра. Например, с помощью свойства можно ввести ограничения на доступ к значению переменной или же сделать ее доступной только для чтения. Так, если сделать свойство открытым, но объявить его базовую переменную закрытой, то этим свойством можно будет воспользоваться в производном классе, но нельзя будет получить непосредственный доступ к его базовой закрытой переменной.
Ниже приведен вариант класса TwoDShape, в котором переменные Width и Height превращены в свойства. По ходу дела в этом классе выполняется проверка: являются ли положительными значения свойств Width и Height. Это дает, например, возможность указывать свойства Width и Height в качестве координат формы в любом квадранте прямоугольной системы координат, не получая заранее их абсолютные значения.
// Использовать открытые свойства для установки и
// получения .значений закрытых членов класса.
using System;
// Класс для двумерных объектов,
class TwoDShape {
double pri_width; // теперь это закрытая переменная
double pri_height; // теперь это закрытая переменная
// Свойства ширины и высоты двумерного объекта,
public double Width {
get { return pri_width; }
set { pri_width = value < 0 ? -value : value; }
}
public double Height {
get { return pri_height; }
set { pri_height = value < 0 ? -value : value; }
}
public void ShowDim() {
Console.WriteLine("Ширина и высота равны " +
Width + " и " + Height);
}
}
// Класс для треугольников, производный от
// класса TwoDShape.
class Triangle : TwoDShape {
public string Style; // тип треугольника
// Возвратить площадь треугольника,
public double Area() {
return Width * Height / 2;
}
// Показать тип треугольника,
public void ShowStyle() {
Console.WriteLine("Треугольник " + Style);
}
}
class Shapes2 {
static void Main() {
Triangle t1 = new Triangle();
Triangle t2 = new Triangle();
t1.Width = 4.0;
t1.Height = 4.0;
t1.Style = «равнобедренный»;
t2.Width = 8.0;
t2.Height = 12.0;
t2.Style = «прямоугольный»;
Console.WriteLine("Сведения об объекте t1: ");
t1.ShowStyle();
t1.ShowDim();
Console.WriteLine("Площадь равна " + t1.Area());
Console.WriteLine();
Console.WriteLine("Сведения об объекте t2: ");
t2.ShowStyle();
t2.ShowDim();
Console.WriteLine("Площадь равна " + t2.Area());
}
}
В этом варианте свойства Width и Height предоставляют доступ к закрытым членам pri_width и pri_height класса TwoDShape, в которых фактически хранятся значения ширины и высоты двумерного объекта. Следовательно, значения членов pri_width и pri_height класса TwoDShape могут быть установлены и получены с помощью соответствующих открытых свойств, несмотря на то, что сами эти члены по-прежнему остаются закрытыми.
Базовый и производный классы иногда еще называют суперклассом и подклассом соответственно. Эти термины происходят из практики программирования на Java. То, что в Java называется суперклассом, в C# обозначается как базовый класс. А то, что в Java называется подклассом, в C# обозначается как производный класс. Оба ряда терминов часто применяются к классу в обоих языках программирования, но в этой книге по-прежнему употребляются общепринятые в C# термины базового и производного классов, которые принято употреблять и в C++.
Организация защищенного доступа
Как пояснялось выше, открытый член базового класса недоступен для производного класса. Из этого можно предположить, что для доступа к некоторому члену базового класса из производного класса этот член необходимо сделать открытым. Но если сделать член класса открытым, то он станет доступным для всего кода, что далеко не всегда желательно. Правда, упомянутое предположение верно лишь отчасти, поскольку в C# допускается создание защищенного члена класса. Защищенный член является открытым в пределах иерархии классов, но закрытым за пределами этой иерархии.
Защищенный член создается с помощью модификатора доступа protected. Если член класса объявляется как protected, он становится закрытым, но за исключением одного случая, когда защищенный член наследуется. В этом случае защищенный член базового класса становится защищенным членом производного класса, а значит, доступным для производного класса. Таким образом, используя модификатор доступа protected, можно создать члены класса, являющиеся закрытыми для своего класса, но все же наследуемыми и доступными для производного класса.
Ниже приведен простой пример применения модификатора доступа protected.
// Продемонстрировать применение модификатора доступа protected,
using System;
class B {
protected int i, j; // члены, закрытые для класса В,
// но доступные для класса D
public void Set (int a, int b) {
i = a;
j = b;
}
public void Show() {
Console.WriteLine (i + " " + j);
}
}
class D : B {
int k; // закрытый член
// члены i и j класса В доступны для класса D
public void Setk() {
k = i * j;
}
public void Showk() {
Console.WriteLine(k) ;
}
}
class ProtectedDemo {
static void Main() {
D ob = new D();
ob.Set(2, 3); // допустимо, поскольку доступно для класса D
ob.Show(); // допустимо, поскольку доступно для класса D
ob.Setk(); // допустимо, поскольку входит в класс D
ob.Showk(); // допустимо, поскольку входит в класс D
}
}
В данном примере класс В наследуется классом D, а его члены i и j объявлены как protected, и поэтому они доступны для метода Setk(). Если бы члены i и j класса В были объявлены как private, то они оказались бы недоступными для класса D, и приведенный выше код нельзя было бы скомпилировать.
Аналогично состоянию public и private, состояние protected сохраняется за членом класса независимо от количества уровней наследования. Поэтому когда производный класс используется в качестве базового для другого производного класса, любой защищенный член исходного базового класса, наследуемый первым производным классом, наследуется как защищенный и вторым производным классом.
Несмотря на всю свою полезность, защищенный доступ пригоден далеко не для всех ситуаций. Так, в классе TwoDShape из приведенного ранее примера требовалось, чтобы значения его членов Width и Height были доступными открыто, поскольку нужно было управлять значениями, которые им присваивались, что было бы невозможно, если бы они были объявлены как protected. В данном случае более подходящим решением оказалось применение свойств, чтобы управлять доступом, а не предотвращать его. Таким образом, модификатор доступа protected следует применять в том случае, если требуется создать член класса, доступный для всей иерархии классов, но для остального кода он должен быть закрытым. А для управления доступом к значению члена класса лучше воспользоваться свойством.
