43. Объектно-ориентированный подход (ООП) программированию и проектированию. Парадигмы (принципы) объектно-ориентированного программирования: инкапсуляция, наследование, полиморфизм. Классы и объекты. Пример
Объекты — это крупнейшее достижение в современной технологии программирования. Изобретение и практическая реализация объектов являются подвигом человеческого гения. Объекты позволили строить программу не из чудовищных по сложности процедур и функций, а из кирпичиков-объектов, заранее наделенных нужными свойствами. При этом внутренняя сложность объектов скрыта от программиста, он просто пользуется готовым строительным материалом.
С появлением Windows без объектов в программировании просто не обойтись. Delphi — не исключение, она в своей основе является объектно-ориентированной и говорить о программировании без объектов просто бессмысленно.
ООП представляет собой новый этап развития современных концепций построения языков программирования. Здесь получили дальнейшее развитие принципы структурного программирования – структуризация программ и данных, модульность и т. д., а также новые подходы к созданию программ. Использование возможностей ООП незаменимо при визуальном программировании, когда программа «набирается» из отдельных объектов, обладающих необходимыми настраиваемыми характеристиками.
ООП обладает рядом преимуществ при создании больших программ. В частности, к ним можно отнести:
- использование более естественных с точки зрения обычной повседневной практики понятий, простота введения новых понятий;
- упрощение разработки многократно используемых компонент приложений;
- некоторое сокращение размера программ за счет того, что повторяющиеся (наследуемые) свойства и действия можно не описывать многократно; кроме того, использование динамических объектов позволяет более эффективно распределять оперативную память;
- возможность создания библиотеки классов; в частности, библиотека визуальных компонент Delphi и является примером такой библиотеки;
- сравнительно простая возможность внесения изменений в программу без изменения уже написанных частей, а в ряде случаев и без перекомпиляции этих написанных и уже скомпилированных частей, используя свойства наследования и полиморфизма;
- возможность написания подпрограмм с различными наборами формальных параметров, но имеющих одно и то же имя;
- более четкая локализация свойств и поведения объектов конкретного класса в одном месте (используется свойство инкапсуляции), позволяющая проще разбираться со структурой программы, отлаживать ее, находить ошибки;
- возможность разделения доступа к различным объектам программы и т. д.
В конце 60-х годов возникла идея объединить понятия тип данных, процедура, функция, запись и то, что получилось, назвать объектом. Рассмотрение данных в неразрывной связи с методами их обработки позволило вывести формулу объекта:
Объект = Данные + Операции
На основании этой формулы была разработана методология объектно-ориентированного программирования (ООП).
Об объектах можно думать как о полезных существах, которые «живут» в вашей программе и коллективно решают некоторую прикладную задачу. Вы лепите этих существ, распределяете между ними обязанности и устанавливаете правила их взаимодействия.
В общем случае каждый объект «помнит» необходимую информацию, «умеет» выполнять некоторый набор действий и характеризуется набором свойств. То, что объект «помнит», хранится в его полях. То, что объект «умеет делать», реализуется в виде его внутренних процедур и функций, называемых методами. Свойства объектов аналогичны свойствам, которые мы наблюдаем у обычных предметов. Значения свойств можно устанавливать и читать. Программно свойства реализуются через поля и методы.
Например, объект «кнопка» имеет свойство «цвет». Значение цвета кнопка запоминает в одном из своих полей. При изменении значения свойства «цвет» вызывается метод, который перерисовывает кнопку.
Кстати, этот пример позволяет сделать важный вывод: свойства имеют первостепенное значение для программиста, использующего объект. Чтобы понять суть и назначение объекта, вы обязательно должны знать его свойства, иногда — методы, очень редко — поля (объект и сам знает, что с ними делать).
ОБЪЕКТЫ И КОМПОНЕНТЫ
С появлением графических систем, в частности Windows, программирование пользовательского интерфейса резко усложнилось. Программист в какой-то мере стал дизайнером, а визуальная компоновка и увязка элементов пользовательского интерфейса (кнопок, меток, строк редактора) начали отнимать основную часть времени. И тогда программистам пришла в голову идея визуализировать объекты, объединив программную часть объекта с его видимым представлением на экране дисплея в одно целое. То, что получилось в результате, было названо компонентом.
Компоненты в Delphi — это особые объекты, которые являются строительными кирпичиками среды визуальной разработки и приспособлены к визуальной установке свойств. Чтобы превратить объект в компонент, первый разрабатывается по определенным правилам, а затем помещается в Палитру Компонентов. Конструируя приложение, вы берете компоненты из Палитры Компонентов, располагаете на форме и устанавливаете их свойства в окне Инспектора Объектов. Внешне все выглядит просто, но чтобы постичь такой простоты, потребовалось создать механизмы, обеспечивающие функционирование объектов-компонентов уже на этапе проектирования приложения! Все это было придумано и блестяще реализовано в среде Delphi. Таким образом, компонентный подход значительно упростил создание приложений с графическим пользовательским интерфейсом и дал толчок развитию новой индустрии компонентов.
КЛАССЫ ОБЪЕКТОВ
Каждый объект всегда принадлежит некоторому классу. Класс — это обобщенное (абстрактное) описание множества однотипных объектов. Объекты являются конкретными представителями своего класса, их принято называть экземплярами класса. Например, класс СОБАКИ — понятие абстрактное, а экземпляр этого класса МОЙ ПЕС БОБИК — понятие конкретное.
ТРИ ПАРАДИГМЫ (ПРИНЦИПА) ООП
ООП держится на трех принципах: инкапсуляции, наследовании и полиморфизме.
Наблюдаемое в объектах объединение данных и операций в одно целое было обозначено термином инкапсуляция (первый принцип ООП). Применение инкапсуляции сделало объекты похожими на маленькие программные модули и обеспечило сокрытие их внутреннего устройства. Для объектов появилось понятие интерфейса, что значительно повысило их надежность и целостность.
Второй принцип ООП — наследование. Этот простой принцип означает, что если вы хотите создать новый класс, лишь немногим отличающийся от того, что уже существует, то нет необходимости в переписывании заново всех полей, методов и свойств. Вы объявляете, что новый класс является потомком (или дочерним классом) имеющегося класса, называемого предком (или родительским классом), и добавляете к нему новые поля, методы и свойства. Иными словами добавляется то, что нужно для перехода от общего к частному. Процесс порождения новых классов на основе других классов называется наследованием. Новые классы имеют как унаследованные признаки, так и, возможно, новые. Например, класс СОБАКИ унаследовал многие свойства своих предков - ВОЛКОВ
Третий принцип — это полиморфизм. Он означает, что в производных классах вы можете изменять работу уже существующих в базовом классе методов. При этом весь программный код, управляющий объектами родительского класса, пригоден для управления объектами дочернего класса без всякой модификации. Например, вы можете породить новый класс кнопок с рельефной надписью, переопределив метод отрисовки кнопки. Новую кнопку можно «подсунуть» вместо стандартной в какую-нибудь подпрограмму, вызывающую отрисовку кнопки. При этом подпрограмма «думает», что работает со стандартной кнопкой, но на самом деле кнопка принадлежит производному классу и отображается в новом стиле.
Пример к вопросу №43. Объектно-ориентированный подход (ООП) программированию и проектированию. Парадигмы (принципы) объектно-ориентированного программирования: инкапсуляция, наследование, полиморфизм. Классы и объекты.
Вычислить значение выражения 10^y - x^y + x^n, x>0.
Реализованы принципы: инкапсуляция и наследование.
ObjT1 = class //описание класса ObjT1 вычисляет значение x^n
x:real; // поле
n:word; // поле
function Power:real; //метод
constructor Create; // специальный метод – конструктор create
end;
ObjT2 = class(ObjT1) //класс ObjT2 вычисляет значение x^y, является наследником от класса ObjT1
y:real; // x наследует от ObjT1
function Power:real;
constructor create;
end;
ObjT3 = class(ObjT2) ) //класс ObjT2 вычисляет значение 10^y, является наследником от класса ObjT2
function Power:real;
end;
var
Form1: TForm1;
o1:ObjT1; // описывается переменная объектного типа Objt1
o2:ObjT2; // описывается переменная объектного типа Objt2
o3:ObjT3; // описывается переменная объектного типа Objt3
implementation
{$R *.dfm}
constructor Objt1.create;
begin
x:=1; // начальное значение поля x
n:=1; // начальное значение поля n
end;
constructor Objt2.create;
begin
inherited create; // вызывается унаследованный метод create родителя, который присваивает полям x и n объекта o2 начальные значения
y:=1; // начальное значение поля y
end;
function Objt1.Power:real; // метод Power класса Objt1 возведения в степень x^n
begin
Result:=exp(n*ln(x));
end;
function Objt2.Power:real; // метод Power класса Objt2 возведения в степень x^y
begin
Result:=exp(y*ln(x));
end;
function Objt3.Power:real; // метод Power класса Objt3 возведения в степень 10^y
begin
Result:=exp(y*ln(10));
end;
procedure TForm1.Button1Click(Sender: TObject); // Обработчик события OnClick кнопки Button1
begin
o1:=ObjT1.Create; // Вызов метода (конструктора) create класса Objt1. Создается объект o1, выделяется память полям x и n
o2:=ObjT2.Create; // Вызов метода (конструктора) create класса Objt2. Создается объект o2, выделяется память полям x, n и y
o3:=ObjT3.Create; // Вызов метода (конструктора) create класса Objt3. Создается объект o3, выделяется память полям x, n и y
o1.x := StrToFloat(form1.edit1.Text); // полю x объекта o1 присваивается значение из edit1.text
o1.n:=StrToInt(form1.edit3.Text); // полю n объекта o1 присваивается значение из edit3.text
o2.y:=StrToFloat(form1.edit2.Text); // полю y объекта o2 присваивается значение из edit2.text
edit4.text := FloatToStr(o3.Power-o2.Power+o1.Power); // вычисление искомого выражения
o3.Free; // разрушение объекта o3, освобождение памяти
o2.Free; // разрушение объекта o2, освобождение памяти
o1.Free; // разрушение объекта o1, освобождение памяти
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
close; // закрытие приложения
end;