Презентация Обєктно-орієнтоване програмування онлайн
На нашем сайте вы можете скачать и просмотреть онлайн доклад-презентацию на тему Обєктно-орієнтоване програмування абсолютно бесплатно. Урок-презентация на эту тему содержит всего 203 слайда. Все материалы созданы в программе PowerPoint и имеют формат ppt или же pptx. Материалы и темы для презентаций взяты из открытых источников и загружены их авторами, за качество и достоверность информации в них администрация сайта не отвечает, все права принадлежат их создателям. Если вы нашли то, что искали, отблагодарите авторов - поделитесь ссылкой в социальных сетях, а наш сайт добавьте в закладки.
Презентации » Устройства и комплектующие » Обєктно-орієнтоване програмування
Оцените!
Оцените презентацию от 1 до 5 баллов!
- Тип файла:ppt / pptx (powerpoint)
- Всего слайдов:203 слайда
- Для класса:1,2,3,4,5,6,7,8,9,10,11
- Размер файла:3.65 MB
- Просмотров:57
- Скачиваний:0
- Автор:неизвестен
Слайды и текст к этой презентации:
№2 слайд
![. Предмет та задач курсу](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img1.jpg)
Содержание слайда: 1. Предмет та задачі курсу
Предмет: вивчення концепцій об‘єктно-орієнтованого проектування (ООD) та програмування (OOP).
Область застосування ООD та OOP — складні програмні продукти.
Прості програми — це програми, які розробляються та використовуються однією людиною . Властивості:
мають обмежений час існування;
мають обмежену область застосування;
їх простіше переписати, ніж розширити.
Промислові програмні продукти — складні, використовуються для вирішення різних задач (системне керування зворотним зв’язком, обробка БД з паралельним доступом, поновленнями та запитами, контроль за реальними процесами — диспетчери). Їм властиві:
значний час існування;
багато користувачів;
високий рівень складності — для розробки програмного забезпеченя потрібно декілька осіб, так як його складність перевищує можливості інтелекту однієї людини.
№3 слайд
![. Чинники складност](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img2.jpg)
Содержание слайда: 2. Чинники складності програмного забезпечення (ПЗ)
складність реальної предметної області:
несумісність між замовниками та розробниками, оскільки вони спеціалісти у різних галузях. Різні погляди на сутність проблеми – зміни вимог у процесі розробки, часто після отримання перших результатів;
складність керування процесом розробки:
необхідно створити ілюзію простоти в процесі роботи команди;
необхідність достатньо гнучкої системи:
створення спеціалізованих бібліотек;
складність опису поведінки великих дискретних систем:
в великій програмі існують тисячі змінних та потоків керування.
№4 слайд
![. Шлях розв язання складних](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img3.jpg)
Содержание слайда: 3. Шлях розв’язання складних задач - об’єктний підхід (1/2)
Розв’язання складних задач грунтується на наступних принципах ООП:
Декомпозиція – поділ задачі на складові
Абстракція – виділення головного
Ієрархія
1. Декомпозиція — дозволяє тримати в пам’яті інформацію лише про деякі частини.
Алгоритмічна декомпозиція — це структурне програмування “згори-донизу”.
Алгоритмічна декомпозиція Концентрує увагу на послідовності дій — підпрограми. Структурний підхід не працює для великих програм (умовно, коли програма містить більше, ніж 100000 рядків).
Об’єктно-орієнтована декомпозиція — це програмування за належністю елементів до різних абстракцій; поділ не на кроки, а на об’єкти. Кожний об’єкт має власну поведінку.
Об’єктно-орієнтована декомпозиція Концентрує увагу на об’єктах чи суб’єктах дії. Зменшує розмір програми за рахунок повторного використання різних механізмів. Більш гнучкі та легко еволюціонують, розвиваються з менших систем.
Важливі обидва аспекти: як алгоритмічна, так і об’єктно-орієнтована декомпозиція.
№5 слайд
![. Шлях розв язання складних](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img4.jpg)
Содержание слайда: 3. Шлях розв’язання складних задач - об’єктний підхід (2/2)
Приклади:
а. Нейронні мережі:
Алгоритмічна декомпозиція: навчання, робота, забування.
Об’єктно-орієнтована декомпозиція: шари нервових клітин містять ансамблі нейронів.
Функція об’єкту: навчання.
б. Транснаціональна корпорація:
Алгоритмічна декомпозиція: виробництво, продаж, участь у політичній діяльності (вибори).
Об’єктно-орієнтована декомпозиція: транснаціональні корпорації складаються з національних компаній, які містять відділення та філіали (відділи збуту).
Функція об’єкту: політичне життя.
2. Абстракція — людина може одночасно сприйняти 72 одиниці інформації. Тому необхідно визначати головну частину інформації (абстракція). В такому разі можна використовувати інформацію більшого семантичного об’єму.
3. Ієрархія — дозволяє вивчати механізми взаємодії компонентів. Поведінка кожного окремого об’єкту відповідає поведінці свого рівня (наприклад клітини). Легко визначити загальні та особливі риси.
В програмній системі дуже важко визначити ієрархію. Але після цього структура системи прояснюється.
№6 слайд
![Л тература . Гради Буч](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img5.jpg)
Содержание слайда: Література
1. Гради Буч “Объектно-ориентированное проектирование с примерами приложений на С++”
2. Айра Пол «Объектно- ориентированное программирование на С++»
3. Герберт Шилдт «Самоучитель по С++»
4. Стивен Прата «Язык программирования С++»
5. А также, как и и ранее Бьерн Страуструп
№9 слайд
![Розвиток ООП Розвиток ООП](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img8.jpg)
Содержание слайда: Розвиток ООП
Розвиток ООП є еволюційним розвитком проектування.
Передумови розвитку об’єктного підходу:
прогрес в області архітектури ЕОМ (поява об’єктно-орієнтованої архітектури ЕОМ);
розвиток мов програмування;
розвиток методології (стилю) програмування: модульність та приховання даних;
розвиток теорії баз даних (ENTITY-RELATIONSHIP-моделі, сутність-відношення);
штучний інтелект (теорія фреймів, ансамблів);
філософія та теорія пізнання — світ можна розглядати в термінах об’єктів та подій. Розум людини — сукупність різноманітно мислячих агентів.
№10 слайд
![Реал зац я ООП Процес реал](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img9.jpg)
Содержание слайда: Реалізація ООП
Процес реалізації ОО підходу (макропроцес):
Концептуалізація (встановлення основних вимог);
Аналіз (побудова моделі відповідної поведінки);
Проектування (створення архітектури);
Супроводження (керування еволюцією після виходу).
Мікропроцес:
Ідентифікація класів та об’єктів на даному рівні абстракції;
Ідентифікація семантики класів та об’єктів;
Ідентифікація відношень між класами;
Специфікація інтерфейсів та початок реалізації.
№11 слайд
![Об ктно-ор нтоване](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img10.jpg)
Содержание слайда: Об’єктно-орієнтоване програмування
ОО Програмування — це методологія програмування, що базується на представленні програми у вигляді сукупності 1) об’єктів, кожний з яких є екземпляром 2) класів, а класи створюють 3) ієрархії.
Програма є об’єктно-орієнтованою при наявності всіх 3-х вимог.
№12 слайд
![Характеристики ОО мови Мова](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img11.jpg)
Содержание слайда: Характеристики ОО мови
Мова є об’єктно-орієнтованою, якщо:
Підтримує об’єкти (інтерфейс у вигляді іменованих операцій та власні дані з обмеженим доступом);
Об’єкти відносяться до відповідних типів (класів);
Типи (класи) можуть успадковувати атрибути супертипів (відношення спадкування “is a” “це є “).
№13 слайд
![ООП Об ктно-ор нтоване](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img12.jpg)
Содержание слайда: ООП
Об’єктно-орієнтоване проектування (ООD — Object Oriented Design) — це методологія проектування, що поєднує в собі процес об’єктної 1) декомпозиції та способи представлення 2) логічної, фізичної, статичної та динамічної моделей системи.
1. Декомпозиція — об’єктна;
2. Багато засобів представлення моделей.
№16 слайд
![Приклад include lt iostream.h](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img15.jpg)
Содержание слайда: Приклад
#include <iostream.h>
//Make public and private explicit in class
class complex_c1 {
public://need to know style- our preference
void assign(double r, double i);
void print()
{ cout << real << " + " << imag << "i ";}
private:
double real, imag;
};
inline void complex_c1::assign(double r, double i = 0.0)
{
real = r;
imag = i;
}
№17 слайд
![Абстракц я Абстракц я це в](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img16.jpg)
Содержание слайда: Абстракція
Абстракція — це відмова від зайвих деталей класу об`єктів та виділення важливих деталей їх структури та поведінки.
Інтерфейс об’єкту містить важливі аспекти поведінки. Абстракція дозволяє реалізувати відношення між об’єктами: клієнт-сервер — один об’єкт (клієнт) використовує ресурси іншого об’єкта (сервера), на основі якої формується контрактна модель програми, тобто внутрішня структура об’єкта визначається контрактом.
Зовнішня взаємодія — контракт:
1. Кожна операція задається формальними параметрами та типом значень, що вертається;
2. Повний набір операцій — протокол (містить всі засоби) — поліморфізм;
3. Інваріант — деяка логічна умова, значення якої повинно зберігатися (передумова та постумова).
№18 слайд
![Приклад include lt iostream.h](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img17.jpg)
Содержание слайда: Приклад
#include <iostream.h>
//Make public and private explicit in class
class complex_c1 {
public://need to know style- our preference
void assign(double r, double i);
void print()
{ cout << real << " + " << imag << "i ";}
private:
double real, imag;
};
inline void complex_c1::assign(double r, double i = 0.0)
{
real = r;
imag = i;
}
№19 слайд
![нкапсуляц я нкапсуляц я це](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img18.jpg)
Содержание слайда: Інкапсуляція
Інкапсуляція – це процес відокремлення одного елементу від інших елементів об’єкту, що визначають його структуру від поведінки. Призначена для того, щоб ізолювати контрактні обов’язки абстракції від їх реалізації дозволяє створити уявність простоти програми.
№20 слайд
![Приклад include lt iostream.h](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img19.jpg)
Содержание слайда: Приклад
#include <iostream.h>
//Make public and private explicit in class
class complex_c1 {
public://need to know style- our preference
void assign(double r, double i);
void print()
{ cout << real << " + " << imag << "i ";}
private:
double real, imag;
};
inline void complex_c1::assign(double r, double i = 0.0)
{
real = r;
imag = i;
}
№21 слайд
![Модульн сть Модульн сть це](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img20.jpg)
Содержание слайда: Модульність
Модульність — це властивість системи, що була розкладена внутрішньо, в якій модулі пов’язані між собою слабко.
Модулі — об’єктні:
виконують роль фізичних контейнерів, що містять визначення класів та об’єктів;
розроблюються різними людьми;
модулі можуть компілюватися окремо;
в один модуль групуються логічно пов’язані класи та об’єкти.
№22 слайд
![Приклад include lt iostream.h](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img21.jpg)
Содержание слайда: Приклад
#include <iostream.h>
//Make public and private explicit in class
class complex_c1 {
public://need to know style- our preference
void assign(double r, double i);
void print()
{ cout << real << " + " << imag << "i ";}
private:
double real, imag;
};
inline void complex_c1::assign(double r, double i = 0.0)
{
real = r;
imag = i;
}
№25 слайд
![ОСНОВН ВЛАСТИВОСТ ООП До](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img24.jpg)
Содержание слайда: ОСНОВНІ ВЛАСТИВОСТІ ООП
До основних принципів ООП відносяться наступні:
1. Абстракція — виділення головного.
2. Інкапсуляція — можливість приховати внутрішні деталі під час опису загального інтерфейсу. Ключові слова private, public, protected визначають рівень доступу для забезпечення інкапсуляції (на рівні об’єктів);
3. Успадкування — передача властивостей від попередника (отримання властивостей з протоколу базового класу). Засіб отримання нових класів з існуючих;
4. Поліморфізм — умови, в яких вид має різні морфологічні форми. Окремі повідомлення можуть викликати різноманітні дії. Спосіб реалізації — перевантаження операцій та функцій – паралельний поліморфізм, коли тип невизначений, а його значення вказується пізніше (в С++ — базові вказівники та шаблони).
№26 слайд
![Основна концепц я ООП Основна](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img25.jpg)
Содержание слайда: Основна концепція ООП
Основна концепція ООП — передача повідомлень об’єктам.
Абстрактні типи даних в С++ реалізуються за допомогою механізму класів (дозволяє керувати видимістю того, що є в основі виконання).
Клас — ключове слово “Сlass” — абстрактний тип даних.
Об’єкт — змінна типу СlassName, де СlassName — визначений раніше клас.
Дані стану оголошуються в описі класу і називаються полями даних, дані-члени чи члени.
№28 слайд
![Основна концепц я ООП Пов](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img27.jpg)
Содержание слайда: Основна концепція ООП
Повідомлення – вказуються за допомогою прототипів функцій в описі класу. Прототип функції — це тип значення, що повертається, ім’я функції та список параметрів. Список параметрів включає типи параметрів та необов’язкові імена параметрів.
Метод в С++ — це визначення (реалізація) функції. Прототипи функції та визначення називаються функціями-членами класу. Члени класу — це поля даних та функції-члени.
Підклас — похідний клас. Його суперклас чи базовий клас називається базовим.
№30 слайд
![Мета введення клас в в С](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img29.jpg)
Содержание слайда: Мета введення класів в С++
Головна мета введення концепції класів в С++ — це забезпечення програміста засобами для створення нових типів, які були б такими ж зручними у використанні, як і вбудовані.
Тип — конкретний представник деякої концепції.
Клас — це тип, що визначає користувач. Для визначення концепції, яка не виражається безпосередньо вбудованими типами, створюються нові типи. Ретельно підібраний набір типів, які визначає користувач, робить програму коротшою і виразнішою.
Основний сенс введення нових типів полягає в обмеженні доступу до даних ззовні та у використанні для цього спеціальних процедур у межах чітко визначеного інтерфейсу.
№31 слайд
![Функц -члени Функц , визначен](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img30.jpg)
Содержание слайда: Функції-члени
Функції, визначені всередині опису класу (до речі, структура — це один з видів класу), називаються функціями-членами, і їх можна викликати тільки для змінної відповідного типу, використовуючи стандартний синтаксис доступу до членів структури.
Оскільки різні структури можуть мати функції-члени з однаковими назвами, то, визначаючи функцію-член треба вказати ім’я структури:
№34 слайд
![Контроль доступу мена в](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img33.jpg)
Содержание слайда: Контроль доступу
Імена в закритій private частині можна використовувати тільки у функціях-членах класу. Відкрита public частина утворює відкритий інтерфейс об’єктів класу. (Структура — клас, члени якого відкриті за замовчуванням). Крім того, існує мітка protected (захищений), тобто всі змінні будуть доступні тільки прямим нащадкам цього класу.
Захист закритих даних базується на обмеженні використання імен членів класу. Цей захист можна обійти, маніпулюючи з адресами і явним перетворенням типу. Захист проти зловмисного доступу до закритих даних мовою високого рівня можна забезпечити тільки на апаратному рівні, хоча навіть це — досить складне завдання в реальній системі.
№36 слайд
![Приклад include lt iostream](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img35.jpg)
Содержание слайда: Приклад
#include <iostream>
using namespace std;
class Conscription {
static int Age;
public:
void setInt(int n) {
Age = n;
}
int getInt() {
return Age;
}
};
int main()
{
Conscription Petrov, Sidorov;
Petrov.setInt(18);
cout << “Petrov’s age: " << Petrov.getInt() << '\n'; // displays 18
cout << “Sidorov’s age: " << Sidorov.getInt()<<'\n';// also displays 18
return 0;
}
№37 слайд
![Константн функц -члени Нехай](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img36.jpg)
Содержание слайда: Константні функції-члени
Нехай у класі Х існують функції, які надають і змінюють значення об’єкта типу Х. Але, на жаль, не існує способу для перевірки значення об’єкта Х. Проте цю проблему можна легко вирішити, описавши ці функції як константні функції-члени, тобто функції, які не змінюють стан Х:
№38 слайд
![Приклад три способи](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img37.jpg)
Содержание слайда: Приклад: три способи використання const
class Birthday {
int d,m,y;
const string congratulations;
public:
int day() const {return d;}
int month() const {return m;}
int year() const {return y;}
const string getCon() { return congratulations; }
void print (const int d, const int m, const int y)
{cout<<“My birthday is ”<< d<<“.”<<m<<“.”<<y<<“.”;}
//…
};
№39 слайд
![Константн функц -члени Коли](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img38.jpg)
Содержание слайда: Константні функції-члени
Коли константна функція-член описується зовні, а не всередині класу, то потрібно додати суфікс const:
inline int Date::year() const //правильно
{ return y;}
Константну функцію-член можна викликати як для константного, так і для неконстантного об’єкта, тоді як неконстантну функцію-член можна викликати тільки для об’єкта, який не є константою
№42 слайд
![рарх я клас в Об кти р зних](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img41.jpg)
Содержание слайда: Ієрархія класів
Об’єкти різних класів і самі класи можуть перебувати у відношенні успадкування, за якого формується ієрархія об’єктів, що відповідає заздалегідь передбаченій ієрархії класів.
Ієрархія класів дозволяє визначати нові класи на основі вже існуючих. Існуючі класи зазвичай називають базовими (інколи батьківським), а нові класи, що формуються на основі базових, — похідними (породженими), інколи класами-нащадками або спадкоємцями. Похідні класи “отримують спадок” — дані і методи своїх базових класів — і, крім того, можуть поповнюватись власними компонентами (даними і власними методами).
Наприклад, за таким визначенням
class S: X{…};
клас S породжений класом X, звідки він успадковує компоненти.
№45 слайд
![Приклад виконання](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img44.jpg)
Содержание слайда: Приклад виконання
//-------------------------------------------------
int main()
{
Student Olga; //створення об’єкта
Student* Nick; //створення вказівника
Olga.setData(); //виклик функції setData() об’єкта Olga
Olga.getData();
Nick=new Student; //виділення пам’яті під об’єкт
Nick->setData(); //виклик функції об’єкта *Nick
Nick->getData();
getch();
return 0;
}
№46 слайд
![Об кти Об кт завжди ч тко](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img45.jpg)
Содержание слайда: Об'єкти
Об‘єкт завжди:
є чітко обмеженим
не обов‘язково є відчутним
Приклад: процес хімічного виробництва
Об‘єкт характеризується станом, поведінкою та ідентичністю;
структура та поведінка схожих об‘єктів визначають їх загальний клас. Об`єкт - це екземпляр класу.
Приклад: автомат з напоями, ліфт.
Стан об‘єкту — перелік (зазвичай статичний) усіх властивостей цього об‘єкту та поточними (звичайно динамічними) значеннями кожного з цих властивостей.
№47 слайд
![Приклад class PersonnelRecord](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img46.jpg)
Содержание слайда: Приклад
class PersonnelRecord
{
public:
char * employee Name () const; //всі об‘єкти можуть
int employee Local Security Number () const;
//отримати дані
char * employee Department () const;
protected:
char name [100]; //лише підкласи
int Social Security Number; //можуть визначати
char department [10]; //значення
float Salary;
};
№48 слайд
![Повед нка об кту Повед нка об](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img47.jpg)
Содержание слайда: Поведінка об’єкту
Поведінка об‘єкту — це спосіб дії та реакції об‘єкту.
Поведінка висловлюється в термінах стану об‘єкту та передачі повідомлень.
Поведінка — яка спостерігається і перевіряється зовні дії об‘єкту.
Приклад: Автомат — в залежності від стану (кількості монет) видає або ні напій.
№49 слайд
![Приклад Розглянемо клас Черга](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img48.jpg)
Содержание слайда: Приклад
Розглянемо клас «Черга»
class Queue
{
public:
Queue ();
Queue (const Queue &);
virtual ~Queue (); //знищує чергу, але не її учасників
virtual Queue & Operator = (const Queue &)
//virtual - буде визначатися
// в класах-нащадках
virtual int operator = = (const Queue &) const;
int operator! = (const Queue &) const;
virtual void clear ();
virtual void append (const void *);
virtual void pop (); //просування черги
virtual void remove (int at);
virtual int length ();
virtual int isEmpty () const;
virtual const void * front () const;
virtual int location (const void *)const;
protected:
};
№51 слайд
![В дношення м ж класами Класи](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img50.jpg)
Содержание слайда: Відношення між класами
Класи не існують ізольовано.
Основні типи відносин між класами:
1. "узагальнення/спеціалізація" (загальне–частинне) “is a”
2. "ціле–частина" — “part of”
3. асоціація — семантичний, смисловий зв‘язок.
ОО мови програмування підтримують різні комбінації наступних типів відносин:
асоціація — найбільш загальне та невизначене відношення
успадкування — "загальне–частинне"
агрегація — "ціле–частина"
використання — наявність зв‘язку між екземплярами класів
інстанціонування — специфічний різновид узагальнення
метаклас — клас класів (класи як об‘єкти).
№54 слайд
![Асоц ац я Асоц ац я смисловий](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img53.jpg)
Содержание слайда: Асоціація
Асоціація — смисловий зв‘язок, як правило, не має напрямку та не пояснює, як класи спілкуються один з одним.
Потужність — кількість учасників цього смислового зв`язку
один до одного;
один до багатьох;
багато до багатьох.
Агрегація — включення одного класу до іншого — відповідає агрегації між екземплярами.
Агрегація як співвідношення "ціле–частина" є спрямованою. Не вимагає обов‘язкового фізичного включення (акціонер володіє акціями, але не складається з них).
Якщо (і тільки якщо) існує відношення "ціле–частина" між об‘єктами, класи повинні знаходитися у співвідношенні агрегації.
Використання — спрямовано, якщо клас є частиною сигнатури функції-члена іншого класу (параметром).
Використання класів –> рівноправний зв‘язок між їх екземплярами (клієнт–сервер).
№55 слайд
![Конструктори Одне з основних](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img54.jpg)
Содержание слайда: Конструктори
Одне з основних завдань об’єктно-орієнтованого програмування полягає у тому, щоб об’єкти описаного раз і назавжди класу працювали «правильно» — тобто так, як це визначає модель. Кожний об’єкт перед тим як почати роботу, потрібно створити, тобто перевести в якийсь початковий стан. Отже, треба якимось чином описати можливі механізми створення об’єктів даного класу. Для цього в мові C++ існують конструктори. Це особливі методи класу, які й повинні перевести об’єкт у той самий початковий стан. Конструктор описується як метод, ім’я якого збігається з іменем класу, а тип поверненого значення опущений.
№56 слайд
![Приклад. Конструктор з](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img55.jpg)
Содержание слайда: Приклад. Конструктор з параметрами для класу «Point»
class Point
{
public:
Point(int x0, int y0);
private:
int x, y;
};
Point::Point(int x0, int y0)
{
x=x0;
y=y0;
}
Тепер для створення об’єкта класу Point потрібно після імені змінної вказати параметри, як для виклику функції:
Point A(1, 1), B(2, 0);
№57 слайд
![Типи конструктор в снують](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img56.jpg)
Содержание слайда: Типи конструкторів
Існують деякі типи конструкторів, які, крім безпосереднього використання, автоматично викликаються у деяких особливих ситуаціях.
Конструктор за замовчуванням
Конструктор за замовчуванням - це конструктор, що викликається без параметрів:
Point();
Point(int a=5);
Його використовують для створення масиву об’єктів, оскільки не зрозуміло, які конструктори і з якими параметрами треба викликати для кожного елементу масиву. Наприклад:
Point A[10];
Point* B=new Point[10];
Конструктор за замовчуванням викликається також тоді, якщо не вказано параметри для ініціалізації об’єкта, як у цьому випадку:
Point p;
№58 слайд
![Конструктор коп ювання Цей](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img57.jpg)
Содержание слайда: Конструктор копіювання
Цей конструктор викликається тоді, коли потрібно створити копію об’єкта. Аргументом цього конструктора має бути посилання на об’єкт цього самого класу:
Point(Point& p);
Важливим випадком, коли викликається конструктор копіювання, є передавання об’єкта у функцію як параметра за значенням. Тоді створюється новий об’єкт і для нього автоматично викликається конструктор копіювання. Створення конструкторів копіювання потрібне у випадку, якщо об’єкт потребує якихось спеціальних операцій при копіюванні, оскільки під час стандартного копіювання вміст одного об’єкта просто побайтно переноситься в інший.
№59 слайд
![Приклад. Клас String з реал](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img58.jpg)
Содержание слайда: Приклад. Клас String з реалізованими конструкторами
class String
{
public:
String(); // конструктор за замовчуванням
String(const String& s); // конструктор копіювання
String(const char* s); // конструктор з параметром
// const char*, який являє собою
// стандартний рядок s
~String(); // деструктор
private:
char* array; // масив символів
int size; // розмір масиву
};
№60 слайд
![Приклад виклику конструктор в](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img59.jpg)
Содержание слайда: Приклад виклику конструкторів
int main()
{ String a, b; // конструктор за замовчуванням
String c(a); // конструктор копіювання
print(a); // конструктор копіювання, оскільки
// аргумент передається у функцію за значенням
String d(“One”); // конструктор з параметром
//...
}
№61 слайд
![Деструктори Конструктори н ц](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img60.jpg)
Содержание слайда: Деструктори
Конструктори ініціалізують об’єкт, тобто вони створюють середовище, у якому "працюють" функції-члени. Іноді створення такого середовища зумовлює "захоплення" якихось ресурсів: пам’яті, файлу, процесорного часу, які повинні бути "звільнені" після їх використання. Тобто класам потрібна функція, яка б знищувала об’єкт аналогічно тому, як його створює конструктор. Такі функції називають деструкторами
№66 слайд
![Типи в дношень Класи, як об](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img65.jpg)
Содержание слайда: Типи відношень
Класи, як і об‘єкти не існують ізольовано!!!
Основні типи відношень між класами (на етапі проектування)
“Узагальнення/спеціалізація" (загальне–частинне) “is a”
напр., троянди є частинним випадком квітів, тобто підкласом більш загального класу «квіти»
Ціле/частина("part of")
напр., лепестки являются частью цветов
Семантичний, змістовний зв’язок та асоціація
напр., насекомые ассоциируются с цветами
№67 слайд
![Отношения в языках](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img66.jpg)
Содержание слайда: Отношения в языках программирования 1/2
ОО языки программирования поддерживают разные комбинации следующих отношений
Ассоциация
обозначает смысловую связь между классами
наиболее общее и неопределенное отношение
Наследование
выражает отношение общего и частного
напр., цветок – роза, человек – студент
Агрегация
выражает отношение целого и части
напр., цветок состоит из лепестков,
№68 слайд
![Отношения в языках](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img67.jpg)
Содержание слайда: Отношения в языках программирования 2/2
Использование
наличие связи между экземплярами классов
напр., экземпляр класса явл. параметром функции-члена другого класса
Инстанцирование
специфическая разновидность обобщения
напр., в С++ - шаблоны
Метакласс
это класс классов, что позволяет трактовать классы как объекты
№69 слайд
![Ассоциация Отношение,](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img68.jpg)
Содержание слайда: Ассоциация
Отношение, означающее некоторую смысловую связь между классами
Асоціація — смисловий зв‘язок, як правило, не має напрямку та не пояснює, як класи спілкуються один з одним.
Потужність — кількість учасників цього смислового зв`язку
“один до одного”;
“один до багатьох”;
“багато до багатьох”.
№73 слайд
![Наследование Отношение между](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img72.jpg)
Содержание слайда: Наследование
Отношение между классами, при котором класс использует структуру или поведение другого (одиночное наследование) или других (множественное наследование) классов
Вводит иерархию "общее/частное"
Множественное наследование
в С++ - возожно, однако создает трудности!
в Java – запрещено, однако возможно множественная реализация интерфейсов
№75 слайд
![Приклад class PersonnelRecord](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img74.jpg)
Содержание слайда: Приклад
class PersonnelRecord
{
public:
char * employee Name () const; //всі об‘єкти можуть
int employee Local Security Number () const;
//отримати дані
char * employee Department () const;
protected:
char name [100]; //лише підкласи
int Social Security Number; //можуть визначати
char department [10]; //значення
float Salary;
};
№76 слайд
![рарх я клас в Об кти р зних](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img75.jpg)
Содержание слайда: Ієрархія класів
Об’єкти різних класів і самі класи можуть перебувати у відношенні успадкування, за якого формується ієрархія об’єктів, що відповідає заздалегідь передбаченій ієрархії класів.
Ієрархія класів дозволяє визначати нові класи на основі вже існуючих. Існуючі класи зазвичай називають базовими (інколи батьківським), а нові класи, що формуються на основі базових, — похідними (породженими), інколи класами-нащадками або спадкоємцями. Похідні класи “отримують спадок” — дані і методи своїх базових класів — і, крім того, можуть поповнюватись власними компонентами (даними і власними методами).
Наприклад, за таким визначенням
class S: X{…};
клас S породжений класом X, звідки він успадковує компоненти.
Віртуальні функції визначаються специфікатором virtual і дозволяють програмісту описати в базовому класі функції, які можна було б замінити у кожному наступному класі.
№79 слайд
![Успадкування class](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img78.jpg)
Содержание слайда: Успадкування
class ElectricalData : public TelemetryData {
public:
ElectricalData(float v1, float v2, float a1, float a2);
~ElectricalData();
void transmit();
float currentPower() const;
protected:
float fuelCell1Voltage, fuelCell2Voltage;
float fuelCell1Amperes, fuelCell2Amperes;
};
№80 слайд
![Агрегац я Виража в дношення ц](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img79.jpg)
Содержание слайда: Агрегація
Виражає відношення цілого та частини
Агрегація — включення одного класу до іншого — відповідає агрегації між екземплярами.
Агрегація як співвідношення "ціле–частина" є спрямованою. Не вимагає обов‘язкового фізичного включення (акціонер володіє акціями, але не складається з них).
Якщо (і тільки якщо) існує відношення "ціле–частина" між об‘єктами, класи повинні знаходитися у співвідношенні агрегації.
Приклад 1
Heater – нагрівач
TemperatureController –
контролер температури
№83 слайд
![Використання Використання в](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img82.jpg)
Содержание слайда: Використання
Використання — відношення між класами, якщо клас є частиною сигнатури функції-члена іншого класу (параметром).
Використання класів –> рівноправний зв‘язок між їх екземплярами (клієнт–сервер).
Пример 1
TemperatureController –
контролер температури
TemperatureRamp –
визначає функцію часу
від температури
№88 слайд
![Идентичность Идентичность -](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img87.jpg)
Содержание слайда: Идентичность
Идентичность - это такое свойство объекта, которое отличает его от всех других объектов
«В большинстве языков программирования и управления базами данных для различения временных объектов их именуют, тем самым путая адресуемость и идентичность. Большинство баз данных различают постоянные объекты по ключевому атрибуту, тем самым смешивая идентичность и значение данных". – Хошафян и Коупленд
Источником множества ошибок в объектно-ориентированном программировании является неумение отличать имя объекта от самого объекта.
№90 слайд
![Пример class DisplayItem](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img89.jpg)
Содержание слайда: Пример
class DisplayItem {
public:
DisplayItem();
DisplayItem(const Point& location);
virtual ~DisplayItem();
virtual void draw();
virtual void erase();
virtual void select();
virtual void unselect();
virtual void move(const Point& location);
int isSelected() const;
Point location() const;
int isUnder(const Point& location) const;
protected:
...
};
№91 слайд
![Экземпляры классов Объявим](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img90.jpg)
Содержание слайда: Экземпляры классов
Объявим экземпляры указанных классов:
DisplayItem item1;
DisplayItem* item2 = new DisplayItem(Point(75, 75));
DisplayItem* item3 = new DisplayItem(Point(100, 100));
DisplayItem* item4 = 0;
Уникальная идентичность (но не обязательно имя) каждого объекта сохраняется на все время его существования, даже если его внутреннее состояние изменилось.
№92 слайд
![Идентичность Рассмотрим](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img91.jpg)
Содержание слайда: Идентичность
Рассмотрим результат выполнения следующих операторов
item1.move(item2->location());
item4 = item3;
item4->move(Point(38, 100));
Объект item1 и объект, на который указывает item2, теперь относятся к одной и той же точке экрана. Указатель item4 стал указывать на тот же объект, что и item3. Кстати, заметьте разницу между выражениями "объект item2" и "объект, на который указывает item2". Второе выражение более точно, хотя для краткости мы часто будем использовать их как синонимы.
№93 слайд
![Идентичность Хотя объект item](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img92.jpg)
Содержание слайда: Идентичность
Хотя объект item1 и объект, на который указывает item2, имеют одинаковое состояние, они остаются разными объектами.
Кроме того, мы изменили состояние объекта *item3, использовав его новое косвенное имя item4.
Эта ситуация называется структурной зависимостью.
Структурная зависимость порождает в объектно-ориентированном программировании много проблем. Трудность распознания побочных эффектов при действиях с синонимичными объектами часто приводит к "утечкам памяти", неправильному доступу к памяти, и, хуже того, непрогнозируемому изменению состояния. Например, если мы уничтожим объект через указатель item3, то значение указателя item4 окажется бессмысленным; эта ситуация называется повисшей ссылкой.
№95 слайд
![Идентичность В первой строке](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img94.jpg)
Содержание слайда: Идентичность
В первой строке создается синоним: item2 указывает на тот же объект, что и item1.
Во второй доступ к состоянию item1 получен через этот новый синоним. К сожалению, при этом произошла утечка памяти, - объект, на который первоначально указывала ссылка item2, никак не именуется ни прямо, ни косвенно, и его идентичность потеряна.
В Smalltalk и CLOS память, отведенная под объекты, будет вновь возвращена системе сборщиком мусора.
В языках типа C++ такая память не освобождается, пока не завершится программа, создавшая объект. Такие утечки памяти могут вызвать и просто неудобство, и крупные сбои, особенно, если программа должна непрерывно работать длительное время
№96 слайд
![Копирование, присваивание и](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img95.jpg)
Содержание слайда: Копирование, присваивание и равенство
Структурная зависимость имеет место, когда объект имеет несколько имен. В наиболее интересных приложениях объектно-ориентированного подхода использование синонимов просто неизбежно. Например, рассмотрим следующие две функции:
void highLight(DisplayItem& i);
void drag(DisplayItem i); // Опасно
Если вызвать первую функцию с параметром item1, будет создан псевдоним: формальный параметр i означает ссылку на фактический параметр, и следовательно item1 и i именуют один и тот же объект во время выполнения функции. При вызове второй функции с аргументом item1 ей передается новый объект, являющийся копией item1: i обозначает совершенно другой объект, хотя и с тем же состоянием, что и item1.
№97 слайд
![Копирование, присваивание и](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img96.jpg)
Содержание слайда: Копирование, присваивание и равенство
В C++ различают передачу параметров по ссылке и по значению. Надо следить за этим, иначе можно нечаянно изменить копию объекта, желая изменить сам объект. В общем случае, передача объектов по ссылке крайне желательна для сложных объектов, поскольку при этом копируется ссылка, а не состояние, и следовательно, достигается большая эффективность (за исключением тех случаев, когда передаваемое значение очень простое).
В некоторых случаях, однако, подразумевается именно копирование. В языках типа C++ семантику копирования можно контролировать. В частности, мы можем ввести конструктор копии в определение класса, как в следующем фрагменте кода, который можно было бы включить в описание класса DisplayItem:
DisplayItem(const DisplayItem&);
В C++ конструктор копии может быть вызван явно (как часть описания объекта) или неявно (с передачей объекта по значению)
№98 слайд
![Присваивание, копирование и](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img97.jpg)
Содержание слайда: Присваивание, копирование и равенство
Присваивание - это, вообще говоря, копирование
Копирование
«глубокое» - копирование всех ссылок и указателей на другие обьекты
«поверхностное» - копирует только объект, используя конструктор копирования
Равенство может быть:
2 объекта обозначают 1 объект (item3 и item4)
Равенство состояний у разных объектов (item1 и item2)
№99 слайд
![Равенство В C нет](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img98.jpg)
Содержание слайда: Равенство
В C++ нет предопределенного оператора равенства, поэтому мы должны определить равенство и неравенство, объявив эти операторы при описании:
Мы предлагаем описывать оператор равенства как виртуальный (так как ожидаем, что подклассы могут переопределять его поведение), и описывать оператор неравенства как невиртуальный (так как хотим, чтобы он всегда был логическим отрицанием равенства: подклассам не следует переопределять это).
virtual int operator=(const DisplayItem&) const;
int operator!=(const DisplayItem&) const;
№101 слайд
![Явное создание объекта](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img100.jpg)
Содержание слайда: Явное создание объекта
Объекты создаются явно или неявно
Явно
При объявлении (как это было с item1): тогда объект размещается в стеке
Можно разместить объект, то есть выделить ему память из «кучи» (item3)
В C++ в любом случае при этом вызывается конструктор, который выделяет известное ему количество правильно инициализированной памяти под объект.
№102 слайд
![Неявное создание объекта](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img101.jpg)
Содержание слайда: Неявное создание объекта
Неявно
передача параметра по значению в C++ создает в стеке временную копию объекта.
создание объектов транзитивно: создание объекта тянет за собой создание других объектов, входящих в него
Объекты, созданные в стеке, уничтожаются при выходе из блока, в котором они были определены, но объекты, созданные в "куче" оператором new, продолжают существовать и занимать место в памяти: их необходимо явно уничтожать оператором delete.
№104 слайд
![Успадкування Об кти р зних](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img103.jpg)
Содержание слайда: Успадкування
Об’єкти різних класів і самі класи можуть перебувати у відношенні успадкування, за якого формується ієрархія об’єктів, що відповідає заздалегідь передбаченій ієрархії класів.
Ієрархія класів дозволяє визначати нові класи на основі вже існуючих. Існуючі класи зазвичай називають базовими (інколи породжуюими), а нові класи, що формуються на основі базових, — похідними (породженими), інколи класами-нащадками або спадкоємцями.
Похідні класи “отримують спадок” — дані і методи своїх базових класів — і, крім того, можуть поповнюватись власними компонентами (даними і власними методами). Елементи, які успадковуються, не переміщуються в похідний клас, а залишаються в базових класах. Повідомлення, обробку якого не можуть виконати методи похідного класу, автоматично передається в базовий клас.
№105 слайд
![Успадкування Будь-який пох](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img104.jpg)
Содержание слайда: Успадкування
Будь-який похідний клас може, в свою чергу, стати базовим для інших класів, і таким чином формується напрямлений граф ієрархії класів та об’єктів. В ієрархії похідний об’єкт успадковує дозволені для успадкування компоненти всіх базових об’єктів. Іншими словами, в об’єкта є можливість доступу до даних і методів усіх своїх базових класів.
Успадкування в ієрархії класів може відображатись і у вигляді дерева, і у вигляді більш загального напрямленого ациклічного графу. В С++ дозволяється множинне успадкування — можливість для деякого класу успадковувати компоненти кількох ніяк не зв’язаних між собою базових класів.
№107 слайд
![Приклад class ElectricalData](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img106.jpg)
Содержание слайда: Приклад class ElectricalData
class ElectricalData: public TelemetryData {
public:
ElectricalData(float v1, float v2, float a1,
float a2);
virtual ~ElectricalData();
void transmit();
float currentPower() const;
//розвив потужність
protected:
float fuelCell1 Voltage, fuelCell2 Voltage;
//напруга та струм
float fuelCell1 Amperes, fuelCell2 Amperes;
// в обох електробатареях
};
№109 слайд
![Приклад базовий клас](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img108.jpg)
Содержание слайда: Приклад : базовий клас
Предположим, у вас есть базовый класс employee:
#include <iostream.h>
#include <string.h>
class employee
{
public:
employee(char *, char *, float);
void show_employee(void);
prоtected:
char name[64];
char position[64];
float salary;
};
Далее предположим, требуется класс manager, который добавляет следующие элементы данных в класс employee:
float annual_bonus;
char company_car[64];
№110 слайд
![Защищенные элементы](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img109.jpg)
Содержание слайда: Защищенные элементы обеспечивают доступ и защиту
Программа не может обратиться напрямую к частным элементам класса. Для обращения к частным элементам программа должна использовать интерфейсные функции, которые управляют доступом к этим элементам.
Как вы, вероятно, заметили, наследование упрощает программирование в том случае, если производные классы могут обращаться к элементам базового класса с помощью оператора точки. В таких случаях ваши программы могут использовать защищенные элементы класса.
Производный класс может обращаться к защищенным элементам базового класса напрямую, используя оператор точку. Однако оставшаяся часть вашей программы может обращаться к защищенным элементам только с помощью интерфейсных функций этого класса.
Таким образом, защищенные элементы класса находятся между открытыми (доступными всей программе) и закрытыми (доступными только самому классу) элементами.
№111 слайд
![Функц -члени базового класу](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img110.jpg)
Содержание слайда: Функції-члени базового класу
employee::employee(char *name, char *position, float salary) // конструктор
{
strcpy(employee::name, name);
strcpy(employee::position, position);
employee::salary = salary;
}
void employee::show_employee(void)
{
cout << "Имя: " << name << endl;
cout << "Должность: " << position << endl;
cout << "Оклад: $" << salary << endl;
}
№113 слайд
![Функц -члени пох дного класу](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img112.jpg)
Содержание слайда: Функції-члени похідного класу
manager::manager(char *name, char *position, char *company_car, float salary, float bonus) : employee(name, position, salary)
// ініціалізатор конструктора
{
strcpy(manager::company_car, company_car) ;
manager::annual_bonus = bonus ;
}
void manager::show_manager(void)
{
show_employee(); // без явної кваліфікації (підклас є //підтипом)
cout << "Машина фирмы: " << company_car << endl;
cout << "Ежегодная премия: $" << annual_bonus << endl;
}
№115 слайд
![Резюме Наследование отношение](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img114.jpg)
Содержание слайда: Резюме
Наследование – отношение между классами, позволяющее производить новый класс из существующего базового класса.
Производный класс — это новый класс, а базовый класс — существующий класс.
Для порождения класса из базового начинайте определение производного класса ключевым словом class, за которым следует имя класса, двоеточие и имя базового класса, например class dalmatian: dog.
Когда вы порождаете класс из базового класса, производный класс может обращаться к общим элементам базового класса, как будто эти элементы определены внутри самого производного класса. Для доступа к частным данным базового класса производный класс должен использовать интерфейсные функции базового класса.
Внутри конструктора производного класса ваша программа должна вызвать конструктор базового класса, указывая двоеточие, имя конструктора базового класса и соответствующие параметры сразу же после заголовка конструктора производного класса.
№116 слайд
![Резюме Чтобы обеспечить](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img115.jpg)
Содержание слайда: Резюме
Чтобы обеспечить производным классам прямой доступ к определенным элементам базового класса, в то же время защищая эти элементы от оставшейся части программы, C++ обеспечивает защищенные {protected) элементы класса. Производный класс может обращаться к защищенным элементам базового класса, как будто они являются общими. Однако для оставшейся части программы защищенные элементы эквивалентны частным.
Если в производном и базовом классе есть элементы с одинаковым именем, то внутри функций производного класса C++ будет использовать элементы производного класса. Если функциям производного класса необходимо обратиться к элементу базового класса, вы должны использовать оператор глобального разрешения, например base class:: member.
№117 слайд
![Пол морф зм VCL в зуальн](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img116.jpg)
Содержание слайда: Поліморфізм
VCL — візуальні компоненти. TОbject — базовий клас.
Клас має 2 типи клієнтів:
– екземпляри — зовнішня візуальна поведінка (відкрита частина опису)
– підкласи — визначаються захищеною частиною опису класу.
Поведінка класу успадковується. Функція, оголошена віртуальною, може бути перевизначена в підкласі, а інші — ні. В підкласах можуть бути додані нові функції.
№119 слайд
![Пол морф зм void](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img118.jpg)
Содержание слайда: Поліморфізм
void TelemetryData::transmit()
//передає заголовок пакету
{
//передати id
//передати timeStamp
};
void ElectricalData::transmit()
//перевизначення
{
TelemetryData::transmit ( );
//виклик функції суперкласу з використанням
//кваліфікованого імені
//передати напругу
//передати силу току
};
№121 слайд
![Пол морф зм i transmit](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img120.jpg)
Содержание слайда: Поліморфізм
i transmit FreshData(telemetry, Time (60));
ii transmit FreshData(electrical, Time (120));
i — перша функція передає заголовок, ii — передає заголовок та 4 дійсних числа. Це приклад поліморфізму.
Змінна d може позначати об‘єкти різних класів, в яких є загальний суперклас — параметричний поліморфізм.
№122 слайд
![Перенавантаження Вперше дею](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img121.jpg)
Содержание слайда: Перенавантаження
Вперше ідею поліморфізму пов‘язували з можливістю перевизначати зміст символів, наприклад “+”. В сучасному програмуванні це називається перевантаженням:
функцій (відрізняються сигнатурою)
операцій.
За умов відсутності поліморфізму код програми має містити оператори switch та case.
№123 слайд
![Механ зм п знього зв язування](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img122.jpg)
Содержание слайда: Механізм пізнього зв’язування
Поліморфізм тісно пов‘язаний з механізмом пізнього зв‘язування: зв‘язок методу та імені за умов поліморфізму визначаються тільки в процесі виконання програми.
Якщо функція віртуальна, то зв‘язування пізнє, звідси функція поліморфна. Якщо ні — зв‘язок здійснюється під час компіляції.
№124 слайд
![Успадкування та тип зац я В д](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img123.jpg)
Содержание слайда: Успадкування та типізація
В діаграмі класів TelemetryData усі підкласи є підтипами вищого класу.
Система типів, паралельна успадкуванню, характерна для мов з сильною типізацією, в тому числі C++.
Паралель між типізацією та успадкуванням з‘являється там, де іерархія загального і часткового висловлює смислові зв‘язки між абстракціями.
№125 слайд
![Приклад успадкування](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img124.jpg)
Содержание слайда: Приклад успадкування
TelemetryData telemetry;
ElectricalData electrical(5.0, -5.0, 3.0, 7.0);
telemetry = electrical; //правомірно, так як
//electrical — підтип telemetry
Проте таке присвоєння небезпечне, оскільки втрачаються усі доповнення в стані підкласу, якщо порівнювати із станом суперкласу.
electrical = telemetry; //невірно
№126 слайд
![Висновок з прикладу Висновок](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img125.jpg)
Содержание слайда: Висновок з прикладу
Висновок: присвоєння об‘єкту y значення об‘єкту x (y=x) припустимо, якщо тип об‘єкту x співпадає з типом об‘єкту y, або x є його підтипом.
Для типів, для яких існує співвідношення клас/підклас, припустиме перетворення типів (в C++ — зведення типів). Звичайно зведення типів використовують для присвоєння об‘єкту спеціалізованого класу об‘єкта більш загального класу. Іноді навпаки (це небезпечно).
№127 слайд
![рарх я тип в В C рарх я тип в](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img126.jpg)
Содержание слайда: Ієрархія типів
В C++ ієрархія типів співпадає з ієрархією класів. Таким чином, техніку виклику методів суперкласу з підкласу можна оптимізувати.
Якщо під час визначення класу його суперклас оголошено public, то підклас є одночасно підтипом (як в TelemetryData): він зобов‘язується виконувати усі обов‘язки суперкласу:
забезпечує сумісну з суперкласом підмножину інтерфейсу
має ідентичну з суперкласом поведінку.
№128 слайд
![Private у суперклас Якщо п д](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img127.jpg)
Содержание слайда: Private у суперкласі
Якщо під час оголошення класу його суперклас оголосити private, то підклас спадкує структуру та поведінку, але не буде підтипом:
відкриті та захищені члени суперкласу стануть закритими членами підкласу, звідси вони будуть недосяжні для підкласів більш низького рівня.
підкласу та суперкласу будуть властиві несумісні (взагалі кажучи) інтерфейси з точки зору клієнта.
№130 слайд
![Висновок з прикладу В цьому](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img129.jpg)
Содержание слайда: Висновок з прикладу
В цьому прикладі суперклас закритий, звідси:
1. його методи недосяжні для клієнтів;
2. об‘єкти підкласу не можна присвоювати об‘єктам суперкласу;
3. функція currentPower() видима завдяки її явній кваліфікації (інакше вона була б недосяжною).
Наслідуваний елемент не можна робити більш відкритим в підкласі, ніж в суперкласі.
Наприклад, член timeStamp (protected в TelemetryData) не може стати public шляхом явної кваліфікації.
№135 слайд
![Проблеми множинного](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img134.jpg)
Содержание слайда: Проблеми множинного успадкування
конфлікт імен між суперкласами в C++ усувається шляхом додавання префікса (повної кваліфікації)
повторне успадкування: один клас є спадкоємцем іншого за кількома лініями
можна заборонити (Smalltalk)
можна розвести дві копії успадкованого елемента, додаючи до імен префікси у вигляді імені класу-джерела (С++)
множинні посилання на один і той же клас можна розглядати як один клас (С++); суперклас, що повторюється, визначається як віртуальний базовий клас (shared class)
№136 слайд
![Множинне успадкування При](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img135.jpg)
Содержание слайда: Множинне успадкування
При множинному успадкуванні використовується прийом створення домішок (mixin) — класів, не призначених для породження самостійних примірників, а для змішування з іншими класами (InsurableItem, InterestBearingItem).
Домішка — це клас, який виражає не поведінку, а одну звичку.
Класи, сконструйовані з домішок, називаються агрегатними.
Множинне успадкування використовується, якщо існує декілька ортогональних наборів ознак, за якими можна згрупувати кінцеві класи і ці групи перекриваються.
№137 слайд
![В дношення м ж класами та об](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img136.jpg)
Содержание слайда: Відношення між класами та об’єктами
Класи і об'єкти тісно пов'язані поняття. Будь-який об'єкт належить деякому класу. Клас породжує будь-яке число об'єктів.
Класи статичні (всі їх особливості і зміст визначаються в процесі компіляції). Об'єкти динамічні, тобто створюються і знищуються в процесі виконання програми.
№138 слайд
![В дношення м ж класами та об](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img137.jpg)
Содержание слайда: Відношення між класами та об’єктами
На етапі аналізу і ранніх стадіях проектування вирішується дві основні задачі:
виявлення класів і об'єктів, що складають словник предметної області
побудова структур, що забезпечують взаємодію об'єктів, при яких виконуються вимоги задачі
№140 слайд
![Як сть клас в Зачем нужны](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img139.jpg)
Содержание слайда: Якість класів
Зачем нужны виртуальные функции
При наследовании часто бывает необходимо, чтобы поведение некоторых методов базового класса и классов-наследников отличались. Решение, на первый взгляд, очевидное: переопределить соответствующие методы в производном классе. Однако тут возникает одна проблема, которую лучше рассмотреть на простом примере (листинг 9.1).
//Листинг 9.1. Необходимость виртуальных функций
#include <iostream> using namespace std;
class Base // базовый класс
{ public:
int f(const int &d) // метод базового класса
{ return 2*d; }
int CallFunction(const int &d) // предполагается
{ return f(d)+1; // вызов метода базового класса
}
};
class Derived: public Base // производный класс
{ public: // CallFunction наследуется
int f(const int &d) // метод f переопределяется
{ return d*d;
}
};
int main()
{
Base a; // объект базового класса
cout << a.CallFunction(5)<< endl; // получаем 11
Derived b; // объект производного власса
cout << b.CallFunction(5)<< endl; // какой метод f вызывается?
return 0;
}
№141 слайд
![В базовом классе определены](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img140.jpg)
Содержание слайда: В базовом классе определены два метода — f() и CallFunction(), — причем во втором методе вызывается первый. В классе-наследнике метод f() переопределен, а метод CallFunction() унаследован. Очевидно, метод f() переопределяется для того, чтобы объекты базового класса и класса-наследника вели себя по-разному. Объявляя объект b типа Derived, программист, естественно, ожидает получить результат 5 * 5 + 1 = 26 — для этого и переопределялся метод f(). Однако на экран, как и для объекта а типа Base, выводится число 11, которое очевидно вычисляется как 2 * 5 + 1 = 11. Несмотря на переопределение метода f() в классе-наследнике, в унаследованной функции CallFunction() вызывается «родная» функция f(), определенная в базовом классе!
Аналогичная проблема возникает и в несколько другом контексте: при подстановке ссылки или указателя на объект производного класса вместо ссылки или указателя на объект базового. Рассмотрим опять пример с часами и будильником (листинг 9.2).
№142 слайд
![Листинг . . Неожиданная](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img141.jpg)
Содержание слайда: //Листинг 9.2. Неожиданная работа принципа подстановки
class Clock // базовый класс — часы
{ public:
void print() const
{ cout << "Clock!" << endl; }
};
class Alarm: public Clock // производный класс — будильник
{ public:
void print() const // переопределенный метод
{ cout << "Alarm!" << endl; }
};
void settime(Clock &d) // функция установки времени
{ d.print(); } // предполагается вызов метода базового класса
//...
Clock W; // объект базового класса
settime(W); // выводится "Clock«
Alarm U; // объект производного класса
settime(U); // ссылка на производный вместо базового
Clock *c1 = &W; // адрес объекта базового класса
c1->print(); // вызов базового метода
c1 = &U; // адрес объекта производного типа вместо базового
c1->print(); // какой метод вызывается, базовый или производный?
№143 слайд
![Опять в классе-наследнике](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img142.jpg)
Содержание слайда: Опять в классе-наследнике переопределен метод для того, чтобы обеспечить различное поведение объектов базового и производного классов. Однако и при передаче параметра по ссылке базового класса в функцию settime(), и при явном вызове метода print() через указатель базового класса наблюдается одна и та же картина: всегда вызывается метод базового класса, хотя намерения программиста состоят в том, чтобы вызвать метод производного.
Для того чтобы разобраться в ситуации, необходимо уяснить, что такое связывание. Связывание — это сопоставление вызова функции с телом. В приведенных ранее примерах связывание выполняется на этапе трансляции (до запуска) программы. Такое связывание обычно называют ранним, или статическим.
При трансляции класса Base (см. листинг 9.1) компилятор ничего не знает о классах-наследниках , поэтому он не может предполагать, что метод f() будет переопределен в классе Derived. Его естественное поведение — «прочно» связать вызов f() с телом метода класса Base. Аналогично при трансляции функции settime() компилятору ничего не известно о типе реально передаваемого объекта во время выполнения программы. Поэтому вызов метода print() связывается с телом метода базового класса Clock, как и определено в заголовке функции settime(). Точно так же указатель на базовый класс «прочно» связывается с методом базового класса во время трансляции.
Конечно, при вызове метода по указателю в данном конкретном случае мы можем вызвать метод производного класса, задав явное преобразование указателя:
№144 слайд
![static cast lt Alarm gt c -](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img143.jpg)
Содержание слайда: static_cast<Alarm*>(c1)->print();
Или так:
((Alarm *)c1)->print(); // "лишние" скобки нужны!
Однако для функции settime() и метода CallFunction() это сделать невозможно — нам необходимо именно разное поведение в зависимости от типа объекта. Да и с указателем не все так просто: если такой вызов прописан внутри функции, которая принимает этот указатель как параметр (например, settime(Clock *c1)), то мы имеем те же проблемы.
Определение виртуальных функций
Получается, что в С++ должен существовать механизм, с помощью которого можно узнать тип объекта во время выполнения программы. Такой механизм в С++ есть и он, как уже отмечалось, называется динамической идентификацией типов (RTTI). Однако в ситуациях, подобных описанным, применяется другой, более «сильный» и элегантный механизм С++ — механизм виртуальных функций (см. п. 10.3 в Стандарте).
Чтобы добиться разного поведения в зависимости от типа, необходимо объявить функцию-метод виртуальной; в С++ это делается с помощью ключевого слова virtual. Таким образом, в листинге 9.1 объявление метода f() в базовом и производном классе должно быть таким:
virtual int f(const int &d) // в базовом классе
{ return 2*d; }
virtual int f(const int &d) // в производном классе
{ return d*d; }
После этого для объектов базового и производного классов мы получаем разные результаты: 11 и 26.
Аналогично в листинге 9.2 объявление метода print() тоже должно начинаться со слова virtual:
virtual void print() const // в базовом классе
{ cout << "Clock!" << endl; }
virtual void print() const // в производном классе
{ cout << "Alarm!" << endl; }
После этого вызов settime() с параметром базового класса обеспечит нам вывод на экран слова «Clock», а с параметром производного класса — слова «Alarm». И при вызове по указателю наблюдается та же картина.
Вообще-то ключевое слово virtual достаточно написать только один раз — в объявлении функции базового класса. Определение можно писать без слова virtual — все равно функция будет считаться виртуальной. Однако лучше всегда это делать явным образом, чтобы всегда по тексту было видно, что функция является виртуальной.
№145 слайд
![Для виртуальных функций](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img144.jpg)
Содержание слайда: Для виртуальных функций обеспечивается не статическое, а динамическое (позднее, отложенное) связывание, которое реализуется во время выполнения программы. Естественно, это влечет за собой некоторые накладные расходы, однако на них можно не обращать внимания, так как обеспечивается динамический полиморфизм. Александреску указывает, что в С++ реализованы два типа полиморфизма:
статический полиморфизм, или полиморфизм времени компиляции (compile-time polymorphism), осуществляется за счет перегрузки и шаблонов функций;
динамический полиморфизм, или полиморфизм времени выполнения (run-time polymorphism), реализуется виртуальными функциями.
С перегрузкой функций «разбирается» компилятор, правильно подбирая вариант функции в той или иной ситуации. И полиморфизм шаблонных функций тоже реализуется на этапе компиляции. Естественно, выбор осуществляется статически. Выбор же виртуальной функции происходит динамически — при выполнении программы. Класс, включающий виртуальные функции, называется полиморфным.
Правила описания и использования виртуальных функций-методов следующие:
1. Виртуальная функция может быть только методом класса.
2. Любую перегружаемую операцию-метод класса можно сделать виртуальной, например, операцию присваивания или операцию преобразования типа.
3. Виртуальная функция, как и сама виртуальность, наследуется.
4. Виртуальная функция может быть константной.
5. Если в базовом классе определена виртуальная функция, то метод производного класса с такими же именем и прототипом (включая тип возвращаемого значения и константность метода) автоматически является виртуальным (слово virtual указывать необязательно) и замещает функцию-метод базового класса.
6. Конструкторы не могут быть виртуальными.
7. Статические методы не могут быть виртуальными.
8. Деструкторы могут (чаще — должны) быть виртуальными — это гарантирует корректный возврат памяти через указатель базового класса.
№147 слайд
![Системи позначень](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img146.jpg)
Содержание слайда: Системи позначень
Загальноприйнята система позначень дозволяє розробнтку описати сценарій або розробити архітектуру та дохідчиво викласти свої решення колегам
Чітка система позначень дозволяє автоматизувати більшу частину процесу перевірки на повноту та коректність
Є засобом виразити результат роздумів над архітектурою та поведінкою системи, і не є самоціллю
№168 слайд
![Планування процес в Вит](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img167.jpg)
Содержание слайда: Планування процесів
Витісняюче
Процес з більшим пріоритетом може віднімати процесорний час у процесу з меншим пріоритетом
Невитісняюче
Однопоточність
Циклічне
Процеси отримують рівну кількість процесорного часу
Алгоритмічне
Використовується деякий алгоритм
Ручне
Контролюється користувачем
№171 слайд
![История создания UML UML это](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img170.jpg)
Содержание слайда: История создания UML
UML
это важный фактический и юридический стандарт для объектно-ориентированного моделирования
появился в 1994 году в результате совместных усилий Гради Буча и Джима Румбаха по объединению их популярных методов — метода Буча и ОМТ (Object Modeling Technique)
в 1997 году был принят в качестве стандартного языка моделирования группой промышленных стандартов OMG (Object Management Group). С тех пор он продолжает развиваться в новой редакции OMG UML.
№172 слайд
![Способы использования UML Для](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img171.jpg)
Содержание слайда: Способы использования UML
Для черновиков
неполные и неформальные диаграммы (зачастую нарисованные от руки на доске), создаваемые для прояснения сложных проектных решений. Здесь используется мощь визуального представления.
Для создания проектной документации
относительно детализированные диаграммы проектирования, применяемые для визуализации и лучшего понимания существующего кода, обратного проектирования или генерации кода.
В качестве языка программирования
полные выполняемые спецификации программных систем на языке UML. Выполняемый код можно автоматически сгенерировать. Однако разработчику его сложно осознать или модифицировать — человек работает только с “языком программирования UML”. Такой способ использования UML требует отображения всей логики системы или ее поведения (возможно, с использованием диаграмм взаимодействия или состояний). Он также придает разработке робастность и надежность.
№173 слайд
![Ракурсы моделей Для всех](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img172.jpg)
Содержание слайда: Ракурсы моделей (1)
Для всех моделей применяется одна и та же система обозначений, но интерпретация диаграмм выполняется в разных ракурсах:
концептуальный (conceptual perspective)
ракурс спецификации (specification perspective)
ракурс реализации (implementation perspective)
№186 слайд
![Диаграммы последовательностей](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img185.jpg)
Содержание слайда: Диаграммы последовательностей
Сообщения между объектами
вызов: запрос объекта-отправителя к объекту-получателю на выполнение одной из его операций
синхронное: отправитель ожидает завершения выполнения операции
асинхронное: отправитель передает управление получателю и не ожидает ответа для продолжения выполнения своих действий
ответ: ответное сообщение
№187 слайд
![Диаграммы последовательностей](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img186.jpg)
Содержание слайда: Диаграммы последовательностей
Пример - автомат по продаже лимонада
1. Покупатель помещает монету в щель на лицевой панели автомата и выбирает сорт лимонада
2. Монета попадает в реестр, который ее обрабатывает.
3. Реестр дает команду отсеку доставить лимонад к лицевой панели автомата.
№195 слайд
![Диаграммы видов деятельности](/documents_6/6533f4eaaf7b0850ad410a886853cdd7/img194.jpg)
Содержание слайда: Диаграммы видов деятельности
Пример - диаграмма видов деятельности для бизнес-процесса встречи с новым клиентом
1.Агент договаривается с клиентом о встрече
2. Если встреча планируется в офисе консалтинговой фирмы, то специалист по техническому обеспечению готовит конференц-зал для переговоров
3. Если встреча состоится в офисе клиента, консультант готовит всю необходимую документацию на переносном компьютере
4. Консультант и агент встречаются с клиентом в назначенном месте и в оговоренное время
5. Агент готовит документы о результатах встречи
6. Если результат встречи положителен и задача сформулирована, консультант оформляет предложение и отправляет его клиенту
Скачать все slide презентации Обєктно-орієнтоване програмування одним архивом:
Похожие презентации
-
Визначення ООП. Лекція 1. Обєктно-орієнтоване програмування
-
Перевантаження операторів та функцій в С. Лекція 3. Обєктно-орієнтоване програмування
-
Методи в Java. Об'єктно-орієнтоване програмування
-
Методи об'єктно-орієнтованого програмування
-
Об'єктно-орієнтоване програмування. Принцип інкапсуляції. (Лекція 1)
-
Об'єктно-орієнтований аналіз
-
Об'єктно-орієнтоване проектування з використанням UML 2. 0 Діаграми варіантів використання
-
Математичне програмування. Задачі оптимізації. Задача лінійного програмування. Лекція 5
-
Мови програмування
-
Складання та виконання лінійних алгоритмів опрацювання величин в навчальному середовищі програмування. Урок 31