 |
Модификаторы доступа к компонентам классов в C#.
|
|
|
|
Классы и объекты в ООП
ООП — это методология программирования, основанная на организации кода в программе путем его группировки в виде объектов, то есть отдельных элементов, которые включают данные и код, оперирующий этими данными. Объектно-ориентированные программы организованы вокруг данных, исходя из главного принципа: «данные управляют доступом к коду».
Класс – это ряд схематических описаний способа построения объекта; шаблон, по которому определяется форма объекта. Является логической абстракцией. Физическое представление класса появится в оперативной памяти лишь после того, как будет создан объект этого класса. Объекты являются экземплярами класса. Класс является основной единицей инкапсуляции.
В классе указываются данные и код, который будет оперировать этими данными. Составляющие класса данные и код называют членами. Данные, определяемые классом, называют полями, или переменными экземпляра. Код, оперирующий данными, содержится в функциях-членах. К числу функций-членов относятся методы, свойства, события, конструкторы, деструкторы, индексаторы.
Класс создается с помощью ключевого слова class.
Общая форма определения простого класса в C#:
class имя_класса
{//Объявление переменных экземпляра
Доступ тип имя_переменной;
//…
Доступ тип имя_переменной;
//Объявление методов
Доступ возвращаемый_тип имя_метода (параметры)
{//тело метода
}
//…
Доступ возвращаемый_тип имя_метода (параметры)
{//тело метода
}
}
В правильно сконструированном классе должна быть сгруппирована логически связанная информация.
Определение class обозначает создание нового типа данных (лишь описывает тип, но не создает конкретный объект).
|
|
|
Объект в C# создается следующим образом:
Имя_класса имя_переменной = new Имя_класса();
Здесь объявленная переменная относится к типу класса не является объектом, а лишь переменной, которая может ссылаться на объект. С помощью оператора new создается конкретная, физическая, копия объекта, а ссылка на объект присваивается переменной имя_переменной. Оператор new динамически (т.е. во время выполнения) распределяет память для объекта и возвращает ссылку на него. В конце вызывается конструктор класса для инициализации полей класса. Каждый раз, когда получается экземпляр класса, создается объект, содержащий собственную копию каждой переменной экземпляра, определенной в данном классе.
Потому, что объекты классов доступны по ссылке, классы являются ссылочными типами.
В C# для доступа к члену класса служит оператор-точка. Оператор-точка связывает имя объекта с именем члена класса. Общая форма оператора-точки:
объект.член
Пример на C#:
using System;
namespace Example
{
class Example
{
public int FirstField;
public int SecondField;
public Example()
{
FirstField = 545;
SecondField = 235;
}
public int Sum()
{
int x = FirstField + SecondField;
return x;
}
}
class ExampleDemo
{
static void Main()
{
Example ex = new Example();
Console.WriteLine("Сумма равна: " + ex.Sum());
} } }
Абстрагирование в ООП
ООП — это методология программирования, основанная на организации кода в программе путем его группировки в виде объектов, то есть отдельных элементов, которые включают данные и код, оперирующий этими данными. Объектно-ориентированные программы организованы вокруг данных, исходя из главного принципа: «данные управляют доступом к коду».
Абстрагирование – это процесс выделения наиболее существенных характеристик некоторого объекта, отличающих его от всех других видов объектов, важных с точки зрения дальнейшего рассмотрения и анализа, и игнорирование менее важных или незначительных деталей.
Абстракция – это набор всех таких характеристик.
|
|
|
Абстрагирование позволяет отделить логический смысл фрагмента программы от проблемы его реализации, разделив внешнее описание (интерфейс) объекта и его внутреннюю организацию (реализацию).
Пример абстрагирования: в автомобиле можно выделить такие абстракции, как мотор, коробка передач, система зажигания и т.д.
В абстрактном классе определяется лишь самая общая форма для всех его производных классов, а наполнение ее деталями предоставляется каждому из этих классов. Для абстрактного класса нельзя создать экземпляр.
В C# абстрактный метод создается с помощью указываемого модификатора abstract. У абстрактного метода отсутствует тело, и поэтому он не реализуется в базовом классе. Т.е. он должен быть переопределен в производном классе.
Когда производный класс наследует абстрактный класс, в нем должны быть реализованы все абстрактные методы базового класса. В ином случае он должен быть объявлен также абстрактным.
Определение абстрактного метода в C#:
abstract тип имя(список_параметров);
Модификатор abstract может применяться только в методах экземпляра, но не в статических методах (static).
Абстрактными могут быть также индексаторы и свойства.
Класс, содержащий хотя бы один абстрактный метод, должен быть также объявлен как абстрактный с помощью модификатора abstract перед class.
Пример абстрагирования на C#:
public abstract class Person
{
abstract void move();
abstract void talk();
}
public class Baby: Person
{
public void move()
{
Console.WriteLine("Ползет");
}
public void talk()
{
Console.WriteLine("Плачет");
}
}
public class Adult: Person
{
public void move()
{
Console.WriteLine("Идет");
}
public void talk()
{
Console.WriteLine("Говорит");
} }
Инкапсуляция в ООП
ООП — это методология программирования, основанная на организации кода в программе путем его группировки в виде объектов, то есть отдельных элементов, которые включают данные и код, оперирующий этими данными. Объектно-ориентированные программы организованы вокруг данных, исходя из главного принципа: «данные управляют доступом к коду».
Одним из основных принципов ООП является инкапсуляция– это механизм программирования, объединяющий вместе код и данные, которыми он манипулирует, исключая как вмешательство извне, так и неправильное использование данных. Т.е. этот принцип касается способности языка скрывать излишние детали реализации от пользователя объекта.
|
|
|
Основной единицей инкапсуляции в C# является класс, который определяет форму объекта. Класс – ряд схематических описаний способа построения объекта.
Цель инкапсуляции – уйти от зависимости внешнего интерфейса класса (то, что могут использовать другие классы) от реализации. Чтобы малейшее изменение в классе не влекло за собой изменение внешнего поведения класса.
Объект – это элемент, поддерживающий инкапсуляцию. В объекте код, данные или же и то и другое могут быть открытыми или закрытыми. Закрытые данные или код доступны только остальной части объекта. Открытые данные или код доступны остальным частям программы.
Пример инкапсуляции на C#:
using System;
namespace Example
{
class Example
{
private int x = 7;
public int Op (int y)
{
return x * y;
}
}
class ExampleDemo
{
static void Main()
{
Example ex = new Example();
Console.WriteLine("Введите число, для умножения его на 7: ");
string k = Console.ReadLine();
Console.WriteLine("Результат умножения равен " + ex.Op(Convert.ToInt32(k))); } } }
В примере использовались следующие модификаторы доступа:
public – доступно из любого места в приложении;
private – доступен только в рамках класса, в котором определен;
По умолчанию используется модификатор private.
Наследование в ООП
ООП — это методология программирования, основанная на организации кода в программе путем его группировки в виде объектов, то есть отдельных элементов, которые включают данные и код, оперирующий этими данными. Объектно-ориентированные программы организованы вокруг данных, исходя из главного принципа: «данные управляют доступом к коду».
Одним из основных принципов ООП является наследование – это процесс, в ходе которого один объект приобретает свойства другого объекта. Этот процесс обеспечивает принцип иерархической классификации, он касается способности языка позволять строить новые определения классов на основе определений существующих классов. По сути, наследование позволяет расширить поведение базового (или родительского) класса, наследуя его основную функциональность в производном подклассе (дочернем классе).
|
|
|
Например, сорт яблок «антоновка» входит в общую классификацию сортов «яблок», которые в свою очередь относятся к классу «фрукты». Это означает, что класс «фрукты» обладает рядом свойств, которые распространяются и на подкласс «яблоки». Сорт яблок «антоновка» наследует свойства всех предшествующих классов, обладая в то же время свойствами, присущими только данному классу. Здесь между классами установлено отношение «является» (is-a). Такое отношение и называют наследованием.
Пример на C#:
using System;
namespace Example
{
class Fruit
{
public double Weight;
public string Color;
public string Ripeness;
public void Weight_out()
{
Console.WriteLine("Вес равен " + Weight + " кг.");
}
}
class Apple: Fruit
{
public double Diameter;
public int Age_apple_tree;
}
class Antonovka: Apple
{
public string Kislost;
public Antonovka()
{
Weight = 0.2;
Color = "Зеленый";
Kislost = "Очень кислое";
}
}
class ExampleDemo
{
static void Main()
{
Antonovka ant = new Antonovka();
ant.Weight_out();
}
}
}
Полиморфизм в ООП
ООП — это методология программирования, основанная на организации кода в программе путем его группировки в виде объектов, то есть отдельных элементов, которые включают данные и код, оперирующий этими данными. Объектно-ориентированные программы организованы вокруг данных, исходя из главного принципа: «данные управляют доступом к коду».
Одним из основных принципов ООП является полиморфизм (от греч. – множество форм) – это свойства, позволяющее одному интерфейсу получать доступ к общему классу действий.
Пример полиморфизма: руль машины, выполняющий одни и те же функции своеобразного интерфейса независимо от вида применяемого механизма управления машиной.
Концепция полиморфизма: «Один интерфейс – множество методов». Т.е. для группы взаимосвязанных действий можно разработать общий интерфейс. Полиморфизм позволяет упростить программу, позволяя использовать один и тот же интерфейс для описания общего класса действий. Выбор конкретного действия, в зависимости от ситуации, возлагается на компилятор.
К одному из способов реализации полиморфизма в C# относится перегрузка методов.
Полиморфный интерфейс класса конструируется с использованием любого количества виртуальных или абстрактных членов. Виртуальный член – это член базового класса, определяющий стандартную реализацию, которая может быть изменена в производном классе. Абстрактный член – это член базового класса, который не предусматривает стандартной реализации, а предлагает только сигнатуру. Когда производные классы переопределяют члены, определенные в базовом классе, они по существу переопределяют свою реакцию на один и тот же запрос.
|
|
|
Пример полиморфизма на C#:
using System;
namespace Example
{
class Fruit
{
public double Weight { get; set; }
public string Color { get; set; }
public virtual void Text_out()
{
Console.WriteLine("Это неизвестный фрукт");
}
}
class Apple: Fruit
{
public double Diameter = 5;
public override void Text_out()
{
Console.WriteLine("Это яблоко");
} }
class Banan: Fruit
{
public double length = 15;
public override void Text_out()
{
Console.WriteLine("Это банан");
} }
class ExampleDemo
{
static void Main()
{
Fruit fruit = new Fruit();
fruit.Text_out();
Apple apple = new Apple();
apple.Text_out();
Banan banan = new Banan();
banan.Text_out(); } } }
6. Описание классов в C#
Класс – это ряд схематических описаний способа построения объекта; шаблон, по которому определяется форма объекта.
В классе указываются данные и код, который будет оперировать этими данными. Составляющие класса данные и код называют членами. Данные, определяемые классом, называют полями, или переменными экземпляра. Код, оперирующий данными, содержится в функциях-членах. К числу функций-членов относятся методы, свойства, события, конструкторы, деструкторы, индексаторы.
Класс создается с помощью ключевого слова class. Класс должен определять только одну логическую сущность.
Общая форма определения простого класса в C#:
class имя_класса
{//Объявление переменных экземпляра
Доступ тип имя_переменной;
//…
Доступ тип имя_переменной;
//конструктор класса
доступ имя_класса(параметры)
{
//тело конструктора
}
~имя_класса()
{
//код деструктора
}
//Объявление методов
Доступ возвращаемый_тип имя_метода (параметры)
{//тело метода
}
//…
Доступ возвращаемый_тип имя_метода (параметры)
{//тело метода
}
}
Определение class обозначает создание нового типа данных (лишь описывает тип, но не создает конкретный объект).
Описание класса состоит из описания полей и методов. Описание каждого члена класса начинается с модификаторов доступа, которые определяют порядок доступа к членам класса (public, private, protected, internal). Указывать модификатор доступа необязательно, при отсутствии его по умолчанию считается модификатор доступа private. В определении методов возвращаемый_тип означает тип данных, возвращаемых методом. Если метод ничего не возвращает, то возвращаемый_тип стоит указать void. Параметры метода – это последовательность пар, состоящих из типа и идентификатора и разделенных запятыми. Они представляют собой переменные, получающие значение аргументов, передаваемых методу при его вызове.
Если программа начинается с данного класса, то в этом классе требуется указывать метод Main().
Конструктор инициализирует объект при его создании. У него такое же имя, как и у его класса, а с точки зрения синтаксиса он подобен методу, но у конструктора нет возвращаемого типа, указываемого явно. Доступ конструктора обычно представляет собой модификатор доступа public. Если конструктор в классе не определен, то в C# конструктор предоставляется автоматически, используемый по умолчанию и инициализирующий все переменные экземпляра по умолчанию (нулевым значением – если она относится к числовому типу данных, пустым значением – если к ссылочному, значением false – если тип bool).
Деструктор – метод, который вызывается непосредственно перед окончательным уничтожением объекта системой «сборки мусора». Деструктор объявляется аналогично конструктору, только перед его именем указывается знак тильда.
Класс можно объявлять как static:
static class имя_класса {}
Объекты статического класса создавать нельзя. В таком классе все члены должны быть объявлены как static.
Абстрактный класс создается с помощью модификатора типа abstract:
abstract class имя_класса {}
Класс, содержащий хотя бы один абстрактный метод, должен быть объявлен как абстрактный.
Для того, чтобы предотвратить наследование класса, необходимо указать ключевое слово sealed перед определением класса:
sealed class имя_класса {}
Не допускается одновременно объявлять класс как sealed, abstract и static, он может иметь только один из этих модификаторов или не иметь вообще.
Пример описания класса:
sealed class Example
{
public int x;
public string Text;
bool flag;
public Example(int i)
{
x+=i;
Text = “Test”;
}
~Example(int k)
{
x-=k;
}
public void Text_out()
{
Console.WriteLine(Text);
}
public int Sum(int z)
{
return (z+x);
}
}
Модификаторы доступа к компонентам классов в C#.
Ограничение доступа к членам класса является основополагающим этапом ООП, поскольку позволяет исключить неверное использование объекта. Управление доступом в языке C# организуется с помощью четырех модификаторов доступа: public, private, protected, internal.
Когда член класса обозначается модификатором public, он становится доступным из любого другого кода в программе, включая и методы, определенные в других классах.
Когда член класса обозначается модификатором private, он может быть доступен только другим членам этого класса.
Если ни один из спецификаторов доступа не указан, член класса считается закрытым для своего класса по умолчанию, поэтому при создании закрытых членов спецификатор private указывать необязательно.
Наследование класса не отменяет ограничения, накладываемые на доступ к закрытым членам класса.
С помощью модификатора protected создается защищенный член класса. Защищенный член является открытым в пределах иерархии классов, но закрытым за пределами этой иерархии. Т.е. защищенные члены класса являются закрытыми для своего класса, но все же наследуемые и доступные для производного класса.
Модификатор доступа internal определяет доступность члена во всех файлах сборки и его недоступность за пределами сборки. Сборка – один или несколько файлов, содержащих все необходимые сведения о развертывании программы и ее версии.
Из модификаторов protected и internal можно создать спаренный модификатор доступа protected internal. Такой уровень доступа может быть задан только для членов класса. Такой член доступен лишь в пределах собственной сборки или для производных типов.
Спецификатор доступа указывается перед остальной частью описания типа отдельного члена.
Примеры:
public string Text;
private int x;
protected bool flag;
internal char c;
protected internal double y;
Пример использования всех модификаторов типов:
using System;
namespace Example
{
class BaseClass
{
public double x = 0.2;
string Text = "Test";
internal bool flag;
protected char c = 'c';
protected internal virtual void Text_out()
{
Console.WriteLine(x + Text + flag + c);
}
}
class Class1: BaseClass
{
public string NewText;
protected internal void Text_out()
{
Console.WriteLine(x + NewText + flag + c);
}
}
class ExampleDemo
{
static void Main()
{
BaseClass bc = new BaseClass();
bc.Text_out();
bc.x = 0.1;
bc.flag = true;
Class1 c1 = new Class1();
c1.Text_out(); } } }
8. Статические компоненты класса в C#
Статический компонент класса – это такой член класса, который становится доступным до создания любых объектов своего класса и без ссылки на какой-нибудь объект. Для создания такого члена класса необходимо указать в самом начале его объявления ключевое слово static. С помощью ключевого слова static можно объявлять, как переменные, так и методы. Наиболее характерным примером члена типа static является метод Main(), который объявляется таковым потому, что он должен вызываться ОС в самом начале выполняемой программы.
Чтобы воспользоваться членом типа static за пределами класса, необходимо указать имя этого класса с оператором-точкой. Т.е. статический член класса оказывается доступным не по ссылке на объект, а по имени своего класса.
Переменные, объявляемые как static, являются глобальными. Когда объекты объявляются в своем классе, копии статических переменных не создаются (все экземпляры класса пользуются одной переменной. Такая переменная инициализируется перед ее применением в классе явно или по умолчанию нулевым значением – если она относится к числовому типу данных, пустым значением – если к ссылочному, значением false – если тип bool).
Статический метод отличается от обычного метода тем, что его можно вызывать по имени его класса, не создавая экземпляр объекта этого класса (Пример такого метода – метод Sqrt() типа static класса System.Math).
Ограничения на применение статических методов:
· в статическом методе должна отсутствовать ссылка this, поскольку такой метод не выполняется относительно какого-то объекта;
· в статическом методе допускается непосредственный вызов только других статических методов, но не метода экземпляра из того же самого класса, т.к. у статического метода отсутствуют объекты, которыми он мог бы оперировать;
· для статического метода непосредственно доступными оказываются только другие статические данные, определенные в его классе.
Пример использования статических переменных и метода:
using System;
namespace Example
{
class StaticDemo
{
public static int Val = 100;
public static int ValDiv2()
{
return Val / 2;
}
}
class ExampleDemo
{
static void Main()
{
Console.WriteLine("Исходное значение переменной равно " + StaticDemo.Val);
StaticDemo.Val = 8;
Console.WriteLine("Текущее значение переменной равно " + StaticDemo.Val);
Console.WriteLine("Результат деления переменной на два: " + StaticDemo.ValDiv2());
} } }
Конструктор также может быть статическим. Такой конструктор, как правило, используется для инициализации компонентов, применяемых ко всему классу, а не к отдельному экземпляру объекта этого класса. Члены класса инициализируются статическим конструктором до создания каких-либо объектов этого класса. У статических конструкторов отсутствует модификатор доступа, т.е. он используется по умолчанию (private) и такой конструктор не может быть вызван из любого места программы.
Пример применения статического конструктора:
using System;
namespace Example
{
class StaticDemo
{
public static int Val;
static StaticDemo()
{
Val = 100;
Console.WriteLine("Статический конструктор");
}
public StaticDemo()
{
Console.WriteLine("Конструктор экземпляра");
}
public static int ValDiv2()
{
return Val / 2;
}
}
class ExampleDemo
{
static void Main()
{
StaticDemo sd = new StaticDemo();
Console.WriteLine("Исходное значение переменной равно " + StaticDemo.Val);
StaticDemo.Val = 8;
Console.WriteLine("Текущее значение переменной равно " + StaticDemo.Val);
Console.WriteLine("Результат деления переменной на два: " + StaticDemo.ValDiv2()); } } }
Класс также может быть объявлен как static. Создавать объекты статического класса нельзя, статический класс должен содержать только статические члены. У статического класса может быть статический конструктор.
Форма объявления статического класса:
static class имя_класса {}
Статический класс может служить для хранения совокупности связанных друг с другом статических методов.
Пример использования статического класса:
using System;
namespace Example
{
static class StaticDemo
{
static public double Div(double k)
{
return 1 / k;
}
static public double FracPart(double k)
{
return k - (int)k;
}
}
class ExampleDemo
{
static void Main()
{
Console.WriteLine("Обратная величина числа 5 равна " + StaticDemo.Div(5));
Console.WriteLine("Дробная часть полученного числа равно " + StaticDemo.FracPart(StaticDemo.Div(5))); } } }
|
|
|
