using sc=System.Console;
abstract class Stone //это будет базовый класс
{
protected float weight;//protected можно смело
protected int color;//использовать в абстрактных классах
//т.к. они в любом случае наследуемы.
public Stone(){weight=0;color=0;}//конструктор
public Stone(float w,int c) //конструктор
{
weigth=w;
color=c;
}
public abstract void Print(); //абстрактный метод вывода
}
class Diamond:Stone //это производный класс
{
private double price;
public Diamond(){price=0;}
public Diamond(float ww,int cc,double pp):base(ww,cc)
{price=pp;}
public override void Print() //метод вывода.
//override говорит компилятору о том,
//что код наследованного метода
//будет переопределен.
{
sc.WriteLine("The weight is "+weight);
sc.WriteLine("The color number is "+color);
//ключевое слово base позволяет получить
//доступ и к закрытым членам базового класса
//имеет смысл ссылки на базовый класс
sc.WriteLine("The price is "+price);
sc.ReadLine();
}
}
class Prog
{
public static void Main()
{
Diamond ob1=new Diamond(10,4,99.99);
ob1.Print();
}
}
В .Net Framework имеется специальный класс - Object. А еще точнее
- System.Object. Этот класс является базовым для всех стандартных классов. Любой тип в C# - это, по сути, класс. Поэтому мы до сих пор не рассмотрели типы, а вот мучаемся тут с этими концепциями и реализациями. Зато потом будет понятнее архитектура. Я, например, в свое время пожалел, что сначала знакомился с типами. Да, но что-то я не о том. Object
это фундаментальный класс. Он определяет минимальный набор методов для объекта. Практически, все классы .Net Framework наследуют этот класс, и этот момент очень важен. Итак, класс System.Object определяет шесть открытых методов:
public virtual bool Equals(object object)
Этот метод определяет равенство вызывающего и передаваемого экземпляров.
public static bool Equals(object ob1,object ob2)
Этот метод определяет равенство объектов ob1 и ob2, передаваемых в качестве параметров. Метод Equals() перегружен, т.к. для него определено два разных контекста.
public virtual int GetHashCode()
Этот метод возвращает хэш-код, соответствующий вызывающему объекту. Применяется в алгоритмах, использующих хэши для доступа к экземплярам.
public Type GetType()
Этот метод возвращает тип объекта.
public static bool ReferenceEquals(object ob1,object ob2)
Этот метод определяет равенство ссылок ob1 и ob2, т.е. ссылаются ли они на один экземпляр.
public virtual string ToString()
Этот метод возвращает строку с описанием объекта.
И два закрытых:
protected void Finalyze()
Вызывается перед сборкой мусора. В принципе, можно не использовать. Не следует помещать в выполняемый код. Обычно вызывается деструктором.
protected object MemberwiseClone()
Один старый опытный кодер сказал мне, что этот метод используется для копирования объектов, при котором не копируется объект, а копируются его члены. Если честно, то я ему не верю, т.к. метод возвращает значение типа object. Этот метод скорее создает копию объекта, содержащую ссылки на другие объекты. С этой штукой я пока не
экспериментировал и за базар не отвечаю. Как-нибудь, я разберусь с этим, напишу.
Теперь можно переходить к интерфейсам с чистой душой. Интерфейсами в C# принято называть структуры, содержащие прототипы методов. Интерфейс, как и абстрактный класс не может являться базой для создания объектов. Синтаксис интерфейса похож на синтаксис абстрактного класса, но интерфейс не может содержать переменные-члены и тела методов, строго прототипы. А во всем остальном, можно считать их одной и той же сущностью. Все методы интерфейса являются виртуальными. Для создания интерфейсов в C# используется ключевое слово interface. Ниже приведен общий вид интерфейса и его наследования:
public interface имя_интерфейса //определение интерфейса
{
тип_1 метод_1(список_параметров_1); //прототип_1
...........................................................
тип_n метод_n(список_параметров_n); //прототип_n
}
class имя_класса:имя_интерфейса
//наследование интерфейса классом
{
//тело класса
}
Примечание: при переопределении методов интерфейса ключевое слово override использовать не надо.
Если мы создаем объект типа класса, то нам приходится работать с ссылкой на него, что накладывает некоторое дополнительное время обработки. В С++ структура и класс v почти одно и то же, за исключением разницы в доступе по умолчанию и некоторых синтаксических аспектов. В C# структура синтаксически схожа с классом, может инициализироваться также, как и класс, но она имеет тип значения, а не ссылки, как класс. Это обеспечивает повышение эффективности. Итак, когда следует использовать структуры? Их следует использовать в том случае, если объект не обладает особой сложностью и большими объемами. Иначе говоря, структуры следует использовать для создания более простых объектов. Но синтаксически они мало чем отличаются. Для создания структуры используется старое доброе ключевое слово struct. Но теперь структура определяет тип данных, а не тип структуры, как в С++, и необходимость в использовании typedef отпадает. Вообще C# освобождает кодера от всяких таких мелочей, и не только мелочей, работа стала легче... Но это не значит, что это язык для ламеров... Структура в C# не может определять деструкторы, также не может определять конструторы по умолчанию (без параметров).
Итак, ключевое слово class определяет тип ссылки, а struct v тип значения. Пример структуры я приводить не буду, т.к. сейчас это уже предельно просто.
Теперь, наверное, последняя структура данных
- перечисления. В C# под перечислением понимают некоторый упорядоченный набор целочисленных констант. Для создания используется ключевое слово enum. Рассмотрим следующий пример:
enum CodeMen{gates,torwald,straustrup,ritchie,kernigan};
доступ к элементам производится как и в случае с классом, но им автоматически присваиваются такие значения:
CodeMen.gates =0
CodeMen.torwald =1
CodeMen.straustrup =2
CodeMen.ritchie =3
CodeMen.kernigan =4
Т.е. они индексируются. Если мы хотим обрабатывать перечисление в цикле, то управляющая переменная должна иметь тип данного перечисления и менять свое значение от значения первого элемента к значению последнего элемента, или наоборот. Обычно перечисления объявляются внутри тела класса. По дефолту, перечисления основываются на типе int, но тип можно указать явно так:
enum CodeMen:ulong{gates,torwald,straustrup,ritchie,kernigan};
Теперь все члены перечисления будут иметь значение типа ulong. Это может быть любой другой целочисленный тип, кроме char.
В принципе, теперь вы знаете основы объектно-ориентированной модели C#.
В завершении я хочу привести фундаментальные типы C# с именами классов, которые отвечают за их обработку.
Приведение типов осуществляется, как в С++. Покажем это на следующем примере:
....
int k=10;
object ob1;
ob1=(object)k;
//приведение значения типа int типу object.
....
И, наконец, немного о полиморфизме. Полиморфизм обеспечивается использованием интерфейсов. Хотя, в принципе, полиморфизм можно создать и без интерфейса, но это считается неправильно, типа, если есть - юзай! Я считаю, что на этом не стоит сейчас останавливаться, вы это еще не раз увидите в моих, и не только моих примерах.
Теперь почти все самое нудное позади, далее пойдут вещи новые и более интересные. В следующей статье будет описана перегрузка методов и операторов (только это,
пожалуй, нам не ново), некоторые классы .Net Framework, а также некоторые принципы автоматизации работы программ при помощи того же волшебного .Net. Скоро вы узнаете, почему он волшебный!
