Способы передачи аргументов методу

Методы и классы

Управление доступом к членам класса

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

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

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

Модификаторы доступа

Управление доступом в языке С# организуется с помощью четырех модификаторов доступа: public, private, protected и internal. Основное внимание уделим модификаторам доступа public и private. (Модификатор protected при­меняется только в тех случаях, которые связаны с наследованием, и поэтому речь о нем пойдет позднее. А модификатор internal служит в основном для сборки, которая в широком смысле означает в С# разворачиваемую программу или библиотеку, и поэ­тому данный модификатор подробнее рассматривается также позднее.)

Когда член класса обозначается спецификатором public, он становится доступ­ным из любого другого кода в программе, включая и методы, определенные в других классах. Когда же член класса обозначается спецификатором private, он может быть доступен только другим членам этого класса. Следовательно, методы из других классов не имеют доступа к закрытому члену (private) данного класса. Как пояснялось в главе 6, если ни один из спецификаторов доступа не указан, член класса считается закры­тым для своего класса по умолчанию. Поэтому при создании закрытых членов класса спецификатор private указывать для них необязательно.

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

- Члены, используемые только в классе, должны быть закрытыми.

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

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

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

- Методы, получающие и устанавливающие значения закрытых данных, должны быть открытыми.

- Переменные экземпляра допускается делать открытыми лишь в том случае, если нет никаких оснований для того, чтобы они были закрытыми.

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

 

Способы передачи аргументов методу

 

1 способ. Передача по значению. В этом случае значение аргумента копируется в формальный параметр метода. Следовательно, изменения, вносимые в параметр метода, не оказывают никакого влияния на аргумент, используемый для вы­зова.

По умолчанию в С# используется вызов по значению, а это означает, что копия ар­гумента создается и затем передается принимающему параметру. Следовательно, при передаче значения обычного типа, например int или double, все, что происходит с параметром, принимающим аргумент, не оказывает никакого влияния за пределами метода. В качестве примера рассмотрим следующую программу.

 

// Передача аргументов обычных типов по значению.

 

using System;

 

class Test

{

/* Этот метод не оказывает никакого влияния

на аргументы, используемые для его вызова. */

public void NoChange(int i, int j) {

i = i + j;

j = -j;

}

}

 

class CallByValue {

static void Main() {

Test ob = new Test();

 

int a = 15, b = 20;

 

Console.WriteLine("a и b до вызова: " +

                  a + " " + b);

 

ob.NoChange(a, b); 

 

Console.WriteLine("a и b после вызова: " +

                  a + " " + b);

}

}

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

а и b до вызова: 15 2 0

а и b после вызова: 15 2 0

Как видите, операции, выполняемые в методе NoChange(), не оказывают никакого влияния на значения аргументов а и b, используемых для вызова данного метода. Это опять же объясняется тем, что параметрам i и j переданы копии значений аргументов а и b, а сами аргументы а и b совершенно не зависят от параметров i и j. В частности, присваивание параметру i нового значения не будет оказывать никакого влияния на аргумент а.

 

2 способ. Передача аргумента по ссылке. В данном случае параметру метода передается ссылка на аргумент, а не значение аргумента. В методе эта ссылка используется для доступа к конкретному аргументу, указываемому при вы­зове. Это означает, что изменения, вносимые в параметр, будут оказывать влияние на аргумент, используемый для вызова метода.

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

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

// Передача объектов по ссылке.

 

using System;

 

class Test

{

public int a, b;

 

public Test(int i, int j)

{

a = i;

b = j;

}

 

/* Передать объект. Теперь переменные ob.a и ob.b из объекта,

Используемого в вызове метода, будут изменены. */

public void Change(Test ob) {

ob.a = ob.a + ob.b;

ob.b = -ob.b;

}

}

 

class CallByRef {

static void Main() {

Test ob = new Test(15, 20);

 

Console.WriteLine("ob.a и ob.b до вызова: " +

                  ob.a + " " + ob.b);

 

ob.Change(ob);

 

Console.WriteLine("ob.a и ob.b после вызова: " +

                  ob.a + " " + ob.b);

}

}

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

ob.a и ob.b до вызова: 15 20

ob.a и ob.b после вызова: 35 -20

Как видите, действия в методе Change() оказали в данном случае влияние на объект, использовавшийся в качестве аргумента.

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