Статистика сайта Unity3d

	Пользователей	10
	Новых	0
	Он-лайн	0
	Гостей	1

Ресурсы

	Статей	3
	Уроков	2
	Видеоуроков	5
	Загрузок	13

Помощь сайту

	R394393202050
	U248246294107
	Z323796168232

Объектно-ориентированное программирование

Объектно-ориентированное программирование (ООП) — парадигма программирования, в которой основными концепциями, которыми оперирует программист, разработчик являются понятия объектов и классов.

Ниже приведены основные постулаты ООП:

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

Не имея вышеуказанных составляющих язык программирования не может считаться объектно-ориентированным по определению.
Теперь давайте более детально разберемся в каждом из трех постулатов.

Инкапсуляция

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

class Transmission
{

//количество передач
int countPositions;
//текущая передача
int currentPosition;
//конструктор по-умолчанию, без параметров
public Transmission()
{
}
//конструктор с параметрами
public Transmission(int countPositions)
{

this.countPositions=countPositions;
this.currentPosition=0;

}
//функция переключения передачи
//ключевое слово virtual - позволяет переопределить данный метод классам потомкам
public virtual void ChangePosition(int position)
{

this.currentPosition=position;

}

}

//теперь проверим работу ранее созданного класса
//для этого создадим экземпляр класса Transmission
Transmission mechanicTransmission=new Transmission(5); //пятиступенчатая коробка передач
//теперь переключим передачу указав методу ChangePosition(int position) номер передачи - 1
//таким образом мы свободно можем пользоваться методами класса не имея представления о его внутреннем содержании
mechanicTransmission.ChangePosition(1);

С этим немного разобрались, перейдем к следующему постулату.

Наследование

Используем для демонстрации созданный нами ранее класс Transmission в качестве родительского и разработаем новый класс AutomaticTransmission добавив в него новые свойства и методы.
class AutomaticTransmission:Transmission
{

//текущая скорость движения
int currentSpeed;
//конструктоор по-умолчанию, без параметров
public AutomaticTransmission()
{
}
//переопределяем конструктор базового класса
public AutomaticTransmission(int countPositions, int currentSpeed):base(countPositions)
{

this.currentSpeed=currentSpeed;

}
//переопределяем функцию базового класса
/*теперь в функцию необходимо передать цифру со знаком "+" или "-", которая укажет на сколько необходимо изменить скорость автомобиля, а функция сама определит какую передачу необходимо включить*/
public override void ChangePosition(int speedValue)
{

this.currentSpeed+=speedValue;
if(this.currentSpeed<0)
{

this.currentSpeed=0;
this.currentPosition=0;

}
else if(this.currentSpeed>0&&this.currentSpeed<=20)

this.currentPosition=1;

else if(this.currentSpeed>20&&this.currentSpeed<=40)

this.currentPosition=2;

...........................
/*и так далее, возможно не совсем правильно с точки зрения хорошего тона в программировании использовать в данном случае конструкцию "if ...else", но я думаю смысл в целом понятен*/
}

}

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

Полиморфизм

Позволяет значительно обобщить работу функций не переписывая метод каждый раз под новый класс. Достаточно разработать базовый класс, реализовать проектное решение для работы с ним, и это решение без проблем будет применимо и к классам-потомкам.
Продемонстрируем несколько простых примеров используя разработанные ранее классы Transmission и его потомок AutomaticTransmission.
//поскольку AutomaticTransmission является потомком Transmission то мы запросто можем сотворить следующее преобразование

Transmission transmission=new Transmission();
AutomaticTransmission automaticTransmission = new AutomaticTransmission();
transmission=automaticTransmission;

/*это в свою очередь также означает что если у нас есть функция которая принимает объект класса Transmission то мы можем в нее передать также и объект класса AutomaticTransmission и такой вариант сработает без проблем*/
public int GetCurrentPosition(Transmission transmission)
{

return transmission.countPositions;

}
//вот два варианта успешного вызова функции
int transmissionPositions=GetCurrentPosition(Transmission transmission);
int automaticTransmissionPositions=GetCurrentPosition(AutomaticTransmission automaticTransmission);

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

[fatboy] || добавлена: 21.03.2013 в 15:17:50 || просмотров: 64 || комментариев: 0