Введение в классы, объекты и методы



Мы поможем в написании ваших работ!


Мы поможем в написании ваших работ!



Мы поможем в написании ваших работ!


ЗНАЕТЕ ЛИ ВЫ?

Введение в классы, объекты и методы



Введение в классы, объекты и методы

Эта глава служит введением в классы. Класс составляет основу языка С#, поскольку он определяет характер объекта. Кроме того, класс служит основанием для объектно-ориентированного программирования (ООП). В пределах класса определяются данные и код. А поскольку классы и объекты относятся к основополагающим элементам С#, то для их рассмотрения требуется не одна глава книги. В данной главе рассмотрение классов и объектов начинается с их главных особенностей.

 

Определение класса

Для того чтобы продемонстрировать классы на конкретных примерах, разработаем постепенно класс, инкапсулирующий информацию о зданиях, в том числе о домах, складских помещениях, учреждениях и т.д. В этом классе (назовем его Building) бу­дут храниться три элемента информации о зданиях: количество этажей, общая пло­щадь и количество жильцов.

Ниже приведен первый вариант класса Building. В нем определены три перемен­ные экземпляра: Floors, Area и Occupants. Как видите, в классе Building вообще отсутствуют методы. Это означает, что в настоящий момент этот класс состоит только из данных. (Впоследствии в него будут также введены методы.)

class Building

{

public int Floors; // количество этажей

public int Area; // общая площадь здания

public int Occupants; // количество жильцов

}

Переменные экземпляра, определенные в классе Building, демонстрируют общий порядок объявления переменных экземпляра. Ниже приведена общая форма для объ­явления переменных экземпляра:

доступ тип имя_переменной;

где доступ обозначает вид доступа; тип - конкретный тип переменной, а имя_переменной - имя, присваиваемое переменной. Следовательно, за исключением специфи­катора доступа, переменная экземпляра объявляется таким же образом, как и локаль­ная переменная. Все переменные объявлены в классе Building с предваряющим их модификатором доступа public. Как пояснялось выше, благодаря этому они стано­вятся доступными за пределами класса Building.

Определение class обозначает создание нового типа данных. В данном случае но­вый тип данных называется Building. С помощью этого имени могут быть объявлены объекты типа Building. Не следует, однако, забывать, что объявление class лишь описывает тип, но не создает конкретный объект. Следовательно, в приведенном выше фрагменте кода объекты типа Building не создаются.

Для того чтобы создать конкретный объект типа Building, придется воспользо­ваться следующим оператором.

Building house = new Building(); // создать объект типа Building

После выполнения этого оператора объект house станет экземпляром класса Building, т.е. обретет "физическую" реальность. Не обращайте пока что внимание на отдельные составляющие данного оператора.

Всякий раз, когда получается экземпляр класса, создается также объект, содержа­щий собственную копию каждой переменной экземпляра, определенной в данном классе. Таким образом, каждый объект типа Building будет содержать свои копии переменных экземпляра Floors, Area и Occupants. Для доступа к этим перемен­ным служит оператор доступа к члену класса, который принято называть оператором-точкой. Оператор-точка связывает имя объекта с именем члена класса. Ниже приведе­на общая форма оператора-точки.

объект.член

В этой форме объект указывается слева, а член - справа. Например, присваива­ние значения 2 переменной Floors объекта house осуществляется с помощью сле­дующего оператора.

house.Floors = 2;

В целом, оператор-точка служит для доступа к переменным экземпляра и мето­дам. Ниже приведен полноценный пример программы, в которой используется класс Building.

Листинг 6.1

// Программа, в которой используется класс Building.

 

using System;

 

class Building

{

public int Floors; // количество этажей

public int Area; // общая площадь здания

public int Occupants; // количество жильцов

}

 

// В этом классе объявляется объект типа Building.

class BuildingDemo

{

static void Main()

{

Building house = new Building(); // создать объект типа Building

int areaPP; // площадь на одного человека

 

// Присвоить значения полям в объекте house.

house.Occupants = 4;

house.Area = 2500;

house.Floors = 2;

 

// Вычислить площадь на одного человека.

areaPP = house.Area / house.Occupants;

 

Console.WriteLine("Дом имеет:\n " +

house.Floors + " этажа\n " +

house.Occupants + " жильца\n " +

house.Area +

" кв. футов общей площади, из них\n " +

areaPP + " приходится на одного человека");

}

}

Эта программа состоит из двух классов: Building и BuildingDemo. В классе BuildingDemo сначала создается экземпляр house класса Building с помощью ме­тода Main(), а затем в коде метода Main() осуществляется доступ к переменным эк­земпляра house для присваивания им значений и последующего использования этих значений. Следует особо подчеркнуть, что Building и BuildingDemo - это два со­вершенно отдельных класса. Единственная взаимосвязь между ними состоит в том, что в одном из них создается экземпляр другого. Но, несмотря на то, что это раздельные классы, у кода из класса BuildingDemo имеется доступ к членам класса Building, поскольку они объявлены как открытые (public). Если бы при их объявлении не был указан спецификатор доступа public, то доступ к ним ограничивался бы пределами Building, а следовательно, их нельзя было бы использовать в классе BuildingDemo.

Допустим, что исходный текст приведенной выше программы сохранен в файле UseBuilding.cs. В результате ее компиляции создается файл UseBuilding.exe. При этом оба класса, Building и BuildingDemo, автоматически включаются в состав исполняемого файла. При выполнении данной программы выводится следующий ре­зультат.

Дом имеет:

2 этажа

4 жильца

2500 кв. футов общей площади, из них

625 приходится на одного человека

Но классам Building и BuildingDemo совсем не обязательно находиться в одном и том же исходном файле. Каждый из них можно поместить в отдельный файл, на­пример Building.cs и BuildingDemo.cs, а компилятору C# достаточно сообщить, что оба файла должны быть скомпилированы вместе. Так, если разделить рассматри­ваемую здесь программу на два таких файла, для ее компилирования можно восполь­зоваться следующей командной строкой.

csc Building.cs BuildingDemo.cs

Если вы пользуетесь интегрированной средой разработки Visual Studio, то вам нуж­но ввести оба упомянутых выше файла в свой проект и затем скомпоновать их.

Прежде чем двигаться дальше, рассмотрим следующий основополагающий прин­цип: у каждого объекта имеются свои копии переменных экземпляра, определенных в его классе. Следовательно, содержимое переменных в одном объекте может отли­чаться от их содержимого в другом объекте. Между обоими объектами не существует никакой связи, за исключением того факта, что они являются объектами одного и того же типа. Так, если имеются два объекта типа Building, то у каждого из них своя ко­пия переменных Floors, Area и Occupants, а их содержимое в обоих объектах может отличаться. Этот факт демонстрируется в следующей программе.

Листинг 6.2

// В этой программе создаются два объекта типа Building.

 

using System;

 

class Building

{

public int Floors; // количество этажей

public int Area; // общая площадь здания

public int Occupants; // количество жильцов

}

 

// В этом классе объявляется два объекта типа Building.

class BuildingDemo

{

static void Main()

{

Building house = new Building();

Building office = new Building();

 

int areaPP; // площадь на одного человека

 

// Присвоить значения полям в объекте house.

house.Occupants = 4;

house.Area = 2500;

house.Floors = 2;

 

// Присвоить значения полям в объекте office.

office.Occupants = 25;

office.Area = 4200;

office.Floors = 3;

 

// Вычислить площадь на одного человека в жилом доме.

areaPP = house.Area/house.Occupants;

 

Console.WriteLine("Дом имеет:\n " +

house.Floors + " этажа\n " +

house.Occupants + " жильца\n " +

house.Area +

" кв. футов общей площади, из них\n " +

areaPP + " приходится на одного человека");

 

 

Console.WriteLine();

 

// Вычислить площадь на одного человека в учреждении.

areaPP = office.Area/office.Occupants;

 

Console.WriteLine("Учреждение имеет:\n " +

office.Floors + " этажа\n " +

office.Occupants + " работников\n " +

office.Area +

" кв. футов общей площади, из них\n " +

areaPP + " приходится на одного человека");

}

}

Ниже приведен результат выполнения этой программы.

Дом имеет:

2 этажа

4 жильца

2500 кв. футов общей площади, из них

625 приходится на одного человека

Учреждение имеет:

3 этажа 25 работников

4200 кв. футов общей площади, из них

168 приходится на одного человека

Как видно, данные из объекта house полностью отделены от данных, содержащих­ся в объекте office. Эта ситуация наглядно показана на рис. 6.1.

 

Рисунок 6.1 - Переменные экземпляра одного объекта полностью отделены

от переменных экземпляра другого объекта

Создание объектов

В предыдущих примерах программ для объявления объекта типа Building ис­пользовалась следующая строка кода.

Building house = new Building();

Эта строка объявления выполняет три функции. Во-первых, объявляется перемен­ная house, относящаяся к типу класса Building. Сама эта переменная не является объектом, а лишь переменной, которая может ссылаться на объект. Во-вторых, соз­дается конкретная, физическая, копия объекта. Это делается с помощью оператора new. И наконец, переменной house присваивается ссылка на данный объект. Таким образом, после выполнения анализируемой строки объявленная переменная house ссылается на объект типа Building.

Оператор new динамически (т.е. во время выполнения) распределяет память для объ­екта и возвращает ссылку на него, которая затем сохраняется в переменной. Следова­тельно, в C# для объектов всех классов должна быть динамически распределена память.

Как и следовало ожидать, объявление переменной house можно отделить от созда­ния объекта, на который она ссылается, следующим образом.

Building house; // объявить ссылку на объект

house = new Building(); // распределить память для объекта типа Building

В первой строке объявляется переменная house в виде ссылки на объект типа Building. Следовательно, house - это переменная, которая может ссылаться на объ­ект, хотя сама она не является объектом. А во второй строке создается новый объект типа Building, и ссылка на него присваивается переменной house. В итоге перемен­ная house оказывается связанной с данным объектом.

То обстоятельство, что объекты классов доступны по ссылке, объясняет, почему классы называются ссылочными типами. Главное отличие типов значений от ссылочных типов заключается в том, что именно содержит переменная каждого из этих типов. Так, переменная типа значения содержит конкретное значение. Например, во фраг­менте кода

int х;

х = 10;

переменная х содержит значение 10, поскольку она относится к типу int, который является типом значения. Но в строке

Building house = new Building();

переменная house содержит не сам объект, а лишь ссылку на него.

Методы

Как пояснялось выше, переменные экземпляра и методы являются двумя основны­ми составляющими классов. До сих пор класс Building, рассматриваемый здесь в каче­стве примера, содержал только данные, но не методы. Хотя классы, содержащие только данные, вполне допустимы, у большинства классов должны быть также методы. Методы представляют собой подпрограммы, которые манипулируют данными, определенны­ми в классе, а во многих случаях они предоставляют доступ к этим данным. Как прави­ло, другие части программы взаимодействуют с классом посредством его методов.

Метод состоит из одного или нескольких операторов. В грамотно написанном коде C# каждый метод выполняет только одну функцию. У каждого метода имеется свое имя, по которому он вызывается. В общем, методу в качестве имени можно присвоить любой действительный идентификатор. Следует, однако, иметь в виду, что идентифи­катор Main() зарезервирован для метода, с которого начинается выполнение програм­мы. Кроме того, в качестве имен методов нельзя использовать ключевые слова С#.

Здесь методы именуются в соответствии с условными обозначениями, при­нятыми в литературе по С#. В частности, после имени метода следуют круглые скобки. Так, если методу присвоено имя GetVal, то в тексте книги он упоминается в следую­щем виде: GetVal(). Такая форма записи помогает отличать имена методов от имен переменных при чтении книги.

Ниже приведена общая форма определения метода:

доступ возращаемый_тип имя(список_параметров)

{

// тело метода

}

где доступ - это модификатор доступа, определяющий те части программы, из ко­торых может вызываться метод. Как пояснялось выше, указывать модификатор досту­па необязательно. Но если он отсутствует, то метод оказывается закрытым (private) в пределах того класса, в котором он объявляется. Мы будем пока что объявлять методы открытыми (public), чтобы вызывать их из любой другой части кода в программе. За­тем возращаемый_тип обозначает тип данных, возвращаемых методом. Этот тип должен быть действительным, в том числе и типом создаваемого класса. Если метод не возвра­щает значение, то в качестве возвращаемого для него следует указать тип void. Далее имя обозначает конкретное имя, присваиваемое методу. В качестве имени метода может служить любой допустимый идентификатор, не приводящий к конфликтам в текущей области объявлений. И наконец, список_параметров - это последовательность пар, со­стоящих из типа и идентификатора и разделенных запятыми. Параметры представляют собой переменные, получающие значение аргументов, передаваемых методу при его вы­зове. Если у метода отсутствуют параметры, то список параметров оказывается пустым.

Возврат из метода

В целом, возврат из метода может произойти при двух условиях. Во-первых, когда встречается фигурная скобка, закрывающая тело метода, как показывает пример метода AreaPerPerson() из приведенной выше программы. И во-вторых, когда выполняется оператор return. Имеются две формы оператора return: одна - для методов типа void, т.е. тех методов, которые не возвращают значения, а другая - для методов, возвра­щающих конкретные значения. Первая форма рассматривается в этом разделе, а в сле­дующем разделе будет пояснено, каким образом значения возвращаются из методов.

Для немедленного завершения метода типа void достаточно воспользоваться следующей формой оператора return,

return;

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

public void MyMeth()

{

int i;

 

for(i=0; i<10; i++)

{

if(i == 5) return; // прервать на шаге 5

Console.WriteLine();

}

}

В данном примере выполняется лишь 5 полноценных шагов цикла for, поскольку при значении 5 переменной i происходит возврат из метода.

В методе допускается наличие нескольких операторов return, особенно если име­ются два или более вариантов возврата из него. Например:

public void MyMeth()

{

// ...

if(done) return;

// ...

if (error) return;

}

В данном примере возврат из метода происходит в двух случаях: если метод за­вершает свою работу или происходит ошибка. Но пользоваться таким приемом про­граммирования следует очень аккуратно. Ведь из-за слишком большого числа точек возврата из метода может нарушиться структура кода.

Итак, напомним еще раз: возврат из метода типа void может произойти при двух условиях: по достижении закрывающей фигурной скобки или при выполнении опе­ратора return.

Возврат значения

Методы с возвратом типа void нередко применяются в программировании, тем не менее, большинство методов возвращает конкретное значение. В действительности способность возвращать значение является одним из самых полезных свойств метода. Возврат значения уже демонстрировался в главе 3 на примере метода Math.Sqrt(), использовавшегося для получения квадратного корня.

Возвращаемые значения используются в программировании с самыми разными целями. В одних случаях, как в примере метода Math.Sqrt(), возвращаемое значение содержит результат некоторого вычисления, в других - оно может просто указывать на успешное или неудачное завершение метода, а в третьих - содержать код состоя­ния. Но независимо от преследуемой цели использование возвращаемых значений является неотъемлемой частью программирования на С#.

Для возврата значения из метода в вызывающую часть программы служит следую­щая форма оператора return:

return значение;

где значение - это конкретное возвращаемое значение.

Используя возвращаемое значение, можно усовершенствовать рассматривавшийся ранее метод AreaPerPerson(). Вместо того чтобы выводить величину площади на одного человека, лучше возвратить ее из этого метода. Среди прочих преимуществ такого подхода следует особо отметить возможность использовать возвращаемое зна­чение для выполнения других вычислений. Приведенный ниже пример представляет собой улучшенный вариант рассматривавшейся ранее программы с усовершенство­ванным методом AreaPerPerson(), возвращающим величину площади на одного человека вместо того, чтобы выводить ее.

Листинг 6.4

// Возвратить значение из метода AreaPerPerson().

 

using System;

 

class Building {

public int Floors; // количество этажей

public int Area; // общая площадь здания

public int Occupants; // количество жильцрв

 

// Возвратить величину площади на одного человека.

public int AreaPerPerson() {

return Area / Occupants;

}

}

 

// использовать значение, возвращаемое методом AreaPerPerson().

class BuildingDemo {

static void Main() {

Building house = new Building();

Building office = new Building();

int areaPP; // area per person

 

// Присвоить значения полям в объекте house.

house.Occupants = 4;

house.Area = 2500;

house.Floors = 2;

 

// Присвоить значения полям в объекте office.

office.Occupants = 25;

office.Area = 4200;

office.Floors = 3;

 

// Получить площадь на одного человека в жилом доме.

areaPP = house.AreaPerPerson();

 

Console.WriteLine("house has:\n " +

house.Floors + " этажа\n " +

house.Occupants + " жильца\n " +

house.Area +

" кв. Футов общей площади, из них\n " +

areaPP + " area per person");

 

 

Console.WriteLine();

 

// Получить площадь на одного человека в учреждении.

areaPP = office.AreaPerPerson();

 

Console.WriteLine("office has:\n " +

office.Floors + " этажа\n " +

office.Occupants + " работников\n " +

house.Area +

" кв. Футов общей площади, из них\n " +

areaPP + " area per person");

}

}

Эта программа дает такой же результат, как и прежде.

В данной программе обратите внимание на следующее: когда метод AreaPerPerson() вызывается, он указывается в правой части оператора присваива­ния. А в левой части этого оператора указывается переменная, которой передается значение, возвращаемое методом AreaPerPerson(). Следовательно, после выполне­ния оператора

areaPP = house.AreaPerPerson();

в переменной areaPP сохраняется величина площади на одного человека в жилом доме (объект house).

Обратите также внимание на то, что теперь метод AreaPerPerson() имеет возвра­щаемый тип int. Это означает, что он будет возвращать целое значение вызывающей части программы. Тип, возвращаемый методом, имеет очень большое значение, по­скольку тип данных, возвращаемых методом, должен быть совместим с возвращаемым типом, указанным в методе. Так, если метод должен возвращать данные типа double, то в нем следует непременно указать возвращаемый тип double.

Несмотря на то что приведенная выше программа верна, она, тем не менее, написа­на не совсем эффективно. В частности, в ней можно вполне обойтись без переменной areaPP, указав вызов метода AreaPerPerson() непосредственно в операторе, содер­жащем вызов метода WriteLine(), как показано ниже.

Console.WriteLine("house has:\n " +

house.Floors + " этажа\n " +

house.Occupants + " жильца\n " +

house.Area +

" кв. Футов общей площади, из них\n " +

areaPP + " area per person");

В данном случае при выполнении оператора, содержащего вызов метода WriteLine(), автоматически вызывается метод house.AreaPerPerson(), а воз­вращаемое им значение передается методу WriteLine(). Кроме того, вызов метода AreaPerPerson() можно использовать всякий раз, когда требуется получить величи­ну площади на одного человека для конкретного объекта типа Building. Например, в приведенном ниже операторе сравниваются величины площади на одного человека для двух зданий.

if(b1.AreaPerPerson() > b2.AreaPerPerson())

Console.WriteLine("В здании b1 больше места для каждого человека");

Использование параметров

При вызове метода ему можно передать одно или несколько значений. Значение, передаваемое методу, называется аргументом. А переменная, получающая аргумент, называется формальным параметром, или просто параметром. Параметры объявляют­ся в скобках после имени метода. Синтаксис объявления параметров такой же, как и у переменных. А областью действия параметров является тело метода. За исключе­нием особых случаев передачи аргументов методу, параметры действуют так же, как и любые другие переменные.

Ниже приведен пример программы, в котором демонстрируется применение па­раметра. В классе ChkNum используется метод IsPrime(), который возвращает зна­чение true, если ему передается значение, являющееся простым числом. В против­ном случае он возвращает значение false. Следовательно, возвращаемым для метода IsPrime() является тип bool.

Листинг 6.5

// Простой пример применения параметра.

 

using System;

 

class ChkNum

{

// Возвратить значение true, если значение

// параметра x – простое число.

public bool IsPrime(int x)

{

if(x <= 1) return false;

 

for(int i=2; i <= x/i; i++)

if((x %i) == 0) return false;

 

return true;

}

}

 

class ParmDemo

{

static void Main()

{

ChkNum ob = new ChkNum();

 

for(int i=2; i < 10; i++)

if(ob.IsPrime(i)) Console.WriteLine(i + " простое число.");

else Console.WriteLine(i + " непростое число.");

}

}

Вот какой результат дает выполнение этой программы.

2 простое число.

3 простое число.

4 непростое число.

5 простое число.

6 непростое число.

7 простое число.

8 непростое число.

9 непростое число.

В данной программе метод IsPrime() вызывается восемь раз, и каждый раз ему передается другое значение. Проанализируем этот процесс более подробно. Прежде всего обратите внимание на то, как вызывается метод IsPrime(). Его аргумент указы­вается в скобках. Когда метод IsPrime() вызывается в первый раз, ему передается зна­чение 2. Следовательно, когда метод IsPrime() начинает выполняться, его параметр х принимает значение 2. При втором вызове этого метода его параметр х принимает значение 3, при третьем вызове - значение 4 и т.д. Таким образом, значение, пере­даваемое методу IsPrime() в качестве аргумента при его вызове, представляет собой значение, которое принимает его параметр х.

У метода может быть не только один, но и несколько параметров. Каждый его па­раметр объявляется, отделяясь от другого запятой. В качестве примера ниже приве­ден класс ChkNum, который расширен дополнительным методом LeastComFactor(), возвращающим наименьший общий делитель двух его аргументов. Иными слова­ми, этот метод возвращает наименьшее число, на которое оба его аргумента делятся нацело.

Листинг 6.6

// Добавить метод, принимающий два аргумента.

 

using System;

 

class ChkNum

{

// Возвратить значение true, если значение

// параметра x – простое число.

public bool IsPrime(int x)

{

if(x <= 1) return false;

 

for(int i=2; i <= x/i; i++)

if((x %i) == 0) return false;

 

return true;

}

 

// Возвратить наименьший общий делитель.

public int LeastComFactor(int a, int b) {

int max;

 

if(IsPrime(a) || IsPrime(b)) return 1;

 

max = a < b ? a : b;

 

for(int i=2; i <= max/2; i++)

if(((a%i) == 0) && ((b%i) == 0)) return i;

 

return 1;

}

}

 

class ParmDemo

{

static void Main() {

ChkNum ob = new ChkNum();

int a, b;

 

for(int i=2; i < 10; i++)

if(ob.IsPrime(i)) Console.WriteLine(i + " простое число.");

else Console.WriteLine(i + " непростое число.");

 

a = 7;

b = 8;

Console.WriteLine("Наименьший общий делитель " +

a + " and " + b + " is " +

ob.LeastComFactor(a, b));

 

a = 100;

b = 8;

Console.WriteLine("Наименьший общий делитель " +

a + " and " + b + " is " +

ob.LeastComFactor(a, b));

 

a = 100;

b = 75;

Console.WriteLine("Наименьший общий делитель " +

a + " and " + b + " is " +

ob.LeastComFactor(a, b));

 

}

}

Обратите внимание на следующее: когда вызывается метод LeastComFactor(), его аргументы также разделяются запятыми. Ниже приведен результат выполнения данной программы.

2 простое число.

3 простое число.

4 непростое число.

5 простое число.

6 непростое число.

7 простое число.

8 непростое число.

9 непростое число.

Наименьший общий делитель чисел 7 и 8 равен 1

Наименьший общий делитель чисел 100 и 8 равен 2

Наименьший общий делитель чисел 100 и 75 равен 5

Если в методе используется несколько параметров, то для каждого из них указы­вается свой тип, отличающийся от других. Например, приведенный ниже код является вполне допустимым.

int MyMeth(int a, double b, float с)

{

// ...

Конструкторы

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

house.Occupants = 4;

house.Area = 2500;

house.Floors = 2;

Такой прием обычно не применяется в профессионально написанном коде С#. Кро­ме того, он чреват ошибками (вы можете просто забыть инициализировать одно из по­лей). Впрочем, существует лучший способ решить подобную задачу: воспользоваться конструктором.

Конструктор инициализирует объект при его создании. У конструктора такое же имя, как и у его класса, а с точки зрения синтаксиса он подобен методу. Но у конструк­торов нет возвращаемого типа, указываемого явно. Ниже приведена общая форма конструктора.

доступ имя_класса{список_параметров)

{

// тело конструктора

}

Как правило, конструктор используется для задания первоначальных значений пе­ременных экземпляра, определенных в классе, или же для выполнения любых других установочных процедур, которые требуются для создания полностью сформирован­ного объекта. Кроме того, доступ обычно представляет собой модификатор доступа типа public, поскольку конструкторы зачастую вызываются в классе. А список_параметров может быть как пустым, так и состоящим из одного или более указываемых параметров.

У всех классов имеются конструкторы, независимо от того, определите вы их или нет, поскольку в C# автоматически предоставляется конструктор, используемый по умолчанию и инициализирующий все переменные экземпляра их значениями по умолчанию. Для большинства типов данных значением по умолчанию является ну­левое, для типа bool - значение false, а для ссылочных типов - пустое значение. Но как только вы определите свой собственный конструктор, то конструктор по умол­чанию больше не используется.

Ниже приведен простой пример применения конструктора.

Листинг 6.8

// Простой конструктор.

 

using System;

 

class MyClass

{

public int x;

 

public MyClass()

{

x = 10;

}

}

 

class ConsDemo

{

static void Main()

{

MyClass t1 = new MyClass();

MyClass t2 = new MyClass();

 

Console.WriteLine(t1.x + " " + t2.x);

}

}

В данном примере конструктор класса MyClass имеет следующий вид.

public MyClass()

{

x = 10;

}

Обратите внимание на то, что этот конструктор обозначается как public. Дело в том, что он должен вызываться из кода, определенного за пределами его класса. В этом конструкторе переменной экземпляра класса MyClass присваивается значе­ние 10. Он вызывается в операторе new при создании объекта. Например, в следующей строке:

MyClass tl = new MyClass();

конструктор MyClass() вызывается для объекта t1, присваивая переменной его эк­земпляра tl.х значение 10. То же самое происходит и для объекта t2. После констру­ирования переменная t2.х будет содержать то же самое значение 10. Таким образом, выполнение приведенного выше кода приведет к следующему результату.

10 10

Еще раз об операторе new

Теперь, когда вы ближе ознакомились с классами и их конструкторами, вернемся к оператору new, чтобы рассмотреть его более подробно. В отношении классов общая форма оператора new такова:

new имя_класса (список_аргументов)

где имя_класса обозначает имя класса, реализуемого в виде экземпляра его объекта. А имя_класса с последующими скобками обозначает конструктор этого класса. Если в классе не определен его собственный конструктор, то в операторе new будет исполь­зован конструктор, предоставляемый в C# по умолчанию. Следовательно, оператор new может быть использован для создания объекта, относящегося к классу любого типа.

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

Деструкторы

В языке C# имеется возможность определить метод, который будет вызываться не­посредственно перед окончательным уничтожением объекта системой "сборки му­сора". Такой метод называется деструктором и может использоваться в ряде особых случаев, чтобы гарантировать четкое окончание срока действия объекта. Например, деструктор может быть использован для гарантированного освобождения системного ресурса, задействованного освобождаемым объектом. Следует, однако, сразу же под­черкнуть, что деструкторы — весьма специфические средства, применяемые только в редких, особых случаях. И, как правило, они не нужны. Но здесь они рассматривают­ся вкратце ради полноты представления о возможностях языка С#.

Ниже приведена общая форма деструктора:

~имя_ класса ()

{

// код деструктора

}

где имя_класса означает имя конкретного класса. Следовательно, деструктор объяв­ляется аналогично конструктору, за исключением того, что перед его именем указы­вается знак "тильда" (~). Обратите внимание на то, что у деструктора отсутствуют воз­вращаемый тип и передаваемые ему аргументы.

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

Следует, однако, иметь в виду, что деструктор вызывается непосредственно перед "сборкой мусора". Он не вызывается, например, в тот момент, когда переменная, со­держащая ссылку на объект, оказывается за пределами области действия этого объек­та. (В этом отношении деструкторы в C# отличаются от деструкторов в C++, где они вызываются в тот момент, когда объект оказывается за пределами области своего дей­ствия.) Это означает, что заранее нельзя знать, когда именно следует вызывать деструк­тор. Кроме того, программа может завершиться до того, как произойдет "сборка му­сора", а следовательно, деструктор может быть вообще не вызван.

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

Листинг 6.12

// Продемонстрировать применение деструктора.

 

using System;

 

class Destruct

{

public int x;

 

public Destruct(int i)

{

x = i;

}

 

// Вызывается при утилизации объекта.

~Destruct()

{

Console.WriteLine("Destructing " + x);

}

 

// Создает объект и тут же уничтожает его.

public void Generator(int i)

{

Destruct o = new Destruct(i);

}

 

}

 

class DestructDemo

{

static void Main()

{

int count;

 

Destruct ob = new Destruct(0);

 

/* А теперь создать большое число объектов.

В какой-то момент произойдет “сборка мусора”.

Примечание: для того, чтобы активизировать

“сборку мусора”, возможно придется увеличить

число создаваемых объектов. */

 

for(count=1; count < 100000; count++)

ob.Generator(count);

 

Console.WriteLine("Готово!");

}

}

Эта программа работает следующим образом. Конструктор инициализирует пере­менную х известным значением. В данном примере переменная х служит в качестве идентификатора объекта. А деструктор выводит значение переменной х, когда объект утилизируется. Особый интерес вызывает метод Generator(), который создает и тут же уничтожает объект типа Destruct. Сначала в классе DestructDemo создается ис­ходный объект ob типа Destruct, а затем осуществляется поочередное создание и уни­чтожение 100 тыс. объектов. В разные моменты этого процесса происходит "сборка му­сора". Насколько часто она происходит - зависит от нескольких факторов, в том числе от первоначального объема свободной памяти, типа используемой операционной си­стемы и т.д. Тем не менее в какой-то момент начинают появляться сообщения, форми­руемые деструктором. Если же они не появятся до окончания программы, т.е. до того момента, когда будет выдано сообщение "Готово!", попробуйте увеличить число созда­ваемых объектов, повысив предельное количество подсчитываемых шагов в цикле for.

И еще одно важное замечание: метод WriteLine() вызывается в деструкторе - Destruct() исключительно ради наглядности данного примера его использования. Как правило, деструктор должен воздействовать только на переменные экземпляра, определенные в его классе.

В силу того что порядок вызова деструкторов не определен точно, их не следует применять для выполнения действий, которые должны происходить в определенный момент выполнения программы. В то же время имеется возможность запрашивать "сборку мусора", как будет показано далее при рассмотрении библио­теки классов С#. Тем не менее инициализация "сборки мусора" вручную в большин­стве случаев не рекомендуется, поскольку это может привести к снижению эффектив­ности программы. Кроме того, у системы "сборки мусора" имеются свои особенно­сти - даже если запросить "сборку мусора" явным образом, все равно нельзя заранее знать, когда именно будет утилизирован конкретный объект.

Ключевое слово this

Прежде чем завершать эту главу, необходимо представить ключевое слово this. Когда метод вызывается, ему автоматически передается ссылка на вызывающий объект, т.е. тот объект, для которого вызывается данный метод. Эта ссылка обозна­чается ключевым словом this. Следовательно, ключевое слово this обозначает именно тот объект, по ссылке на который действует вызываемый метод. Для того чтобы стало яснее назначение ключевого слова this, рассмотрим сначала пример программы, в которой создается класс Rect, инкапсулирующий ширину и высо­ту прямоугольника и включающий в себя метод Area(), возвращающий площадь прямоугольника.

Листинг 6.13

using System;

 

class Rect

{

public int Width;

public int Height;

 

public Rect(int w, int h)

{

Width = w;

Height = h;

}

 

public int Area()

{

return Width * Height;

}

}

 

class UseRect

{

static void Main()

{

Rect r1 = new Rect(4, 5);

Rect r2 = new Rect(7, 9);

 

Console.WriteLine("Площадь прямоугольника r1: " + r1.Area());

 

Console.WriteLine("Площадь прямоугольника r2: " + r2.Area());

}

}

 

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

return Width * Height;

в методе Area() означает, что копии переменных Width и Height, связанные с вы­зывающим объектом, будут перемножены, а метод возвратит их произведение. Но тот же самый оператор можно написать следующим образом.

return this.Width * this.Height;

В этом операторе ключевое слово this обозначает объект, для которого вызван метод Area(). Следовательно, в выражении this.Width делается ссылка на копию переменной Width данного объекта, а в выражении this.Height - ссы



Последнее изменение этой страницы: 2016-12-27; просмотров: 140; Нарушение авторского права страницы; Мы поможем в написании вашей работы!

infopedia.su Все материалы представленные на сайте исключительно с целью ознакомления читателями и не преследуют коммерческих целей или нарушение авторских прав. Обратная связь - 54.198.139.112 (0.011 с.)