Public virtual void GiveMoney(int money)

{ Console.WriteLine("Получите "+money+" рублей"); }}

Public class Teacher : Worker

{//Задаем необходимую функциональность

Public override void GiveMoney(int money)

{ int bonus = 1000;//премиальные 1000 руб

money = money + bonus;

base.GiveMoney(money); }}

Вот простой пример, иллюстрирующий перегрузку методов:

public void ovlDemo() {}

// Перегружаем метод ovlDemo() для одного целочисленного параметра

public void ovlDemo(int a) { Console.WriteLine("Одинпараметр: " + a); }

Перегруз операций:

Public class ComplexNumber

{ private int real;

private int imaginary;

Public ComplexNumber() : this(0, 0) // constructor

{ }

Public ComplexNumber(int r, int i) // constructor

{ real = r;

imaginary = i; }

// Override ToString() to display a complex number in the traditional format:

Public override string ToString()

{ return(System.String.Format("{0} + {1}i", real, imaginary)); }

// Overloading '+' operator:

public static ComplexNumber operator+(ComplexNumber a, ComplexNumber b)

{ return new ComplexNumber(a.real + b.real, a.imaginary + b.imaginary); }

// Overloading '-' operator:

Public static ComplexNumber operator-(ComplexNumber a, ComplexNumber b)

{ return new ComplexNumber(a.real - b.real, a.imaginary - b.imaginary); }}

Перегрузка методов. Функциональное назначение. Способ реализации. Примеры применения.

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

Перегрузка методов — один из способов реализации полиморфизма в С#. В общем случае для создания перегрузки некоторого метода достаточно объявить еще одну его версию. Об остальном позаботится компилятор. Но здесь необходимо отметить одно важное условие: все перегруженные методы должны иметь списки параметров, которые отличаются по типу и/или количеству. Методам для перегрузки недостаточно отличаться лишь типами возвращаемых значений.(Другими словами, тип возвращаемого значения не обеспечивает достаточную информацию для С#, чтобы можно решить, какой именно метод должен быть вызван). Конечно, перегруженные методы могут отличаться и типами возвращаемых значений. При вызове перегруженного метода выполняется та его версия, параметры которой совпадают (по типу и количеству) с заданными аргументами.

Вот простой пример, иллюстрирующий перегрузку методов:

public void ovlDemo() {}

// Перегружаем метод ovlDemo() для одного целочисленного параметра

public void ovlDemo(int a) { Console.WriteLine("Одинпараметр: " + a); }

Посредством перегрузки методов в С# поддерживается полиморфизм. В языке, который не поддерживает перегрузку методов, каждый метод должен иметь уникальное имя. Однако часто нужно реализовать один и тот же метод для различных типов данных. Возьмем, например, функцию, возвращающую абсолютное значение. В языках, которые не поддерживают перегрузку методов, обычно существует три или даже больше версий этой функции, причем их имена незначительно отличаются. Например, в языке С функция abs () возвращает абсолютное значение (модуль) целого числа, функция labs () возвращает модуль длинного целочисленного значения, а fabs () — модуль значения с плавающей точкой. Поскольку язык С не поддерживает перегрузку методов, каждая функция должна иметь собственное имя, несмотря на то, что все три функции выполняют по сути одно и то же действие. Это делает ситуацию сложнее, чем она есть на самом деле. Другими словами, при одних и тех же действиях программисту необходимо помнить имена всех трех (в данном случае) функций. Язык С# избавлен от ненужного "размножения" имен, поскольку все методы получения абсолютного значения могут использовать одно и то же имя. И в самом деле, библиотека стандартных классов С# включает метод получения абсолютного значения с именем Abs(). Этот метод перегружается С#-классом System.Math, что позволяет обрабатывать значения всех числовых типов, используя одно имя метода. Определение того, какая именно версия метода должна быть вызвана, основано на типе передаваемого аргумента.

Принципиальная значимость перегрузки состоит в том, что она позволяет обращаться к связанным методам посредством одного, общего для всех имени. Следовательно, имя Abs () представляет общее действие, которое выполняется во всех случаях. Компилятору остается правильно выбрать конкретную версию при конкретных обстоятельствах. А программисту нужно помнить лишь общую операцию, которая связана с именем того или иного метода. Благодаря полиморфизму применение нескольких имен сводится к одному. Несмотря на простоту приведенного примера, он все же позволяет понять, что перегрузка способна упростить процесс программирования.

Виртуальные методы. Функциональное назначение. Примеры применения.

Виртуальным называется метод, объявляемый с помощью ключевого слова virtual в базовом классе и переопределяемый в одном или нескольких производных классах. Таким образом, каждый производный класс может иметь собственную версию виртуального метода. Какую именно версию метода нужно вызвать, С# определяет по типу объекта, на который указывает эта ссылка, причем решение принимается динамически, во время выполнения программы. Следовательно, если имеются ссылки на различные объекты, будут выполняться различные версии виртуального метода. Другими словами, именно тип объекта, на который указывает ссылка (а не тип ссылки) определяет, какая версия виртуального метода будет выполнена. Чтобы объявить метод в базовом классе виртуальным, его объявление необходимо предварить ключевым словом virtual. При переопределении виртуального метода в производном классе используется модификатор override. Итак, процесс переопределения виртуального метода в производном классе иногда называется замещением метода (method overriding). При переопределении метода сигнатуры типа у виртуального и метода-заменителя должны совпадать. Кроме того, виртуальный метод нельзя определять как статический (с использованием слова static) или абстрактный (с использованием слова abstract).

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

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

Пример:

Class TwoDShape {

Public virtual double area() { Console.WriteLine("Метод area() необходимо переопределить. " ) ;

return 0.0; }}

class Triangle : TwoDShape { // Класс треугольников, производный от класса TwoDShape

public override double area() { // Переопределяем метод аrеa() для класса Triangle

return width * height / 2 ; } }

class Rectangle : TwoDShape { // Класс прямоугольников, производный от класса TwoDShape

public override doubl earea() {// Переопределяем метод аrеа() для класса Rectangle,

return width * height; } }

public static void Main() {

TwoDShape shape1 = new TwoDShape();

TwoDShape shape2 = new TwoDShape();

shape1= new Triangle();

shape2= new Rectangle(); }

Каждое переопределение метода area () реализует вариант вычисления площади, соответствующий типу объекта, инкапсулируемому производным классом.

Перегрузка операций. Функциональное назначение. Способ реализации. Примеры применения.

Под перегрузкой операции понимается существование нескольких реализаций одной и той же операции. Большинство операций языка C# перегружены - одна и та же операция может применяться к операндам различных типов. Поэтому перед выполнением операции идет поиск реализации, подходящей для данных типов операндов. Операции, как правило, выполняются над операндами одного типа. Если же операнды разных типов, то предварительно происходит неявное преобразование типа операнда.

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

При перегрузке оператора ни одно из его исходных значений не теряется. Перегрузку оператора можно расценивать как введение новой операции для класса. Эта расширяемость типов — важная составляющая мощи таких объектно-ориентированных языков программирования, как С#. Если для класса определены некоторые операторы, вы можете оперировать объектами этого класса, используя обычный С#-синтаксис выражений. Более того, вы можете использовать в выражениях объект, включающий другие типы данных. Перегрузка операторов — одно из самых мощных средств языка С#. Перегрузка операторов тесно связана с перегрузкой методов. Для перегрузки операторов используется ключевое слово operator, позволяющее создать операторный метод, который определяет действие оператора, связанное с его классом. Существует две формы методов operator: одна используется для унарных операторов, а другая — для бинарных. Общий же формат (для обоих случаев) таков:

public static тип_возврата operator ор{ тип_параметра операнд)

{// операции}

// Общий формат перегрузки для бинарного оператора,

public static тип_возврата operator op{тип_параметра1 операнд1, тип_параметра2 операнд2) {// операции }

Здесь элемент ор — это оператор (например " + " или " / " ), который перегружается. Пример:

public static Rational operator +(Rational r1, Rational r2)

{ return (r1.Plus(r2)); }//метод Plus складывает дроби

18. Управление областями видимости членов класса. Функциональное назначение. Способ реализации. Примеры применения.

До сих пор все переменные, с которыми мы имели дело, объявлялись в начале метода Main(). Однако в С# разрешается объявлять переменные внутри любого блока. Блок начинается открывающей, а завершается закрывающей фигурными скобками. Любой блок определяет область объявления, или область видимости (scope) объектов. Таким образом, при создании блока создается и новая область видимости, которая определяет, какие объекты видимы для других частей программы. Область видимости также определяет время существования этих объектов.

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

Как правило, переменные, объявленные в некоторой области видимости, невидимы (т.е. недоступны) для кода, который определяется вне этой области видимости. Таким образом, при объявлении переменной внутри области видимости вы локализируете ее и защищаете от неправомочного доступа и/или модификации. Эти правила области видимости обеспечивают основу для инкапсуляции. Области видимости могут быть вложенными. Например, при каждом создании программного блока создается новая вложенная область видимости. В этом случае внешняя область включает внутреннюю. Это означает, что объекты, объявленные внутри внешней области, будут видимы для кода внутренней области. Но обратное утверждение неверно: объекты, объявленные во внутренней области, невидимы вне ее. Чтобы лучше понять суть вложенных областей видимости, рассмотрим следующую

программу:

// Демонстрация области видимости блока.

using System;

class ScopeDemo {

public static void Main() {

int x; // Переменная х известна всему коду в пределах

// метода Main().

х = 10;

if(х — 10) { // Начало новой области видимости,

int у = 20; // Переменная у известна только этому блоку.

// Здесь известны обе переменные х и у.

Console.WriteLine("х и у: " + х + " " + у );

х = у * 2;

}

// у = 100; // Ошибка! Переменная у здесь неизвестна.

// Переменная х здесь известна.

Console.WriteLine("Значение х равно " + х );

Как утверждается в комментариях, переменная х объявляется в начале области видимости метода Main () и потому доступна всему последующему коду метода. Внутри блока инструкции i f объявляется переменная у. А поскольку блок определяет область видимости, то переменная у видима только коду внутри этого блока. Поэтому, находясь вне этого блока, программная строка

I // у = 100; // Ошибка! Переменная у здесь неизвестна. оформлена как комментарий. Если убрать символ комментария, компилятор выдаст сообщение об ошибке, поскольку переменная у невидима вне if-блока. Переменную х можно свободно использовать и внутри if-блока, поскольку внутренний код этого блока (т.е. код во вложенной области видимости) имеет доступ к переменным, объявленным вне его.

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

они становятся только после объявления. Таким образом, если объявить переменную

в начале метода, она будет доступна всему коду этого метода. И наоборот, если объя-

вить переменную в конце метода, она будет попросту бесполезной ввиду отсутствия

кода, который мог бы ее использовать.

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

выходе из нее. Это означает^ что переменная не будет хранить значение за пределами

области видимости. Таким образом, переменная, объявленная внутри некоторого ме-

тода, не будет хранить значение между вызовами этого метода. И точно так же пере-

менная, объявленная внутри некоторого блока, потеряет свое значение по завершении

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

ластью видимости.

Если объявление переменной включает инициализатор, такая переменная будет

повторно инициализироваться при каждом входе в блок, в котором она объявляется,

рассмотрим, например, следующую программу:

// Демонстрация времени существования переменной.

using System;

class VarlnitDemo {

public static void Main() { /

int x;

for(x = 0; x < 3; x++) {

int у = -1; // Переменная у инициализируется при

// каждом входе в программный блок.

Console.WriteLine("Значение у равно: " + у); // Здесь всегда выводится -1.

у = 100;

Console.WriteLine("Теперь значение у равно: " + у);

Вот какие результаты генерирует эта программа:

Значение у равно; -1

Теперь значение у равно: 100

Значение у равно: -1

Теперь значение у равно: 100

Значение у равно: -1

Теперь значение у равно: 100

Как видите, при каждом входе в цикл for переменная у неизменно принимает

значение — 1. Несмотря на последующее присваивание ей значения 100, она это зна-

чение теряет.

В правилах действия областей видимости есть одна деталь: хотя блоки могут быть

вложенными, ни одна переменная, объявленная во внутренней области видимости, не

может иметь имя, совпадающее с именем переменной, объявленной во внешней об-

ласти видимости. Например, следующая программа из-за попытки объявить две от-

дельные переменные с одинаковыми именами скомпилирована не будет.

/*Здесь делается попытка объявить переменную во

внутренней области видимости с таким же именем, как у

переменной, определенной во внешней области видимости.

*** Эта программа не будет скомпилирована. ***

*/using System;

class NestVar {

public static void Main() {

int count;

for(count = 0; count < 10; count = count+1) {

Console.WriteLine("This is count: " + count);

int count; // Неверно!!!

for(count = 0; count < 2; count++)

Console.WriteLine("В этой программе есть ошибка!");

Если вы до этого программировали на C/C++, вам должно быть известно, что на имена, объявляемые во внутренней области видимости, никакие ограничения не накладываются. Таким образом, в языках C/C++ объявление переменной count внутри блока внешнего цикла for было бы совершенно законным. Однако при всей своей законности такое объявление скрывает внешнюю переменную. Поэтому разработчики С#, зная, что подобное сокрытие имен может легко привести к ошибкам программирования, решили запретить его.

Исключительные ситуации. Понятие. Способы обработки исключительных ситуаций. Примеры применения.

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

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

Исключительная ситуация (или исключение) — это ошибка, которая возникает во время выполнения программы. Используя С#-подсистему обработки исключительных ситуаций, с такими ошибками можно справляться. Преимущество подсистемы обработки исключений состоит в автоматизации создания большей части кода, который ранее необходимо было вводить в программы "вручную". Обработка исключений упрощает "работу над ошибками", позволяя в программах определять блок кода, именуемый обработчиком исключение, который будет автоматически выполняться при возникновении определенной ошибки. В этом случае не обязательно проверять результат выполнения каждой конкретной операции или метода вручную. Если ошибка возникнет, ее должным образом обработает обработчик исключений. Еще одним преимуществом обработки исключительных ситуаций в С# является определение стандартных исключений для таких распространенных программных ошибок, как деление на нуль или попадание вне диапазона определения индекса. В С# исключения представляются классами. Все классы исключений должны быть выведены из встроенного класса исключений Exception, который является частью пространства имен System. Таким образом, все исключения — подклассы класса Exception.

С# определяет встроенные исключения, которые выводятся из класса SystemException. Например, при попытке выполнить деление на нуль генерируется исключение класса DivideByZeroException. Но можно создавать собственные классы исключений, выводя их из класса ApplicationException.