
- •Передмова
- •Розділ 1 об'єктний підхід у програмуванні
- •1.1.Причини виникнення ооп
- •1.1.1.Складність об'єкта дослідження
- •1.1.2.Складність процесу розробки програмного забезпечення
- •1.1.3.Складність опису окремих елементів
- •1.2.Парадигма ооп
- •1.3.Історія розвитку ооп
- •Розділ 2 об'єкти й класи: інкапсуляція
- •2.1.Структура об'єкта й класу
- •2.2.Особливості опису класів у мовах ооп
- •2.2.1.Опис класів в SmallTalk
- •2.2.3.Опис класів в Delphi
- •2.2.4.Опис класів в Java
- •2.3.Поля даних та їх ініціалізація
- •2.3.1.Визначення полів даних в SmallTalk
- •2.3.3.Визначення полів даних в Delphi
- •2.3.4.Визначення змінних в Java
- •2.4.Доступ до даних
- •2.4.1.Доступ до даних в SmallTalk
- •2.4.3.Доступ до даних в Delphi
- •2.4.4.Доступ до даних в Java
- •2.5.Спеціальні змінні
- •2.5.1.Спеціальні змінні в SmallTalk
- •2.5.3.Спеціальні змінні в Java
- •2.5.4.Спеціальні змінні в Delphi
- •2.6.Посилання
- •2.6.1.Визначення посилань в SmallTalk, Delphi і Java
- •2.7.Методи
- •2.7.1.Загальна схема визначення методу
- •2.7.2.Визначення методів в SmallTalk
- •2.7.4.Визначення методів в Delphi
- •2.7.5.Визначення методів в Java
- •2.8."Дружні" методи
- •2.8.2.Аналог дружніх функцій в Delphi
- •2.9.Конструктори й деструктори
- •2.9.1.Конструктори й деструктори в SmallTalk
- •2.9.3.Конструктори й деструктори в Delphi
- •2.9.4.Конструктори й деструктори в Java
- •2.10.Властивості
- •2.10.1.Властивості в Delphi
- •2.10.2.Властивості в Java
- •2.12.Абстрактні методи
- •Розділ 3 успадкування
- •3.1.Форми успадкування
- •3.2.Успадкування в SmallTalk
- •3.3.1.Віртуальне успадкування
- •3.3.2.Правило сумісності типів
- •3.3.3.Використання конструкторів і деструкторів при успадкуванні
- •3.4.Успадкування в Delphi
- •3.4.1.Ієрархія класів в Delphi
- •3.4.2.Створення нових компонентів
- •3.5.Успадкування в Java
- •3.5.1.Використання ключового слова super
- •3.5.2.Клас Object
- •Розділ 4 поліморфізм
- •4.1.Віртуальні методи
- •4.2.1.Механізм пізнього зв'язування
- •4.2.2.Таблиця віртуальних методів
- •4.3.Поліморфізм в Delphi
- •4.3.1.Заміщення віртуальних і динамічних методів
- •4.3.2.Приведення типів
- •4.4.Поліморфізм в Java
- •4.5.Поліморфізм в SmallTalk
- •5.1.Потокові класи
- •5.1.1.Ієрархія потокових класів
- •5.1.2.Форматоване введення/ виведення
- •5.1.3.Маніпулятори
- •5.1.4.Введення/виведення у файл
- •5.2.Контейнерні класи
- •5.2.1.Ітератори
- •5.2.2.Визначення контейнерних класів
- •5.2.3.Стандартні контейнерні класи
- •5.3.1.Параметиізовані класи (шаблони)
- •5.3.2.Ітератори stl
- •5.3.3.Узагальнені алгоритми
- •Література
- •Додатки лабораторна робота №1 об'єкти й повідомлення в smalltalk
- •Лабораторна робота №2 класи й методи в smalltalk
- •Листинг 3.1
- •Листинг 3.2
- •Листинг 3.3
- •Лабораторна робота 5 компоненти в delphi
- •Лабораторна робота 6 меню й вікна в delphi
- •Лабораторна робота 7 розробка меню в java
- •Лабораторна робота 8 робота з подіями в java
3.4.2.Створення нових компонентів
Компоненти в Delphi реалізують ідею багаторазового використання на рівні коду. Компонент - це особливий різновид об'єктів(має двійкове подання й має специфічні властивості). Компоненти будуються на основі заздалегідь визначених класів.
При розробці нових компонентів варто дотримуватися такої схеми. Починаючи з нижніх рівнів ієрархії шукається вже існуючий клас, що найбільшою мірою забезпечує необхідну функціональність. Якщо методи даного класу занадто спеціалізовані для розглянутого випадку, то необхідно піднятися на одну сходинку нагору по ієрархії, поки не буде обраний клас, здатний забезпечити необхідну конкретизацію поводження. Обраний клас приймається в якості базового, від якого й буде створюватися новий похідний клас компонента.
Далі необхідно виконати:
побудова каркаса компонента;
настроювання компонента;
вбудовування компонента в палітру компонентів;
тестування компонента (створення застосування, що використовує розроблений компонент).
Нижче наводиться код каркаса нового компонента TCloseButton, створеного за допомогою середовища розробки Component Expert, що входить до складу Delphi.
unit NewComp;
interface
uses ...…
type
TCloseButton = class (Tbutton)
private
…………………………
protected
…………………………
public
…………………………
published
…………………………
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponent('Simple',[TCloseButton]); {}
end;
Процедура RegisterComponent містить як перший параметр ім'я сторінки палітри компонентів Simple, куди повинен бути поміщений новий компонент TСloseButton. Використання відкритого масиву означає, що в одному модулі можуть бути оголошені не один, а кілька компонентів.
Хороший стиль програмування вимагає, щоб новим компонентам приділялися нові директорії, куди буде записаний код і тестові програми. Не потрібно турбуватися, що це може привести до перевитрати ресурсів, тому що модуль компонента поміщається у файл, що виконується, тільки з тими елементами, на які є посилання в коді програми.
Зміна властивостей унаслідуваного компонента здійснюється через перевизначення конструкторів. Допустимо що необхідно щоб при створенні кнопки TCloseButton її ширина рівнялася 200 а довжина 300. Для цього в розділі public оголосимо конструктор у такий спосіб:
type
TCloseButton = class (Tbutton)
…………………
publick
constructor Create(AOwner : TComponent);override;
end;
implementation
constructor TCloseButton......reate(AOwner : Tcomponent);
begin
inherited Create(AOwner);
Width:=300;
Height:=200;
end;
3.5.Успадкування в Java
В термінології Java, як і в Smalltalk, клас, що успадкований, називається суперкласом (superclass), а похідний від нього клас – підкласом (subclass). Тому підклас - це версія суперкласу. Він успадковує всі змінні й методи, що існують в суперкласі, і додає свої елементи.
Особливості успадкування:
Для оголошення успадкування використовується ключове слово extends:
class A {
int i; // public за замовчуванням
private int j; // private для А
}
// клас В(підклас) успадковує клас А (суперклас)
сlass B extends A {
int total;
void sum(){
total=i+j; // помилка, j тут не доступна
}
}
На відміну від С++, в Java не підтримується множинне успадкування, тобто після слова extends може стояти ім'я тільки одного суперкласу. Але можна створити багаторівневу ієрархію. У цьому випадку підклас буде мати елементи всіх своїх суперкласів.
При створенні екземпляра підкласу викликаються всі конструктори його суперкласів у порядку підпорядкованості класів, починаючи із самого верхнього суперкласу:
// суперклас А
class A {
A() {
System.out.println(“виклик конструктора класу А”)
}
}
// B - підклас А
class B extends A {
B() {
System.out.println(“виклик конструктора класу В”)
}
}
// С - підклас В
class З extends В {
З() {
System.out.println(“виклик конструктора класу З”)
}
}
class Х {
public static void main(String args[]) {
C c=new C();
}
}
Порядок виклику конструкторів для даної програми буде такий:
виклик конструктора класу А
виклик конструктора класу В
виклик конструктора класу З
Тип змінної, а не тип об'єкта, на який вона посилається, визначає до яких елементів можна звертатися через неї. Тобто, коли змінна на об'єкт суперкласу вказує на об'єкт підкласу, то вона буде мати доступ тільки до елементів суперкласу, тому що , у принципі, вона нічого не знає про об'єкт підкласу:
class Box {
// розміри ящика
double width;
double heigth;
double depth;
Box(double len) {
width=height=depth=len;
}
}
сlass ColorBox extends Box {
// кольори ящика
int color;
ColorBox (double w, double h, double d, int c){
width=w;
height=h;
depth=d;
color=c;
}
}
class RefDemo {
public static void main(String args[]) {
Box lenbox = new Box(1); // lenbox посилання на Box
ColorBox paintbox = new ColorBox(1.0, 2.0, 3.0, 4);
lenbox= paintbox;
lenbox.color = 1; // помилка, lenbox не знає елемент color
}
}