 |
Приведение и проверка типов в C#.
|
|
|
|
Если в одной операции присваивания смешиваются совместимые типы данных, то значение в правой части оператора присваивания автоматически преобразуется в тип, указанный в левой его части. Неявное преобразование типов происходит автоматически при следующих условиях:
· оба типа совместимы;
· диапазон представления чисел целевого типа шире, чем у исходного типа.
В этом случае происходит расширяющее преобразование. Типы char и bool несовместимы друг с другом, а также не допускается неявное преобразование типов decimal и float или double, числовых типов и char или bool.
Приведение типов – это команда компилятору преобразовать результат вычисления выражения в указанный тип. Общая форма приведения типов:
(целевой_тип) выражение
Целевой_тип – это тот тип, в который желательно преобразовать указанное выражение.
Если приведение типов приводит к сужающему преобразованию, то часть информации может быть потеряна.
Конкретный тип объекта можно определить с помощью оператора is. Общая форма:
выражение is тип
где выражение – отдельное выражение, описывающее объект, тип которого проверяется. Если выражение имеет совместимый или такой же тип, как и проверяемый тип, то результат этой операции получается истинным, в противном случае – ложным.
Оператор as служит для преобразования типа во время выполнения без генерации исключения в случае неудачного исхода этой операции. Общая форма оператора as:
выражение as тип
где выражение обозначает отдельное выражение, преобразуемое в указанный тип. Если исход такого преобразования оказывается удачным, то возвращается ссылка на тип, а иначе – пустая ссылка. Оператор as может использоваться только для преобразования ссылок, идентичности, упаковки, распаковки.
|
|
|
Оператор typeof предназначен для получения информации о самом типе. Он извлекает объект класса System.Type для заданного типа. С помощью этого объекта можно определить характеристики конкретного типа данных. Общая форма оператора typeof:
typeof (тип)
где тип обозначает получаемый тип. Информация, описывающая тип, инкапсулируется в возвращаемом объекте класса Type.
Рефлексия – это средство, позволяющее получать сведения о типе данных. Она позволяет выявлять и использовать возможности типов данных, известные только во время выполнения. Для применения рефлексии в код программы вводится следующая строка:
using System.Reflection;
Пример приведения и проверки типов (использование операторов is, as, typeof и рефлексии):
using System;
namespace Example
{
class A { }
class B: A { }
class ExampleDemo
{
static void Main()
{
double x = 10.0, y = 3.0;
byte b1;
int i;
char ch;
i = (int)(x / y); // дробная часть теряется
Console.WriteLine("Целочисленный результат деления x на y равен {0}", i);
i = 255;
b1 = (byte)i;//без потери данных
Console.WriteLine("b после присваивания 255: " + b1);
i = 257;
b1 = (byte)i;//с потерей данных
Console.WriteLine("b после присваивания 257: " + b1);
b1 = 88;
ch = (char)b1;
Console.WriteLine("ch после присваивания 88: " + ch);
x = i;//неявное преобразование типов
Console.WriteLine("x после присваивания 257: " + x);
A a = new A();
B b = new B();
if (a is B) { b = (B)a; Console.WriteLine("Приведение типов b = (B) выполнено успешно"); }
else { b = null; Console.WriteLine("Приведение типов b = (B) не допустимо"); }
b = a as B;
if (b == null) Console.WriteLine("Приведение типов b = (B) не допустимо");
else Console.WriteLine("Приведение типов b = (B) выполнено успешно");
Type t = typeof(A);
Console.WriteLine(t.FullName);
if (t.IsClass) Console.WriteLine("Это класс.");
Console.WriteLine("Методы:");
System.Reflection.MethodInfo[] methodInfo = t.GetMethods();
foreach (System.Reflection.MethodInfo mInfo in methodInfo)
Console.WriteLine(mInfo.ToString());
} } }
Абстрактные классы в C#.
Абстрактный класс – это класс, в котором определена лишь общая форма для всех его производных классов, а наполнение ее деталями предоставляется каждому из этих классов. Класс, содержащий один или более абстрактных методов, также должен быть объявлен как абстрактный. Для этого перед его объявлением class указывается модификатор abstract.
|
|
|
У абстрактного метода отсутствует тело, он реализуется только в производных классах, а объявляется с помощью модификатора abstract. Абстрактный метод автоматически становится виртуальным и не требует указания модификатора virtual. Модификатор abstract может применятся только в методах экземпляра, но не в статических методах. Абстрактными могут быть также индексаторы и свойства.
У абстрактного класса не может быть объектов. Когда производный класс наследует абстрактный, в нем должны быть реализованы все абстрактные методы базового класса. В противном случае производный класс должен быть также определен как abstract.
Пример применения абстрактного класса:
using System;
namespace Example
{
abstract class Base
{
public int i;
public int Sum(int x)
{
return x + i;
}
public abstract void ShowText();
}
class Child1: Base
{
public override void ShowText()
{
Console.WriteLine("Класс Child1");
} }
class Child2: Base
{
public override void ShowText()
{
Console.WriteLine("Класс Child2");
}
}
class ExampleDemo
{ static void Main()
{
Child1 ch1 = new Child1();
Child2 ch2 = new Child2();
ch1.ShowText();
ch2.ShowText();
} } }
Интерфейсы в C#.
Интерфейс определяет ряд методов для реализации в классе. Интерфейс представляет собой чисто логическую конструкцию, описывающую функциональные возможности без конкретной их реализации. Для реализации интерфейса в классе должны быть предоставлены тела методов, описанных в этом интерфейсе. Один и тот же интерфейс может быть реализован в двух разных классах по-разному. Благодаря поддержке интерфейсов в C# может быть реализован принцип полиморфизма: один интерфейс – множество методов.
Интерфейсы объявляются с помощью ключевого слова interface и они подобны абстрактным классам, но у методов интерфейса нет тела. Упрощенная форма объявления интерфейса:
interface имя { возвращаемый_тип имя_метода1 (список_параметров);
возвращаемый_тип имя_метода2 (список_параметров);
…
возвращаемый_тип имя_методаN (список_параметров); }
где имя – это конкретное имя интерфейса. Все методы должны быть реализованы в каждом классе, включающем в себя этот интерфейс. В самом интерфейсе методы неявно считаются открытыми, поэтому модификатор доступа указывать не нужно явно.
|
|
|
Интерфейс также может содержать свойства, индексаторы и события. Интерфейсы не могут содержать члены данных, конструкторы, деструкторы, операторные методы. Ни один из членов интерфейса не может быть объявлен как static.
Для реализации интерфейса в классе достаточно указать имя этого интерфейса после имени класса через двоеточие:
class имя_класса: имя_интерфейса
{//тело класса}
В одном классе можно реализовать несколько интерфейсов, в этом случае все реализуемые интерфейсы указываются списком через запятую. При наследовании имя базового класса должно быть указано перед списком реализуемых в производном классе интерфейсов. Методы, реализующие интерфейс, должны быть объявлены как public. Возвращаемый тип и сигнатура реализуемого метода должны полностью совпадать с возвращаемым типом и сигнатурой, указанными при определении метода в интерфейсе.
Простой пример использования интерфейса:
using System;
namespace Example
{
interface IExample
{
void ShowText();
}
class A: IExample
{
public void ShowText()
{
Console.WriteLine("Класс A");
}
}
class B: IExample
{
public void ShowText()
{
Console.WriteLine("Класс B");
}
}
class ExampleDemo
{
static void Main()
{
A a = new A();
B b = new B();
a.ShowText();
b.ShowText();
}
}
}
Виды массивов в C#.
Массив представляет собой совокупность переменных одного типа с общим для обращения к ним именем. В C# массивы могут быть как одномерными, так и многомерными. Главное преимущество массива – в организации данных таким образом, чтобы ими было проще манипулировать. Массивы в C# реализованы в виде объектов.
Одномерный массив представляет собой список связанных переменных. Общая форма для объявления одномерного массива:
тип [] имя_массива = new тип[размер];
где тип объявляет конкретный тип элемента массива, а размер определяет число элементов массива. Здесь происходит объявление переменной, которая может объявляться к массиву, и создание экземпляра массива с помощью оператора new.
Доступ к отдельному элементу массива осуществляется по индексу: индекс обозначает положение элемента в массиве (начиная с нулевого). Для индексирования массива достаточно указать номер требуемого элементе в квадратных скобках: имя_массива[индекс].
|
|
|
Общая форма инициализации одномерного массива:
тип []имя_массива = {val1, val1, …, valN};
где val1-valN обозначают первоначальные значения, которые присваиваются по очереди, слева направо и по порядку индексирования.
Многомерным называется такой массив, который отличается двумя или более измерениями, причем доступ к каждому элементу такого массива осуществляется с помощью определенной комбинации двух или более индексов.
Общая форма объявления двумерного массива:
тип [,] имя_массива = new тип [размер1, размер2];
Для доступа к элемента двумерного массива следует указать оба индекса, разделив их запятой: имя_массива[i,j].
В C# допускаются массивы трех и более измерений:
тип[, …,] имя_массива = new тип[размер1, размер2, …, размерN];
Для инициализации многомерного массива достаточно заключить в фигурные скобки список инициализаторов каждого его размера:
тип [,] имя_массива = {
{val1, val2, …, valN},
{val1, val2, …, valN},
…,
{val1, val2, …, valN}
};
где каждый внутренний блок – это отдельный ряд.
Ступенчатый массив – это массив массивов, в котором длина каждого массива может быть разной. Общая форма объявления двумерного ступенчатого массива:
тип [][] имя_массива = new тип[размер][];
где размер – число строк в массиве.
Доступ к элементу ступенчатого массива осуществляется по индексу, указываемому в отдельных квадратных скобках:
mass[2][1] = 10;
Ступенчатые массивы могут состоять не только из одномерных массивов, например:
int [][,] = new int[3][,];
Пример использования одномерного, двумерного и ступенчатого массивов:
using System;
namespace Example
{
class ExampleDemo
{
static void Main()
{
int[] sample = new int[5];
Console.WriteLine("Элементы одномерного массива: ");
for (int i = 0; i < 5; i++)
{
sample[i] = i;
Console.Write(sample[i] + " ");
}
Console.WriteLine();
int[,] table = {{1, 2, 3},
{4, 5, 6}};
Console.WriteLine("Элементы двумерного массива: ");
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
Console.Write(table[i, j] + " ");
}
Console.WriteLine();
}
int[][] mass = new int[3][];
mass[0] = new int[2];
mass[1] = new int[3];
mass[2] = new int[4];
Console.WriteLine("Элементы ступенчатого массива: ");
for (int i = 0; i < 2; i++)
{
mass[0][i] = i;
Console.Write(mass[0][i] + " ");
}
Console.WriteLine();
for (int i = 0; i < 3; i++)
{
mass[1][i] = i;
Console.Write(mass[1][i] + " ");
}
Console.WriteLine();
for (int i = 0; i < 4; i++)
{
mass[2][i] = i;
Console.Write(mass[2][i] + " ");
}
Console.WriteLine();
} } }
|
|
|
