Podstawy
programowania
obiektowego
Ćwiczenia laboratoryjne nr 1
Temat: Wstęp do programowania obiektowego
Prowadzący:
mgr inż. Dariusz Rataj
Koszalin 2001
Podstawy programowania obiektowego
Strona 2
Skrócony spis treści:
Część 1 - Programowanie obiektowe w języku C++
Część 2 - Programowanie obiektowe w środowisku Borland C++Builder
1. Programowanie obiektowe w języku C++
1.1. Cel programowania obiektowego
Programowanie obiektowe jest próbą "przeniesienia" rzeczywistości na platformę maszyn liczących zwanych
komputerami. Człowiek w życiu codziennym postrzega przedmioty (obiekty) rzeczywiste w sposób intuicyjny nie
zwracając uwagi na szczegóły zachowania czy stanu przedmiotu. W programowaniu strukturalnym programista jest
zmuszony do znajomości wielu parametrów symulowanego obiektu. Celem programowania obiektowego jest
uzyskanie możliwości wydawania poleceń dla symulowanego obiektu rzeczywistego bez konieczności zagłębiania się
w szczegóły jego konstrukcji czy stanu.
1.2. Przykład symulacji obiektu rzeczywistego
W tej części przedstawiony zostanie prosty przykład opisu obiektu rzeczywistego - samochodu. Widząc samochód
jadący ulicą przeciętny człowiek zwróci uwagę jedynie na ogólne cechy pojazdu, np.: wielkość (duży, mały), kolor
itd. Jadąc samochodem "wydajemy polecenia": przyspiesz, zwolnij, zatrzymaj itd. Opis obiektu rzeczywistego na
poziomie języka programowania powinien umożliwić wydawanie tego typu poleceń. Każdy obiekt rzeczywisty
posiada trzy elementy: tożsamość (nazwa), stan lub cechy obiektu, zachowanie (działania na obiekcie).
Przykładowy samochód jest oczywiście obiektem rzeczywistym złożonym z wielu podzespołów, części i możemy
opisać go bardzo szczegółowo. W wielu zastosowaniach wystarczy nam jednak opis tylko niektórych cech obiektu.
Takie podejście do opisu (pewne cechy są istotne inne są bez znaczenia) określane są w teorii obiektowej mianem
abstrakcji. Programista operuje jedynie na pewnym poziomie abstrakcji niezbędnym do zrealizowania celu
oprogramowania, np. inaczej będzie wyglądał opis obiektu programisty piszącego grę "wyścigi samochodowe", a
inaczej opis do celów symulacji wypadków wykonany dla firmy produkującej samochody. Poniżej przedstawiony
został prosty przykład opisu obiektowego (obiektu - samochodu) demonstrujący zasady tworzenia symulacji
obiektu rzeczywistego.
Prezentowany przykład ogranicza się tylko do elementarnych cech samochodu: marka, model, kolor, pozX (pozycja
X), pozY (pozycja Y) i czterech czynności: ustawMarke, ustawModel, ustawKolor, przesun operujących na cechach.
W terminologii programowania obiektowego cechy opisujące stan obiektu będziemy nazywać polami obiektu (lub
zmiennymi składowymi obiektu) natomiast czynności nazwiemy metodami (lub procedurami i funkcjami
składowymi obiektu).
1. Tożsamość (nazwa) - samochód
2. Stan obiektu (cechy opisujące obiekt):
- Marka
- Model
- Kolor
- Pozycja (współrzędne x i y)
3. Zachowanie (działania na obiekcie):
- Nazwanie marki
- Nazwanie modelu
- Zmiana koloru
- Przesunięcie samochodu - zmiana
położenia (pozycji)
Obiekt rzeczywisty
Opis obiektu
rzeczywistego
class
samochod {
public
:
char
marka[
20
];
char
model[
20
];
int
kolor;
int
pozX, pozY;
samochod();
void
ustawMarke(
char
*s);
void
ustawModel(
char
*s);
void
ustawKolor(
int
k);
void
przesun(
int
x,
int
y);
};
Definicja typu
obiektowego
(Zgodnie ze składnią języka
programowania C++)
Podstawy programowania obiektowego
Strona 3
Po zdefiniowaniu obiektu możemy wykorzystać obiekt w programie głównym. Na początek należy zdefiniować
zmienną obiektową klasy samochod:
samochod car1;
// deklaracja obiektu (utworzenie instancji obiektu)
Następnie w ciele programu głównego możemy wywołać wcześniej zdefiniowane funkcje i procedury obiektu.
Przykładowy program główny symuluje jazdę samochodu po ekranie monitora (kursory: góra, dół, prawo, lewo).
Pełny kod programu definiującego i wykorzystującego obiekt
samochod:
#include <conio.h>
#include <stdio.h>
#include <iostream.h>
#include <string.h>
class
samochod {
public
:
// pola (zmienne)
char
marka[
20
];
char
model[
20
];
int
kolor;
int
pozX, pozY;
// metody (funkcje)
samochod();
// konstruktor
void
ustawMarke(
char
*s);
// ustawienie marki samochodu
void
ustawModel(
char
*s);
// ustawienie marki samochodu
void
ustawKolor(
int
k);
// ustawienie koloru samochodu
void
przesun(
int
x,
int
y);
// przesuniecie po ekranie
};
samochod::samochod()
{
pozX =
0
; pozY =
0
;
}
void
samochod::ustawMarke(
char
*s)
{
strcpy(marka, s);
// kopiowanie parametru do zmiennej marka
cout <<
"Marka:"
<< marka << endl;
}
void
samochod::ustawModel(
char
*s)
{
strcpy(model, s);
// kopiowanie parametru do zmiennej model
cout <<
"Model:"
<< model << endl;
}
void
samochod::ustawKolor(
int
k)
{
kolor = k;
// zmiana zmiennej kolor
textcolor(k);
// zmiana koloru znaku na ekranie
cout <<
"Kolor(nr):"
<< kolor << endl;
}
void
samochod::przesun(
int
x,
int
y)
{
pozX += x; pozY += y;
// zmiana zmiennych pozX i pozY
if
(pozX >
80
) pozX=
1
;
if
(pozY >
25
) pozY=
1
;
Podstawy programowania obiektowego
Strona 4
if
(pozX <
1
) pozX=
80
;
if
(pozY <
1
) pozY=
25
;
gotoxy(pozX, pozY);
// przesuniecie kursora
cprintf(
"%c"
,
'X'
);
}
void
main()
{
int
key;
clrscr();
samochod car1;
// utworzenie obiektu typu samochod
car1.ustawMarke(
"Audi"
);
car1.ustawModel(
"A4"
);
car1.ustawKolor(RED);
car1.przesun(
40
,
12
);
do
{
key = getch();
// pobranie kodu klawisza
switch
(key) {
case
72
: car1.przesun(
0
,-
1
);
break
;
// kody kursorow: gora
case
80
: car1.przesun(
0
,
1
);
break
;
// dol
case
77
: car1.przesun(
1
,
0
);
break
;
// prawo
case
75
: car1.przesun(-
1
,
0
);
break
;
// lewo
}
}
while
(key !=
27
);
// rozne od Esc
textcolor(WHITE);
clrscr();
}
2. Programowanie obiektowe w C++ Builder
2.1. Środowisko programowania pod Windows - C++ Builder
Nowoczesne środowiska programowania pod system Windows takie jak Borland C++ Builder
umożliwiają stworzenie programu okienkowego wykorzystującego gotowe obiekty zdefiniowane
w środowisku graficznym systemu operacyjnego lub w samym środowisku C++Builder. W większości
prostych zastosowań nie będzie konieczne "ręczne" definiowanie własnych obiektów tak jak ma to
miejsce w programowaniu strukturalnym. Większość mozolnej pracy (tworzenie plików, okien,
obiektów kontrolnych itp.) wykonuje za nas środowisko programowania. Proces tworzenia aplikacji
Windows w tego typu środowiskach można ująć w kilku podstawowych etapach:
a) Utworzenie projektu (nazwanie projektu, wskazanie katalogu w którym przechowywane będą
wszystkie pliki składające się na projekt). Na tym etapie tworzone jest (automatycznie) główne
okno aplikacji i główne pliki źródłowe aplikacji.
b) Dodanie obiektów kontrolnych do głównego okna aplikacji (menu, napisy, pola tekstowe,
przyciski itp.).
c) Utworzenie okien dodatkowych posiadających również obiekty kontrolne, które należy
zdefiniować (podobnie jak w głównym oknie aplikacji: patrz pkt. 2 i 3). Okna dodatkowe
najczęściej są aktywowane przez okno główne aplikacji (są aktywowane w metodach obsługi
zdarzeń obiektów kontrolnych), np.: zdarzenie "kliknięcie na przycisku" w głównym oknie aplikacji
spowoduje uruchomienie (aktywowanie) okna dodatkowego.
d) Zdefiniowanie odpowiednich "zdarzeń" i przypisanie ich do obiektów kontrolnych, np.
zdefiniowanie metody (funkcji, procedury), która zostanie wykonana po kliknięciu na przycisku.
e) Skompilowanie i uruchomienie (jeżeli nie ma błędów) oraz przetestowanie działania aplikacji.
Podstawy programowania obiektowego
Strona 5
2.2. Przykład prostej aplikacji w CBuilder - "Ankieta"
Program "Ankieta" będzie umożliwiał przeprowadzenie prostej ankiety osobowej (np. ucznia, studenta)
zawierającej pytania o imię, nazwisko, wiek i klasa. Po wypełnieniu ankiety użytkownik może
wygenerować podsumowanie wykorzystujące dane z ankiety. Podsumowanie zostanie umieszczone w
dodatkowym oknie aplikacji a następnie zapisane do pliku o nazwie wybranej przez użytkownika. Do
zapisania pliku o wybranej nazwie i w wybranym katalogu na dysku można użyć standardowego
obiektu SaveDialog z grupy obiektów Dialogs.
a) Utworzenie projektu
Z menu górnego wybieramy polecenie File - New Application. Następnie polecenie File - Save
Project as.... Otworzy się okno dialogowe w którym wybieramy katalog naszego projektu i nazwę
plików (pliku źródłowego Unit1.cpp - plik okna głównego aplikacji; pliku projektu Project1.bpr). Po
wykonaniu tych czynności utworzy się puste okno główne aplikacji gotowe do edycji o nazwie Form1.
Okno główne aplikacji
Okno zapisu do pliku (okno
standardowe z grupy Dialogs)
Okno dodatkowe aplikacji
Podstawy programowania obiektowego
Strona 6
b) Dodanie obiektów kontrolnych do głównego okna aplikacji
Dodawane obiekty kontrolne możemy wybrać z podręcznego menu obiektów. W głównym oknie
aplikacji "Ankieta" użyjemy obiektów kontrolnych z grupy Standard:
-
Label (tekst statyczny).
-
Edit (pole tekstowe służące do wprowadzania krótkich tekstów).
-
Button (graficzny przycisk)
c) Utworzenie okien dodatkowych - okno "Wynik ankiety"
Aby dodać okno do aplikacji wybieramy polecenie File - New Form. Utworzy się nowy obiekt okna o
nazwie Form2 (plik źródłowy Unit2.cpp). Będzie to drugie okno aplikacji - "Wynik ankiety". W drugim
oknie ("Wynik ankiety") aplikacji użyjemy obiektów kontrolnych z grupy Standard:
-
GroupBox (ramka grupująca obiekty).
-
Memo (pole tekstowe służące do wprowadzania dłuższych tekstów złożonych z kilku linii tekstu).
-
Button (graficzny przycisk) x 2.
Dodatkowo w tym oknie dodamy standardowe okno SaveDialog z grupy Dialogs (poszukać tego
obiektu). Obiekt ten (okno dialogowe zapisu do pliku) będzie nazywał się SaveDialog1.
Dodajemy także przycisk (Button) "Zamknij".
d) Zdefiniowanie zdarzeń i przypisanie ich do obiektów kontrolnych
- zdarzenia w głównym oknie aplikacji
W oknie głównym aplikacji (obiekt Form1 - "Ankieta") zdefiniujemy jedno zdarzenie - kliknięcie na
przycisku "Zapisz do pliku". W tym celu klikamy na przycisku "Zapisz do pliku" - w oknie Object
Inspector pojawią się właściwości obiektu Button. Przechodzimy do zakładki Events (zdarzenia) i
klikamy dwa razy na zdarzeniu OnClick (kliknięcie na obiekcie). Środowisko programistyczne powinno
utworzyć automatycznie metodę obsługi zdarzenia OnClick o nazwie Button1Click. Teraz definiujemy
tą metodę wpisując wewnątrz fragment kodu w języku C++:
Form1->Memo1->Text = Edit1->Text +" nazywa się "+ Edit2->Text +", ma "+
Edit3->Text +" lat i chodzi do klasy " + Edit4->Text;
Form2->ShowModal();
-
Pierwsze polecenie zmienia pole Text obiektu Memo1 okna Form2. W tym poleceniu składamy
tekst obiektu Memo1 odczytując dane (tekst) z pól Edit okna głównego. Każdy obiekt typu Edit
posiada pole Text przechowujące dane wpisane do obiektu, np.: Edit1->Text przechowuje tekst
wpisany w obiekcie Edit1 (imię ankietowanego).
-
Drugie polecenie uaktywnia drugie okno w trybie modalnym.
Wszystkie okna systemu Windows mogą pracować w dwóch podstawowych trybach:
-
Modalnym (aktywacja procedurą ShowModal),
-
Standardowym lub niemodalnym (aktywacja procedurą Show),
Label
Edit
Button
Button
Memo
GroupBox
Podstawy programowania obiektowego
Strona 7
- zdarzenia w oknie "Wynik ankiety"
W oknie dodatkowym aplikacji (obiekt Form2 - "Wynik ankiety") zdefiniujemy jedno zdarzenie -
kliknięcie na przycisku "Podsumowanie". W tym celu klikamy na przycisku "Podsumowanie" - w oknie
Object Inspector pojawią się właściwości obiektu Button. Przechodzimy do zakładki Events
(zdarzenia) i klikamy dwa razy na zdarzeniu OnClick (kliknięcie na obiekcie). Środowisko
programistyczne powinno utworzyć automatycznie metodę obsługi zdarzenia OnClick o nazwie
Button1Click. Teraz definiujemy tą metodę wpisując wewnątrz fragment kodu w języku Delphi:
if (SaveDialog1->Execute()) Memo1->Lines->SaveToFile(SaveDialog1->FileName);
Obiekt SaveDialog posiada metodę Execute, która uruchamia okno dialogowe wyboru pliku na
dysku. Po zakończeniu działania okna w polu (zmiennej) FileName przechowywana jest pełna
(z pełną ścieżką dostępu) nazwa wybranego pliku. Metoda SaveToFile zapisuje tekst obiektu Memo
do wybranego pliku.
W oknie "Wynik ankiety" znajduje się (patrz: punkt c) przycisk "Zamknij". Dla tego przycisku
definiujemy pole (właściwość) ModalResult równe mrOk. MrOk jest jednym z kilku poleceń okna
otwartego w trybie modalnym i powoduje "potwierdzenie" działań wykonanych w oknie. W naszym
przykładzie spowoduje zamknięcie okna.
e) Skompilowanie, uruchomienie i przetestowanie aplikacji
Po wykonaniu wszystkich wyżej opisanych działań możemy skompilować i uruchomić aplikację. W tym
celu wybieramy polecenie z menu górnego Run - Run. Następnie należy sprawdzić czy wszystkie
zaprogramowane działania wykonują się poprawnie:
-
wypełniamy ankietę,
-
klikamy przycisk "Podsumowanie",
-
klikamy przycisk "Zapisz do pliku" okna "Wynik ankiety",
-
wybieramy katalog i podajemy nazwę pliku do którego chcemy zapisać dane - polecenie "Zapisz"
okna SaveDialog,
-
teraz można pozamykać okna i zakończyć działanie aplikacji,
-
korzystając z dowolnego edytora tekstowego systemu Windows (np. Notatnik) sprawdzamy: czy
został poprawnie utworzony plik tekstowy i czy zawiera poprawny tekst wynikowy ankiety.
2.3. Zadanie do samodzielnego wykonania - "Prosta przeglądarka
graficzna"
Utworzyć program (aplikację) Windows:
Obiekt
Image
Menu górne
obiekt typu
Menu
Grafika
umieszczona
w obiekcie
Image
Wyszukiwarka
Podobne podstrony:
więcej podobnych podstron