Абстрактные классы

Вот пример, иллюстрирующий использование абстрактных классов:
abstract class Figure
{
//Площадь фигуры
public abstract double square();
public abstract double perimeter();
}

Изолированные классы

Если вы хотите быть уверенными, что класс никогда не будет использован как базовый, при определении класса примените модификатор sealed. Единственное ограничение: абстрактный класс не может быть изолированным, так как в силу своей природы абстрактные классы предназначены для использования в качестве базовых. И еще. Хотя изолированные классы предназначены для предотвращения непреднамеренного создания производных классов, определение класса как изолированного позволяет выполнить оптимизацию периода выполнения. В частности, поскольку компилятор гарантирует отсутствие у класса любых производных классов, есть возможность преобразования виртуальных вызовов для изолированного класса в невиртуальные вызовы. Вот пример определения класса как изолированного:

using System;

sealed class MyPoint {

public HyPoint(int x, int y) {

this.x = x; this.у = у; }

private int X; public int x {

get

{

return this.X;

} set

<

this.X = value;

} }

private int Y; / public int у /

get {

return this.Y;

}

set

{

this.Y = value; } } >

class SealedApp {

public static void Main() {

MyPoint pt = new MyPoint(6,16);

Console.WriteLine("x = {0}, у = {1}", pt.x, pt.y); } }

11. Сложение:

1 1 1 1 0 0 1 0

+

1 0 1 0 1 0 1 0

-------------------------

11 0 0 1 1 1 0 0

Вычитание: 0-0=0

1-0=1

1-1=0

0-1=1 и заем единицы старшего разряда

Пример:

Умножение: Пример умножения «столбиком» (14 × 5 = 70):

Деление чисел в двоичной системе счисления производится по тем же правилам, что и для десятичных чисел, даже еще проще, поскольку мы имеем всегда только две цифры - 0 и 1. Например делим 11110₂ на 110₁₀:

1. Для перевода десятичного числа в восьмеричную систему его необходимо последовательно делить на 8 до тех пор, пока не останется остаток, меньший или равный 7. Число в восьмеричной системе записывается как последовательность цифр последнего результата деления и остатков от деления в обратном порядке.

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

Для перевода двоичного числа в шестнадцатеричное двоичное число нужно разбить на группы по четыре цифры (тетрады).

12. Под типом данных понимается набор доступных значений, которые может хранить переменная данного типа, и разрешенный набор операций над этими значениями. В языке C# различает две категории типов данных: значащие типы (value types) и ссылочные типы (reference types). Основное различие между ними состоит в том, что значащие типы хранят непосредственно свои значения, а ссылочные типы непосредственно хранят ссылки на свои значения. К значащим типам относятся:

 встроенные типы (описанные в библиотеке FCL), которые хранят одиночные значения, как например, int – целые; float – вещественные значения; bool – логические;  структуры – сложные типы, которые во многом сходны с классами, но значения которых хранятся в стеке

Типы, описываемые разработчиками. Кроме встроенных типов, которые предоставляются в языке C#, программист может описывать и использовать свои собственные (пользовательские) типы. Имеются следующие пользовательские типы: 1. классы (class); 2. структуры (struct); 3. перечисления (enum); 4.интерфейсы (interface); 5. делегаты (delegate).

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

[режим_доступа] [partial] class имя_класса { // описание элементов класса }

Классы это основные пользовательские типы данных.

Экземпляры класса – Объекты. Классы описывают все элементы объекта (данные) и его поведение (методы), также устанавливают начальные значения для данных объекта, если это необходимо. При создании экземпляра класса в памяти создается копия данных этого класса. Созданный таким образом экземпляр класса называется объектом. Экземпляр класса создается с помощью оператора new. Для получения данных объекта или вызова методов объекта, используется оператор. (точка). Student s;

s = new Student();

s.Name = “Иванов А.”;

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

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

struct PointS { // структура описания точек

public float x, y;

public PointS(float xx, float yy)

{ x = xx; y = yy; }

public override string ToString() {

return "{X:" + x + ";" + "Y:" + y + "}"; }}

Метод представляет собой блок кода, содержащий набор инструкций. Программа инициирует выполнение операторов, вызывая метод и задавая необходимые аргументы метода. В C# все инструкции выполняются в контексте метода. Метод Main является точкой входа для каждого приложения C#, и вызывается он средой CLR при запуске программы. Параметры заключаются в круглые скобки и разделяются запятыми. Пустые скобки указывают на то, что у метода нет параметров. Следующий класс содержит три метода.

abstract class Motorcycle

{ public void StartEngine() {/* Method statements here */ }

protected void AddGas(int gallons) { /* Method statements here */ }

public virtual int Drive(int miles, int speed) { /* Method statements here */ return 1; }

public abstract double GetTopSpeed(); }

Доступ к методам: class TestMotorcycle: Motorcycle

{ public override double GetTopSpeed()

{ return 108.4; }

static void Main()

{ TestMotorcycle moto = new TestMotorcycle();

moto.StartEngine();

moto.AddGas(15);

moto.Drive(5, 20);

double speed = moto.GetTopSpeed();

Console.WriteLine("My top speed is {0}", speed); } }

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

public class CalendarEntry

{

private DateTime date;

public string day;

public DateTime Date

{

get

{return date;}

set

{ if (value.Year > 1900 && value.Year <= DateTime.Today.Year)

{ date = value; }

else

throw new ArgumentOutOfRangeException(); }}

public void SetDate(string dateString)

{ DateTime dt = Convert.ToDateTime(dateString);

if (dt.Year > 1900 && dt.Year <= DateTime.Today.Year)

{ date = dt;}

else

throw new ArgumentOutOfRangeException(); }

public TimeSpan GetTimeSpan(string dateString)

{

DateTime dt = Convert.ToDateTime(dateString);

if (dt!= null && dt.Ticks < date.Ticks)

{ return date - dt;}

else

throw new ArgumentOutOfRangeException(); }}

13.Переменные – это именованные участки памяти, которые могут хранить: значения некоторого типа (для значащих типов, в стеке), ссылки на экземпляры некоторых классов (для ссылочных типов, ссылки на объекты, расположенные в "куче"). В C# выделяют два типа переменных: поля классов (объявляются в описаниях классов и создаются для каждого объекта) и локальные переменные методов (создаются при каждом вызове метода класса). Прежде, чем переменная может быть использована, она должна быть объявлена. Объявление переменных можно делать в любом месте программы. При объявлении переменных задается:имя (идентификаторы):Должно начинаться с буквы или подчерка (_), буква может быть из любого алфавита (unicode), количество символов не ограничено, тип (встроенный или пользовательский), могут быть заданы модификаторы (режим доступа, возможность изменения, сохранность значений). Формат объявление переменных:

<тип> <имя>;

<тип> <имя> [= <значение>]

[<модификаторы>] <тип> <имя> [= <значение>];

где [<модификаторы>] = {<режим доступа>, static, const}.

• Например:

public int x = 5;

public static const int n=10;

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

• Поле (field), известное также как переменная-член класса, находится в области видимости до тех пор, пока в этой области находится содержащий поле класс;
• Локальная переменная (local variable) - находится в области видимости до конца блока операторов или метода в котором она обьявлена;
• Локальная переменная, которая обьявлена в операторах for, while или подобных им, видна в пределах тела цикла.

Виды переменных по области видимости:

• Уровня класса (статические переменные класса)

– Доступ с помощью имени класса

– Время жизни – время работы программы

– Доступ из всех классов (если public)

• Уровня объекта класса (поля)

– Доступ с помощью ссылки на объект

– Время жизни – от new до удаления ссылок

– Доступ в методах класса (если public то из других классов)

• Уровня метода (локальные переменные)

– Доступ по имени

– Время жизни – выполнения метода

– Доступны только в методе после объявления

public void ScopeTest() {

int n = 0;

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

Console.WriteLine(i);

} // i выходит из области видимости и удаляется

// можно объявить другу переменную с именем i

{

var i = ”другой цикл”; // строка

Console.WriteLine(i);

} // i опять выходит из области видимости

for (int i = 9; i > = 0; i--) {

Console.WriteLine(i);

} // i еще раз выходит из области видимости

return;

} // переменная n тоже выходит из области видимости

14. Структурные блоки платформы.NET: CLI, CLR, CLS, CTS.

CLI это открытая спецификация разработанная фирмой Microsoft которая описывает код исполнительной программы и среду выполнения. Спецификация подразумевает среду разрешающую нескольким языкам высокого уровня быть использованными на разных компьютерных платформах без переписи под специфику архитектур. CLI это спецификация, а не реализация, также CLI часто путают с CLR, которая содержит аспекты вне спецификации. Спецификация CLI состоит из 4 аспектов: Common Type System (CTS) - Набор типов и операций которые используются во многих языках программирования.

Metadata - Информация о структуре программы является независимой от языка, потому вы можете использовать программу в разных языках. Common Language Specification (CLS) - Набор базовых правил, которые язык программирования CLI должен соблюдать, что-бы общаться с другими CLS языками.

Virtual Execution System (VES) - Загружает и выполняет CLI-совместимые программы, используя метаданные чтобы совместить сгенерированные куски кода во время исполнения.

CLR - специальная виртуальная машина, которая управляет компиляцией в инструкции процессора и выполнением модулей, состав-ленных на промежуточном языке; CLR начинает работать при каждом запуске управляемых модулей на выполнение. Она является основой.NET Framework. Среда CLR является виртуальной машиной, которая расположена поверх ОС (выполняется под управлением ОС и использует все ее возможности) и управляет выполнением приложений разработанных для платформы.Net. CLS представляет собой набор правил, которые во всех подробностях описывают минимальный и полный комплект функциональных возможностей, которые должен обязательно поддерживать каждый отдельно взятый.NET-компилятор для того, чтобы генерировать такой программный код, который мог бы обслуживаться CLR и к которому в то же время могли бы единообразным образом получать доступ все языки, ориентированные на платформу.NET. CLS может считаться просто подмножеством всех функциональных возможностей, определенных в CTS. Спецификация CLS обеспечивает расширенное и надежное взаимодействие языков, определяя набор функциональных возможностей, доступных разработчикам в разных языках. В CLS также устанавливаются требования к CLS-совместимости, которые позволяют проверять, соответствует ли управляемый код спецификации CLS, и определять для конкретного средства уровень поддержки разработки управляемого кода, в котором используются функциональные возможности CLS.

Common Type System (сокр. CTS, рус. Стандартная система типов) — часть.NET Framework, формальная спецификация, определяющая, как какой-либо тип (класс, интерфейс, структура, встроенный тип данных) должен быть определён для его правильного выполнения средой.NET. Кроме того, данный стандарт определяет, как определения типов и специальные значения типов представлены в компьютерной памяти. Целью разработки CTS было обеспечение возможности программам, написанным на различных языках программирования, легко обмениваться информацией. Как это принято в языках программирования, тип может быть описан как определение набора допустимых значений (например, «все целые от 0 до 10») и допустимых операций над этими значениями (например, сложение и вычитание).

15. В.NET все (классы, переменные, структуры и т.д.) разбито по пространствам имен, что позволяет избавиться от возможных конфликтов в именовании и, в тоже время, использовать одинаковые имена в разных пространствах. Пространство имен – это определенная область, внутри которой все имена должны быть уникальными. Пространство имен определяется с помощью ключевого слова namespace следующим образом:

namespace TextNamespace

{ Определение типов, классов, переменных }

Таким образом, можно определить собственное пространство имен, которое действует между фигурными скобками, где можно объявлять свои типы. Имя пространства имен может состоять из нескольких частей, разделенных точной. Для доступа к типам, объявленным внутри определенного пространства имен:

1. Имя_Пространстра_Имен.Переменная

2. Мы должны находиться в том же самом пространстве имен, т.е. внутри фигурных скобок.

3. Мы должны подключить пространство имен с помощью оператора using: using System.

Базовой единицей защиты, управления версиями и развертывания в.NET Framework является не управляемый модуль, а сборка (assembly).

Сборки образуют базовую единицу развертывания, управления версиями, повторного использования, областей действия активации и разрешений безопасности для приложений на основе.NET. Сборки принимают форму исполняемого файла (EXE) или файла библиотеки динамической компоновки (DLL); они являются стандартными блоками платформы.NET Framework. Среда CLR получает от них сведения, необходимые для реализации типов. Сборку можно представить как коллекцию типов и ресурсов, формирующих логическую единицу функциональности и собранных для совместной работы.

Сборки могут содержать один или несколько модулей. Например, крупные проекты могут быть спланированы таким образом, чтобы несколько разработчиков работали каждый над своим модулем, а вместе эти модули образовывали одну сборку.

16. При выполнении программы для хранения данных используются два участка оперативной памяти, которые называются стеком (stack) и " кучей ".

Стек (stack) – это линейный участок памяти (массив), который действует как структура данных типа «Последним пришел – первым ушел» (last-in, first-out – LIFO). Основной особенностью стека являются то, что данные могут добавляться только к вершине стека и удаляться из вершины. Добавление и удаление данных из произвольного места стека невозможно. Операции по добавлению и удаление элементов из стека выполняются очень быстро. Однако размер стека, как правило, ограни-чен, и время хранения данных зависит от времени жизни переменной. Для всех локальных переменных методов и передаваемых методам па-38

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

Куча (heap) – это область оперативной памяти, в разных частях которой могут выделяться участки для хранения объектов классов. В отличие от стека, такие участки памяти в "куче" могут выделяться и освобождаться в любом порядке. Хотя программа может хранить элементы данных в "куче", она не может явно удалять их из нее. Вместо этого компонент среды CLR, называемый «Сборщиком мусора» (Garbage Col-lector, GC), автоматически удаляет неиспользуемые участки "кучи", ко-гда он определит, что код программы уже не имеет доступа к ним (не хранит их адреса).

Переменные – это именованные участки памяти, которые могут хранить либо значения некоторого типа (для значащих типов, в стеке), либо ссылки на экземпляры некоторых классов (для ссылочных типов, ссылки на объекты, расположенные в "куче"). В C# также разделяют пе-ременные на поля классов (объявляются в описаниях классов и создают-ся для каждого объекта) и локальные переменные методов (создаются при каждом вызове метода класса). [модификаторы] <тип> <имя_переменной> При объявлении переменных указывается их тип и имя, где имя_переменной – это просто название переменной или название пере-менной с инициализацией (начальным значением). После типа можно указывать и список имен, разделенных запятой. Инициализацию можно осуществлять либо с помощью присваивания значений или с использованием конструкции new и вызовом конструктора по умолчанию.

int x, s; //без инициализации

int y =0, u = 77; //обычный способ инициализации

//допустимая инициализация

float w1 = 0f, w2 = 5.5f, w3 = w1 + w2 + 125.25f;

//допустимая инициализация в объектном стиле

int z= new int();

x = u + y; //теперь x инициализирована

В C# константы могут задаваться в виде литералов (набора сим-волов) или именованных констант. Например: y = 7.7;

Значение константы "7.7" является одновременно ее именем, а также она имеет и тип. По умолчанию константы с дробной частью имеют тип double. Точный тип константы можно задать с помощью символа, стоящего после литерала (в верхнем или нижнем регистре). Такими символами могут быть: f – тип float; d – тип double; m – тип decimal.

Также можно объявить именованную константу. Для этого в объявление переменной добавляется модификатор const. Именованные константы обязательно должны быть инициализированы и инициализация не может быть отложенной. Например:

const float с = 0.1f;

Под строковыми константами понимается последовательность символов заключенная в двойные кавычки ("): обычные константы, которые представляют строку символов, за-ключенную в двойные кавычки – "ssss"; @-константы, заданные обычной константой c предшествующим знаком @.

s1 = "c:\\c#book\\ch5\\chapter5.doc"

s2 = @"c:\c#book\ch5\chapter5.doc"

Таблица приоритетов операций, соответствующая Common Language Specification (CLS)

18. Отладка приложений в C#.

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

- нажмите F9
- выберите меню Debug | Toggle Breakpoint
- дважды щелкните на полоске серого цвета, слева от строки текста в окне редактора кода

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

Если точку на текущей строке установить нельзя, то в строке состояния среды разработки появиться соответствующее сообщение.

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

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

• Continue (F5) - продолжить выполнение программы.
• Stop debugging (Shift+F5) - остановить отладку. При этом остановится и выполнение программы. Даже больше - ваполнение программы прервется на той точке, на которой сейчас и находиться, т.е. оно не будет завершено корректно и ничего не сохранится, если вы в программе что-то делали;
• Restart (Ctrl+Shift+F5) - перезапустить программу. Выполнение программы будет прервано и запустится заново;
• Show Next Statement (Alt + Num *) - показать следующий оператор, т.е переместить курсор редактора кода в курсор пошагового выполнения. Курсор переместиться в начала оператора, который должен быть выполнен следующим. В редакторе кода он выделен желтым цветом;
• Step Into (F11) - выполнить очередной оператор. Если это метод, то перейти в начало этого метода, чтобы начать отладку. Например, если вы находитесь на строке: x = Double(x) то, курсор пошагового выполнения перейдет на начало метода Double и вы сможете отладить этот метод;
• Step Over (F10) - выполнить очередной оператор. Если это метод, то он будет полностью выполнен, т.е. курсор выполнения не будет входить внутрь метода;
• Step out (Shift + F11) - выйти из метода. Если вы отлаживаете метод и нажмете эту кнопку, то метод выполнится до конца и курсор пошагового выполнения выйдет из метода и остановится на следующей строке после вызова данного метода.

19. Язык UML представляет собой общецелевой язык визуального моделирования, который разработан для спецификации, визуализации, проектирования и документирования компонентов программного обеспечения, бизнес-процессов и других систем. Язык UML одновременно является простым и мощным средством моделирования, который может быть эффективно использован для построения концептуальных, логических и графических моделей сложных систем самого различного целевого назначения. Диаграмма классов (class diagram) служит для представления статической структуры модели системы в терминологии классов объектно-ориентированного программирования.

Класс (class) в языке UML служит для обозначения множества объектов, которые обладают одинаковой структурой, поведением и отношениями с объектами из других классов. Графически класс изображается в виде прямоугольника, который дополнительно может быть разделен горизонтальными линиями на разделы или секции. В этих разделах могут указываться имя класса, атрибуты (переменные) и операции (методы).

Обязательным элементов обозначения класса является его имя. На начальных этапах разработки диаграммы отдельные классы могут обозначаться простым прямоугольником с указанием только имени соответствующего класса.

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

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

Еще одним пользовательским типом являются интерфейсы – пользовательский тип, который описывает ссылочный тип, который не может иметь какой-либо реализации, для которого нельзя создавать экземпляры, и все методы которого являются открытыми. То, что интерфейс не может иметь реализации, означает, что все его методы и свойства являются абстрактными. Интерфейсы описывают формальный открытый контракт между провайдером сервиса (классами, которые реализуют интерфейс) и потребителями сервиса (другими классами, которые используют объекты класса, реализующего интерфейс).

Агрегирование — это процесс немного более сложный, чем вложенность (описываемая в следующем разделе).Агрегирование обычно используется, чтобы позволить внешнему объекту предоставлять доступ к реализации интерфейса другим объектом без изменения. Все управляемые объекты автоматически поддерживают агрегирование в COM-стиле, при которой управляемый объект используется в качестве внутреннего объекта. В языке C# допускает наследование одного класса от другого, таким образом потомок наследуется свойства и методы родителя. При этом родитель может быть только один, то есть множественное наследование не допускается. Наследование позволяет создавать новые классы на осно-ве существующих, при этом новые классы обладают всей функциональ-ностью старых и при необходимости могут модифицировать их.

• Наследование (Генерализация) — объекты дочернего класса наследуют все свойства родительского класса.
• Ассоциация — объекты классов вступают во взаимодействие между собой.
• Агрегация — объекты одного класса входят в объекты другого.
• Композиция — объекты одного класса входят в объекты другого и зависят друг от друга по времени жизни.

namespace HelloWorld

{

class Hello

{

static void Main()

{

Console.WriteLine("Hello World!");

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}

}

}

Поиск по сайту: