Politechnika Świętokrzyska w Kielcach Wydział Elektrotechniki, Automatyki i Informatyki
Laboratorium Podstaw Programowania 2
Lab. nr 11
Data wykonania ćwiczenia : 20.05.2012
1.Przemysław Wolski

1. Wstęp Teoretyczny

Dotychczas tworzone przez nas programy były programami strukturalnymi. Oznacza, to że kod tych programów był podzielony na podprogramy działające na

określonych przez nas zmiennych. Przepływ sterowania pomiędzy tymi podprogramami, czyli kolejność w jakiej są one wywoływane jest określona jawnie. Podejście

strukturalne, mimo wielu zalet, takich jak prostota zapisu programu, możliwość wielokrotnego wykorzystania kodu, ma też liczne wady. Do najpoważniejszych należą

oddzielenie kodu od danych na których przeprowadza on operacje oraz ubogi mechanizm kontroli widoczności zmiennych. Pierwsza z nich powoduje, że pisząc program

myślimy o rozwiązywanym problemie nie w kategoriach tego problemu, ale w kategoriach języka programowania, który służy nam do zapisania kodu programu (np.:

„wywołaj funkcję wyszukującą w tablicy rekord zawierający dane studenta o określonym nazwisku”). Ponadto, jeśli swój kod udostępnimy innym programistom, np.:

w postaci biblioteki, to może się okazać, że zignorują oni napisane przez nas funkcje i procedury i będą bezpośrednio odwoływać się do zmiennych i struktur danych lub

będą niewłaściwie posługiwać się stworzonymi przez nas podprogramami. W obu przypadkach takie działanie może skończyć się katastrofą. Druga wada wiąże się

z opisanym przed chwilą zagrożeniem, jak również wprowadza nowe – w kodzie dużych programów, tworzonych na potrzeby dużych projektów informatycznych bardzo

trudno jest zapanować nad nazwami zmiennych, co bardzo często prowadziło do załamania się prac nad takimi projektami i przynosiło firmom ogromne straty1.

Odpowiedzią specjalistów od inżynierii oprogramowania na te problemy było wprowadzenie nowej metodologii tworzenia programów, którą nazwano techniką

obiektową. To pojęcie obejmuje trzy osobne zagadnienia: analizę obiektową (ang. OOA = Object Oriented Analysis), projektowanie obiektowe (ang. Object Oriented

Design) i programowanie obiektowe (ang. Object Oriented Programming). Ten wykład będzie obejmował ostanie zagadnienie, do dwóch pierwszych wrócimy innym

razem. Z pojęciem obiektowości wiąże się pojęcie abstrakcyjnych typów danych, z którym spotkaliśmy się przy okazji omawiania dynamicznych struktur danych. Takim

typem był np.: stos. Aby go zdefiniować musieliśmy określić typ pojedynczego elementu takiego stosu (typ bazowy stosu) i operacje, które możemy na tych elementach

przeprowadzać. Zgodnie z tym co zostało napisane wyżej, programista korzystający z naszego kodu może te operacje ominąć implementując ich własne wersje.

Programowanie obiektowe idzie o krok dalej: pozwala zadeklarować zmienne i związać z nimi operacje, tak, aby nie można ich było rozdzielić. W dużym uproszczeniu

można określić programowanie obiektowe jako programowanie polegające na deklarowaniu nowych typów danych, opisujących pojęcia właściwe dla rozwiązywanego

problemu. Takie typy danych będziemy nazywać klasami, a zmienne tych typów – obiektami.

2. Przebieg laboratorium

Zadanie 1.

Utwórz klasę Zarowka. Klasa powinna zawierać metody:

 zapalZarowke(), która będzie wyświetlała napis: „Żarówka zapalona”;

 zgasZarowke(),która będzie wyświetlała napis: „Żarówka zgaszona”;

 rozjasnijZarowke()która będzie wyświetlała napis: „Żarówka rozjaśniona”;

 przyciemnijZarowke()która będzie wyświetlała napis: „Żarówka przyciemniona”.

Program lab10zad1; uses crt,LAB; var p:Zarowka; begin clrscr; p.zapalZarowke; p.zgasZarowke; p.rozjasnijZarowke; p.przyciemnijZarowke; readln; end.

Treść zadania wykorzystującego moduł LAB Początek programu głównego Wywołanie procedur.

unit LAB; interface type Zarowka = object procedure zapalZarowke; procedure zgasZarowke; procedure rozjasnijZarowke; procedure przyciemnijZarowke; end; implementation procedure Zarowka.zapalZarowke; begin writeln('Zarowka zapalona'); end; procedure Zarowka.zgasZarowke; begin writeln('Zarowka zgaszona'); end; procedure Zarowka.rozjasnijZarowke; begin writeln('Zarowka rozjasniona'); end; procedure Zarowka.przyciemnijZarowke; begin writeln('Zarowka przyciemniona'); end; end.

Moduł LAB Zdefiniowanie obiektu z 4 metodami. Implementacja metod modułu. Procedura wyświetlająca napis o treści "Żarówka zapalona" Procedura wyświetlająca napis o treści "Żarówka zgaszona" Procedura wyświetlająca napis o treści "Żarówka rozjaśniona" Procedura wyświetlająca napis o treści "Żarówka przyciemniona" Koniec modułu.

Zadanie 2.

Utwórz klasę Punkt, która będzie zawierać współrzędne punktu (x, y). Klasa ta powinna zawierać metody:

 ustawX(), która będzie ustawiała wartość współrzędnej punktu X;

 pobierzX(), która będzie zwracała przechowywaną wartość współrzędnej punktu X;

 ustawY(), która będzie ustawiała wartość współrzędnej punktu Y;

 pobierzY(), która będzie zwracała przechowywaną wartość współrzędnej punktu Y;

 wyswietlWspolrzędne(), która będzie wyświetlać współrzędne punktu X i Y.

program zad2; uses crt,LAB2; var z:Punkt; begin clrscr; z.ustawX(3); z.ustawY(5); z.wyswietlWspolrzedne(z.pobierzX,z.pobierzY); end.

Program wykorzystujący moduł LAB2 Ustawienie wartości X na "3" Ustawienie wartości Y na "5" Wyświetlenie obu liczb jako współrzędnych punktu.

unit LAB2; interface type Punkt = object x,y:integer; procedure ustawX(wX:integer); function pobierzX:integer; procedure ustawY(wY:integer); function pobierzY:integer; procedure wyswietlWspolrzedne(d,c:integer); end; implementation procedure Punkt.ustawX(wX:integer); begin x:=wX; end; function Punkt.pobierzX:integer; begin pobierzX:=x; end; procedure Punkt.ustawY(wY:integer); begin y:=wY; end; function Punkt.pobierzY:integer; begin pobierzY:=y; end; procedure Punkt.wyswietlWspolrzedne(d,c:integer); begin writeln('Wspolrzedne: ',d,',',c); readln; end; end.

Zdefiniowanie obiektu "Punkt" O polach x i y, oraz 5 metod Procedura ustawiająca wartość wpisaną w programie wykorzystującym moduł na X. Funkcja pobierająca wartość z procedury ustawX i przekazuje do procedury wyświetlającej. Procedura ustawiająca wartość wpisaną w programie wykorzystującym moduł na Y. Funkcja pobierająca wartość z procedury ustawY i przekazuje do procedury wyświetlającej. Procedura wyświetlająca współrzędne punktu.

Zadanie 3.

Utwórz klasę, której obiekt będzie mógł wykonywać następujące operacje na liczbach zespolonych :

1. Wyświetlanie liczby zespolonej w postaci a+jb;

2. Obliczanie liczby sprzężonej do danej liczby zespolonej;

3. Obliczanie modułu liczby zespolonej;

4. Obliczanie kąta liczby zespolonej;

5. Dodawanie do jednej liczby zespolonej drugiej liczby zespolonej. Wynik należy zapisać w obiekcie wywołującym metodę np.: a.dodaj(b) wynik w a.

6. Odejmowanie od jednej liczby zespolonej drugiej liczby zespolonej. Wynik należy zapisać w obiekcie wywołującym metodę np.: a.odejmij(b) wynik w a.

7. Mnożenie jednej liczby zespolonej przez drugą liczbę zespoloną. Wynik należy zapisać w obiekcie wywołującym metodę np.: a.mnoz(b) wynik w a.

8. Dzielenie jednej liczby zespolonej przez drugą liczbę zespoloną. Wynik należy zapisać w obiekcie wywołującym metodę np.: a.dziel(b) wynik w a.

Klasa zawiera:

Pola:

 Re

 Im

Metody:

 ustawRe()

 pobierzRe()

 ustawIm()

 pobierzIm()

 sprzezona()

 obliczModul()

 obliczKat()

 wyswietlLiczbeZesp()

 dodaj()

 odejmij()

 mnoz()

 dziel()

 drukuj()

program zad2; uses crt,LAB3; var z:Zespolona; Re,Im,Re2,Im2:integer; begin clrscr; textcolor(yellow); write('podaj liczbe rzeczywista: '); readln(Re); write('podaj liczbe urojona: '); readln(Im); z.ustawRe(Re); z.ustawIm(Im); textcolor(green); writeln('Pierwsza liczba zespolona: '); z.drukuj(Re,Im); textcolor(white); writeln('Modul: ',z.obliczModul(Re,Im):4:2); writeln('Kat liczby zespolonej: '); z.obliczKat(Re,Im); z.sprzezona(Re,Im); textcolor(yellow); write('podaj 2 liczbe rzeczywista: '); readln(Re2); write('podaj 2 liczbe zespolona: '); readln(Im2); textcolor(green); writeln('Druga liczba zespolona: '); z.drukuj(Re2,Im2); textcolor(white); z.dodaj(Re,Im,Re2,Im2); z.odejmij(Re,Im,Re2,Im2); z.mnoz(Re,Im,Re2,Im2); z.dziel(Re,Im,Re2,Im2); readln; end.

Program wykorzystujący moduł LAB3 Deklaracja liczby pierwszej i liczby drugiej. Wczytywanie pierwszej liczby. Ustawienie wpisanej wartości. Wyświetlenie liczby zespolonej. Wyświetlenie modułu. Wyświetlenie kąta. Wczytanie drugiej liczby. Wyświetlenie 2 liczby zespolonej. Operacje kolejno: dodawania, odejmowania, mnożenia, dzielenia.

unit LAB3; interface type Zespolona = object Re,Im:integer; procedure ustawRe(wX:integer); function pobierzRe:integer; procedure ustawIm(wY:integer); function pobierzIm:integer; procedure sprzezona(x,y:integer); function obliczModul(x,y:integer):real; procedure obliczKat(x,y:integer); procedure dodaj(x,y,c,v:integer); procedure odejmij(x,y,c,v:integer); procedure mnoz(x,y,c,v:integer); procedure drukuj(x,y:integer); procedure dziel(x,y,c,v:integer); end; implementation procedure Zespolona.ustawRe(wX:integer); begin Re:=wX; end; function Zespolona.pobierzRe:integer; begin pobierzRe:=Re; end; procedure Zespolona.ustawIm(wY:integer); begin Im:=wY; end; function Zespolona.pobierzIm:integer; begin pobierzIm:=Im; end; procedure Zespolona.sprzezona(x,y:integer); begin writeln('Liczba sprzerzona: ',x,'-',y,'j'); end; function Zespolona.obliczModul(x,y:integer):real; begin obliczModul:=sqrt(x*x+y*y); end; procedure Zespolona.obliczKat(x,y:integer); var modu:integer; begin modu:=(x*x+y*y); writeln('sin FI= ',x/modu:4:2); writeln('cos FI= ',y/modu:4:2); end; procedure Zespolona.dodaj(x,y,c,v:integer); begin writeln('Suma to: ',x+c,'+',y+v,'j'); end; procedure Zespolona.odejmij(x,y,c,v:integer); begin if y-v>=0 then writeln('Roznica to: ',x-c,'+',y-v,'j') else writeln('Roznica to: ',x-c,'',y-v,'j'); end; procedure Zespolona.mnoz(x,y,c,v:integer); var m1,m2,m3:integer; begin m1:=-1*(y*v); m2:=x*y+m1; m3:=c*y+x*v; if m3>=0 then writeln('Iloczyn: ',m2,'+',m3,'j') else writeln('Iloczyn: ',m2,'',m3,'j'); end; procedure Zespolona.drukuj(x,y:integer); begin if y>=0 then writeln(x,'+',y,'j') else writeln(x,'',y,'j'); end; procedure Zespolona.dziel(x,y,c,v:integer); begin writeln('Iloraz to: ',x / c:4:1,'+',y / v:4:1,'j') end; end.

Zdefiniowanie obiektu o polach Re i Im i dwunastu metodach. Procedura ustawiająca liczbę Re. Funkcja pobierająca Re z ustawRe i przypisująca do nazwy funkcji. Procedura ustawiająca liczbę Im. Funkcja pobierająca Im z ustawIm i przypisująca do nazwy funkcji. Procedura wyświetlająca liczbę sprzężoną. Funkcja obliczająca moduł. Procedura obliczająca i wyświetlająca kąt . Procedura dodająca 2 liczby zespolone. Procedura odejmująca 2 liczbę zespolone. Procedura mnożąca 2 liczby zespolone i wyświetlająca wynik. Procedura drukująca liczbe zespoloną. Procedura dzieląca 2 liczby rzeczywiste.

3. Wnioski

W prezentowanych przykładach pokazano niewielką część możliwości programowania obiektowego. Idea ta pozwala bardziej zbliżyć się do przestrzeni rozwiązywanego

problemu, gdyż operujemy pojęciami właściwymi temu problemowi. Możemy np.: stworzyć obiekt przechowujący inne obiekty, które przechowują informację

o studentach i wysłać do niego komunikat: „znajdź studenta o podanym nazwisku”. Po nabraniu pewnej wprawy kod programu obiektowego staje się bardziej czytelny

i łatwy do zrozumienia niż kod programu strukturalnego. Na następnych wykładach dowiemy się również, że programowanie obiektowe pozwala na znacznie lepsze

ponowne wykorzystanie kodu, niż programowanie strukturalne.