Учебно-методический комплекс общее количество часов 58 ч. Лекции 28 ч

7.8. Неизменяемость стандартных строк. Работа с классом StringBuilder

Класс System.String относится к неизменяемым (immutable) классам. Это означает, что при присвоении переменной типа System.String нового значения, создается новый объект, ссылка на который присваивается этой переменой переменной.

Такое поведение строк создает дополнительную нагрузку на динамическую кучу и существенно снижает производительность. Поэту если алгоритм программы предусматривает активное изменение содержимого строки, предпочтение следует отдать классу System.Text.StringBuilder.Этот класс предоставляет чуть широкие возможности, чем класс System.String.
8. ПЕРЕГРУЗКА. СВОЙСТВА И ИНДЕКСАТОРЫ


8.1. Перегрузка методов

Перегрузка (overload) – это одна из форм реализации полиморфизма, то есть изменчивости классов. Перегрузка методов нужна, чтобы произвести одинаковые или похожие действия с разнотипными данными.

Перегрузка методов реализуется путем определения нескольких методов с одинаковыми именами, но разным количеством или типом параметров. Методы, различающиеся только количеством или типом формальных параметров, называются перегруженными.
Как уже отмечалось, компилятор языка C# различает методы класса не по имени, а по сигнатуре. Сигнатура метода — это имя метода и список аргументов с указанием порядка их следования и типов.
Когда компилятор встречает в тексте программы вызов метода, он ищет наиболее подходящую к данному списку фактических параметров перегрузку метода класса.

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

Convert.ToChar(2);

Convert.ToChar("s");
Лист 8.1

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

class MethOverloadDemo

{
// первая группа перегруженных методов
public void Meth()
{
Console.WriteLine("Вызван метод Meth() без параметров ");
}

public void Meth(int a)

{
Console.WriteLine("Вызван метод Meth(int) с одним
параметром типа int");
Console.WriteLine("a: {0}", a);
}

public void Meth(int a, int b)

{
Console.WriteLine("Вызван метод Meth(int, int) с двумя
параметрами типа int");
Console.WriteLine("a: {0}", a);
Console.WriteLine("b: {0}", b);
}

public void Meth(double a, double b)

{
Console.WriteLine("Вызван метод Meth(double, double) с
двумя параметрами типа double");
Console.WriteLine("a: {0}", a);
Console.WriteLine("b: {0}", b);
}

// вторая группа перегруженны методов

public double Summ(double a, double b)
{
Console.WriteLine("Вызван метод Summ(double, double) с
двумя параметрами типа double");
Console.WriteLine("a: {0}", a);
Console.WriteLine("b: {0}", b);

return (a + b);

}

public Decimal Summ(Decimal a, Decimal b)

{
Console.WriteLine("Вызван метод Summ(Decimal, Decimal) с
двумя параметрами типа Decimal");
Console.WriteLine("a: {0}", a);
Console.WriteLine("b: {0}", b);

return (a + b);

}

// пустой конструктор

public MethOverloadDemo()
{
}
}
Лист. 8.2
В приведенном выше листинге определен класс MethOverloadDemo. В этом классе объявлен пустой конструктор и две группы перегруженных методов. Первая группа перегруженных методов объединена общим именем Meth и состоин из четырех методов: первый метод без формальных параметров, второй – с одним параметром типа int, третий – с двумя параметрами типа int, четвертый – с двумя с двумя параметрами типа double.
Вторая группа состоит из двух методов, ожидающих два формальных параметра: первый метод ожидает параметры типа int, второй – типа double.

Теперь создадим класс для тестирования работы класса MethOverloadDemo.

class Program

{
static void Main(string[] args)
{
MethOverloadDemo Demo = new MethOverloadDemo();
// какой из перегруженных методов вызвать,
// компилятор может решить по внешнему виду
// или по количеству
// передаваемых методу констант
Demo.Meth();
Demo.Meth(1);
Demo.Meth(1, 2);
Demo.Meth(1.0, 2.0);

// когда количество и внешний вид

// передаваемых параметров совпадает,
// необходимо явно определить типы параметров
double doubleA = 10, doubleB = 20;
Decimal DecimalA = 100, DecimalB = 200;

Console.WriteLine("doubleA + doubleB = {0}", Demo.Summ(doubleA,

doubleB));
Console.WriteLine("DecimalA + DecimalB = {0}",
Demo.Summ(DecimalA, DecimalB));}
}
Лист. 8.3

Сначала создаем объект класса MethOverloadDemo Demo.

Далее поочередно вызываем все методы с именем Meth, их компилятор может различить либо по количеству параметров, либо по внешнему виду предаваемых в метод констант. Для компиляторов большинства языков программирования константы вид 1 или 2 являются целыми числами, константы же вида 1.0 или 2.0 являются вещественными числами.
Затем вызываем методы группы Summ. Обе перегрузки этого метода имеют по два параметра разных вещественных типов double и Decimal, поэтому чтобы компилятор различил типы фактических параметров, необходимо объявить переменные нужных типов. Затем объявленные переменные передаются в метод Summ, а какую конкретную перегрузку выбрать компилятор решает по их типу.
Вывод программы:
Вызван метод Meth() без параметров
Вызван метод Meth(int) с одним параметром типа int
a: 1
Вызван метод Meth(int, int) с двумя параметрами типа int
a: 1
b: 2
Вызван метод Meth(double, double) с двумя параметрами типа double
a: 1
b: 2
Вызван метод Summ(double, double) с двумя параметрами типа double
a: 10
b: 20
doubleA + doubleB = 30
Вызван метод Summ(Decimal, Decimal) с двумя параметрами типа Decimal
a: 100
b: 200
DecimalA + DecimalB = 300
Вывод. 8.1

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

class ConstructorOverloadDemo

{
// открытые поля класса
public int Number1, Number2;

// группа открытых перегруженных конструкторов

public ConstructorOverloadDemo()
{
Number1 = 0;
Number2 = 0;
}

public ConstructorOverloadDemo(int Number1, int Number2)

{
this.Number1 = Number1;
this.Number2 = Number2;
}

public ConstructorOverloadDemo(double Number1, double Number2)

{
this.Number1 = (int)Number1;
this.Number2 = (int)Number2;
}
}
Лист. 8.4

В листинге описан класс ConstructorOverloadDemo, содержащий три перегруженных конструктора: первый – конструктор без параметров, второй конструктор ожидает два параметра типа int, третий – два параметра типа double.

class Program

{
static void Main(string[] args)
{
ConstructorOverloadDemo Demo1, Demo2, Demo3;

Console.WriteLine("Создаем объект Demo1, конструктором без

параметров.");
Demo1 = new ConstructorOverloadDemo();
Console.WriteLine("Demo1.Number1: {0}", Demo1.Number1);
Console.WriteLine("Demo1.Number2: {0}", Demo1.Number2);
Console.WriteLine("Создаем объект Demo2, конструктором с
двумя параметра типа int.");
Demo2 = new ConstructorOverloadDemo(100, 200);
Console.WriteLine("Demo2.Number1: {0}", Demo2.Number1);
Console.WriteLine("Demo2.Number2: {0}", Demo2.Number2);
Console.WriteLine("Создаем объект Demo3, конструктором с
двумя параметра типа double.");
Demo3 = new ConstructorOverloadDemo(10.00, 20.00);
Console.WriteLine("Demo3.Number1: {0}", Demo3.Number1);
Console.WriteLine("Demo3.Number2: {0}", Demo3.Number2);

}
}
Лист 8.5

В этом листинги приводится класс Program, метод Main которого используется для тестирования класса ConstructorOverloadDemo. В этом методе сначала объявляются три объекта класса ConstructorOverloadDemo Demo1, Demo2 и Demo3, затем эти объекты создаются каждый своим перегруженным конструктором: первый – конструктором без параметров, второй – конструктором с двумя параметрами типа int, третий – конструктором с двумя параметрами типа double, каждый раз после создания объекта выводятся его поля.

Вывод программы:

Создаем объект Demo1, конструктором без параметров.

Demo1.Number1: 0
Demo1.Number2: 0
Создаем объект Demo2, конструктором с двумя параметра типа int.
Demo2.Number1: 100
Demo2.Number2: 200
Создаем объект Demo3, конструктором с двумя параметра типа double.
Demo3.Number1: 10
Demo3.Number2: 20
Вывод. 8.2