Основной структурой объектно-ориентрованного
программирования является класс. Классы –
это кирпичики, из которых состоит любая
программа на С#. Конечно же классы – это
основа С#. Поэтому я их рассматриваю в
первую очередь, хотя многие считают, что
надо начинать с типов данных и операторов.
Без знания классов и основных концепций
ООП невозможно создать действительно !качественного!
приложения в С#.
В классе определяются данные и код,
обрабатывающий эти данные. Активный
процесс С#-программы происходит внутри
класса. Класс является определением
составляющих объекта. Переменная типа
класса называется объектом, то есть объект
– это экземпляр класса. Под инициализацией
объекта понимается инициализация
переменных в объекте. Как и в C++,
инициализация объекта выполняется
специальной функцией – конструктором.
Класс может иметь несколько конструкторов,
но об этом попозже. Функции-методы и данные,
составляющие класс называют членами класса.
Итак, класс – это описание объекта (за
исключением одного момента, который вы
вскоре уловите). Я думаю, понятно, что данные
содержатся в переменных объекта, а код – в
функциях-методах. В С# применяется
следующая классификация членов класса:
- переменные;
- статические переменные;
- константы;
- конструкторы;
- деструкторы;
- методы;
- операторы;
- свойства;
- индексаторы;
- события;
Определение класса начинается, как и в С++,
с ключевого слова class. Например,
class example //example – это имя
класса
{
//-----------Объявление-переменных-------------
private int version; //эта переменная доступна только
для членов класса
public int amount; //а эта открыта для кода,
находящегося вне данного класса
//-----------Объявление-методов-------------------
public int get_version()//
{
//тело метода (код)
}
}
“public” & “private” называются
идентификаторами доступа.
А теперь напишем прогу...
using System;
class CPU //этот класс
описывает
{ //характеристики
проца
public char ID; //идентификатор
производителя
//(I->Intel, A->AMD)
public int freq; //рабочая
частота проца (Mhz)
public int CACHE; //размер кэша
(Kb)
}
class Application
{
public static void Main()
{
CPU object1 = new CPU();//создание
объекта класса CPU
object1.ID = ’A’;
object1.freq = 1700;
object1.CACHE = 256;
Console.WriteLine (“Made by “+object1.ID);
Console.WriteLine (“Frequence is”+object1.freq+”Mhz”);
Console.WriteLine (“CACHE has “+object1.CACHE+”Kb”);
}
Откомпилировав и запустив данную прогу, вы
должны увидеть, за каким беспонтовым
тазиком я работаю...
В классе CPU мы определили основные
характеристики процессора в качестве одной
символьной и двух целочисленных переменных.
Как создается объект в C#? Можно выделить 2
этапа (на примере вышеприведенного кода):
1) Объявление переменной object1 типа CPU. Но
переменная не является объектом, как,
например, в С++, а только ссылается на него.
2) Оператор new создает физическую реализацию
объекта, т.е. динамически выделяет память
под объект, на который теперь получает
ссылку переменная. Если мы наберем, к
примеру, CPU object2 = object1; мы не создадим нового
объекта, мы создадим новую ссылку на старый
объект.
Смысл оператора присваивания в первой
строке метода Main() заключается в том, что
переменная получает значение адреса
объекта в памяти. Можно создавать несколько
ссылок на один объект, приравнивая новые к
первой и т.д.
В C# память, занимаемая объектом, должна
выделяться строго динамически!
Теперь поговорим о конструкторах и
деструкторах. Это специальные методы,
отвечающие за инициализацию и удаление
объектов соответственно. Конструктор в С#
похож на конструктор в С++. И там и там
конструкторы и деструкторы не имеют
возвращаемого значения. Добавим к нашему
классу 2 конструктора:
class CPU //этот
класс описывает
{ //характеристики
проца
public char ID; //идентификатор
производителя
//(I->Intel, A->AMD)
public int freq; //рабочая
частота проца (Mhz)
public int CACHE; //размер кэша
(Kb)
public CPU() //конструктор по
умолчанию
{
ID = 0;freq = 0;CACHE = 0;//установка
в 0 значений
//всех переменных-членов
}
public CPU(char ID_,int freq_,int CACHE_)
{ //конструктор с тремя
параметрами -
//значениями для
переменных
ID = ID_;
freq = freq_;
CACHE = CACHE_;
}
}
В конструкторах чаще всего описывают
динамическое выделение памяти и задание
начальных значений некоторых переменных.
Показано два конструктора – по умолчанию и
с параметрами. Существуют и другие
разновидности конструкторов, но это как-нибудь
потом, а то перегруз инфы пойдет.
Конструктор в классе должен быть объявлен
открытым, т.е. public.
Еще одно нововведение С# - механизм сборки
мусора. Итак, оператор new динамически
выделяет память под объект. Но “...памяти
никогда не бывает много...” (так говорит мой
препод по Центральным Устройствам) и ее
надо освобождать после использования. В С++
мы это делали оператором delete. Сейчас память
освобождается сама тогда, когда объект
больше не используется, т.е. тогда, когда
отсутствуют обращения к нему. Память
освобождается при необходимости. Сборка
мусора производится только тогда, когда она
может быть выполнена эффективно, например,
для нескольких объектов одновременно.
Деструктор же может использоваться для
гарантии удаления. Можно его использовать
для осведомления пользователя о
деятельности нового чудо-механизма.
Деструктор, как и конструктор, имеет такое
же имя, как и класс, но перед ним ставится
знак ‘~’. А теперь, типа фокус...
class CPU //этот
класс описывает
{ //характеристики
проца
public char ID; //идентификатор
производителя
//(I->Intel, A->AMD)
public int freq; //рабочая
частота проца (Mhz)
public int CACHE; //размер кэша
(Kb)
public CPU() //конструктор по
умолчанию
{
ID = 0;freq = 0;CACHE = 0;//установка
в 0 значений
//всех переменных-членов
}
public CPU(char ID_,int freq_,int CACHE_)
{ //конструктор с тремя
параметрами -
//значениями для
переменных
ID = ID_;
freq = freq_;
CACHE = CACHE_;
}
}
public void CreateNewObject(char ID__,int freq__, int CACHE__)
{
CPU ob = new CPU(ID__,freq__,CACHE__); //это
используем
//для создание объектов
}
~CPU() //деструктор
{
System.Console.WriteLine(“Сгорел твой проц!!!”);
}
}
//--------------------
class Application
{
public static void Main()
{
int i;
CPU object = new CPU();
for(i=0;i<500000;i++) object.CreateNewObject(‘A’,1700,i);
}
}
Итак, мы создали множество объектов методом
CreateNewObject() в цикле for. Со временем они
перестают быть используемыми и удаляются,
причем группами. На экране должны
появляться сообщения от деструктора. Чаще
всего деструктор генерирует сообщения об
удалении объекта, т.е. для осведомления
пользователя. Сообщения деструкторов могут
выводится, например, в Status Bar’e.
Еще я хочу сказать пару слов о методах, и на
сегодня все... Метод является одной из двух
основных составляющих класса. Итак, что
такое метод? Это ни что иное, как старая
добрая сишная функция, являющаяся членом
класса. Кто не знаком с функциями, советую
взять любой учебник по С или С++ и посмотреть.
Метод содержит в себе определенный код,
последовательность операций, может
возвращать значение при помощи оператора
return:
return значение;
Метод может возвращать значение любого
типа, имеющегося в языке. Пример я пока не
привожу. Их потом будет более чем
достаточно.
А вот вам сувенирчик – ссылка
на .Net Framework SDK, содержащий компиляторы и
другие инструменты для создания .Net-приложений.
Весит около 132 Мб, но оно того стоит...
Советую скачать. Не советую качать без Getright
или подобной проги. Можно компилировать
программы на С#, не имея MS Visual Studio на семи
дисках.
И еще одно... Если вы считаете, что мои статьи
короткие, просьба написать об этом в
мнениях.
Следующая глава раскроет другие новые
аспекты объектно-ориентированной модели C#.
Это очень объемная тема, за один раз ее
сложно рассмотреть и преподнести. Да и не
зачем так мозги нагружать, мы же не в
универе! Еще хочу включить в следующую
статью перегрузку операторов и ключевое
слово this. Но пока не обещаю. Я считаю, что чем
меньше доза информации, тем больше прикола,
и она лучше усваивается. Я хочу, чтоб
читатели наслаждались чтением, а не
грузились. Поэтому такие вот короткие
статейки. Если я не прав, оставляйте свои
мнения...
Некоторые типы членов класса, как события,
свойства и т.д. будут рассмотрены
непосредственно перед первым
использованием, когда уровень сложности
статей и знаний читателей повысится, т.е.
немного позже.
