Wstęp
do programowania
Wykład 9  klasy, moduły
Moduły
Napisane funkcje lub procedury przez np.. Użytkownika mogą być połączone
w jeden moduł, z którego można korzystać w wielu aplikacjach.
Reguły tworzenia modułów
" Nazwa pliku, w którym znajduje się moduł powinna być taka sama jak
nazwa modułu.
" Moduł składa się z części opisowej, implementacyjnej i inicjującej. Część
inicjująca musi się kończyć kropką.
" Stosowanie modułów powoduje, że właściwe programy są znacznie
krótsze, bardziej przejrzyste i czytelne.
" Dzięki temu, że moduły przechowywane są w postaci skompilowanej w
trakcie kompilacji programu definicje zawarte w modułach są
do programu wynikowego dołączane a zatem kompilacja programu
przebiega szybciej. (rozszerzenie .pas w delphi)
Moduły
Fragment modułu umieszczony pomiędzy słowami interface i
implementation jest częścią publiczną, a pomiędzy słowami
implementation oraz end . jest tzw. częścią prywatną modułu,
W programach, w których zadeklarowano chęć korzystania z modułu
dostępne są tylko definicje umieszczone w części publicznej;
żaden typ, zmienna lub stała umieszczona w części prywatnej nie
jest dostępna w programie.
" Wszystkie definicje funkcji i procedur, niezależnie od tego czy mają
być dostępne w programie czy nie muszą być umieszczone
w części prywatnej. Procedura lub funkcja staje się publiczna gdy jej
nagłówek zostanie umieszczony w części publicznej modułu.
Moduły
Liczba modułów, z których może składać się program jest praktycznie
nieograniczona.
" Jeśli jeden moduł korzysta z innego to istotna jest kolejność nazw na
liście deklarowanych modułów. Moduł wykorzystywany powinien
znajdować się przed wykorzystującym.
" Nazwy występujące w programie są nadrzędne w stosunku do tych
występujących w modułach. Przesłonięte identyfikatory z modułu
są dostępne w programie jeśli są poprzedzone nazwą modułu i
kropkÄ….
Dołączanie modułów w programie za
pomocą słowa kluczowego uses
Moduły
program modul_dpr;
uses
Unit Unit1
SysUtils, System
Unit1 in 'Unit1.pas';
Interface
Część
pubiczna
Implementation
Część
prywatna
End.
unit modul1;
interface
Moduły -
const n = 2; Type Tab=array[1..N,1..N] of
użyj aplikacji
Integer;
units
procedure gener(var T:Tab );
procedure wypisz( T:Tab );
Program pr_modul1;
Implementation
uses
procedure gener( var T:Tab);
SysUtils,
var i,j:byte;
modul in 'modul1.pas';
Begin for i:=1 to N do
var a: Tab;
for J:=1 to N do T[i,j]:=random(10);
Begin
end;
gener(A );
procedure wypisz(T: Tab );
wypisz(A);
var i,j:byte;
readln;
Begin
end.
for i:=1 to N do
for j:=1 to N do
if j< N then write (T[i,j]:4,' ') else writeln
(T[i,j]:4)
end; end.
Moduły
Projekt w Lazarusie składać się może formularzy, modułów.
Projekt w Delphi składa się z plików:
Øðplik główny projektu (lpr)
plik zawierający informacje o formularzach i modułach aplikacji zawiera
kod inicjujÄ…cy
Øðpliki modułów (pas) - kody z
ródłowe modułów
Øðpliki formularzowe (lfm)
Øðplik zasobów (lrs)
Øðplik informacyjny (lpi)
Klasy
Klasa jest złożoną strukturą danych rozbudowaną o funkcje składowe.
Obiektem nazywamy konkretny egzemplarz danej klasy.
W skład klasy wchodzą: dane (zmienne) składowe, funkcje składowe
(metody), w tym konstruktory i destruktory.
Klasę deklaruje się przy użyciu słowa kluczowego class, np:
type Tnazwa_Klasy=class & end;
W dobrym stylu jest nadawanie klasie nazwy z dużej litery T.
Elementy klasy sÄ… podzielone na sekcje: publicznÄ… i prywatnÄ…,
chronionÄ….
Elementy te mogą być deklarowane w dowolnej liczbie występujących
po sobie sekcji wydzielonych przez etykiety public lub private
Elementy klasy są domyślnie prywatne. Metod i zmiennych publicznych
klasy można używać wszędzie w programie, natomiast do metod i
zmiennych prywatnych dostęp mają tylko inne metody klasy.
Klasa powinna być abstrakcyjnym typem danych, czyli takim, który raz
zaprojektowany może być używany przez innych programistów bez
konieczności wgłębiania się w jego mechanizm.
Klasy
Sekcja publiczna deklaracji klasy nazywana jest interfejsem klasy. zawarte
w niej metody wraz opisami ich parametrów, działanie i format wyniku
powinny dawać programiście minimum informacji na temat klasy
Według zasady abstrakcyjności danych, wszystkie dane składowe klasy
powinny znajdować się w sekcji prywatnej.
W sekcji publicznej należy umieszczać metody operujące na danych
prywatnych.
Jeśli metoda publiczna wykonuje wiele obliczeń lub pewne z nich
wykonywane są przez wiele metod publicznych, to można je wyodrębnić w
postaci osobnej metody prywatnej. Są one wtedy wyłącznie na użytek
implementacji klasy.
Implementacja klasy powinna być zaprojektowana przez programistę w
sposób, który daje mu możliwość rozbudowania i udoskonalania działania
funkcji jej składowych, bez wprowadzania jakichkolwiek zmian w interfejsie.
Dostęp do danych i funkcji składowych obiektu uzyskujemy przez użycie
operatora dostępu:  . ,
Klasy
Klasa  jest wzorcem czyli typem dla swoich zmiennych, czyli
obiektów
Obiekt  jest zmiennÄ… swojej klasy
Programowanie obiektowe - programowanie, w którym klasy
stanowią najważniejszą część w konstrukcji programu.
Podstawowe własności programowania obiektowego:
- dziedziczenie
- hermetyzacja
- polimorfizm
- rozszerzalność
Klasy
Dziedziczenie  jest własnością umożliwiającą klasie pochodnej uzyskanie
pól i metod swoich klas rodzicielskich,
" Jest możliwością tworzenia klas jako potomnych od klas rodzicielskich.
" Klasy potomne dziedziczą charakterystyki i działania klasy rodzic.
" Klasy pochodne  definiowane własności i operacje oraz mogą zmieniać
operacje odziedziczone.
Dziedziczenie
Budowa jednej klasy na bazie drugiej, przez dodawanie/przesłanianie jej
składowych:
Klasy
Hermetyzacja - własność, która pozwala na łączenie danych z metodami w
obrębie obiektu; zwana inaczej Enkapsulacją.
Polimorfizm - własność dzielenia pojedynczego działania i nazwy działania
poprzez hierarchię obiektową w sposób właściwy dla każdego obiektu w
tej hierarchii.
Polimorfizm  pozwala każdej klasie na posiadanie własnych potrzeb,
metody te zapewniajÄ… jednolitÄ… odpowiedz
na komunikaty dochodzÄ…ce do
żądanych klas w hierarchii, umożliwia obiektom generowania własnych
odpowiedzi na podobne komunikaty.
Rozszerzalność - własność pozwalająca rozszerzać i uaktualniać moduły już
skompilowane
Klasy Sekcje klasy
public (publiczne)  definiuje pola i metody, które są dostępne z dowolnego
miejsca programu oraz z modułu, w którym zostały zdefiniowane
private (prywatne)  definiuje pola i metody klasy, które są niedostępne spoza
modułu (pliku kodu z
ródłowego), w którym zdefiniowano klasę
protected (chronione)  definiuje pola i metody klasy, które są widoczne tylko
dla danej klasy i jej klas pochodnych (wykorzystywane w dziedziczeniu)
type
TFigura = class
private
bok: byte;
sekcja prywatna
podstawa: 1..100;
procedure wypisz;
protected
kat: integer;
sekcja chroniona
ile_pr: 0..2;
function pole(a,b:byte): Integer;
public
nazwa :string sekcja publiczna
procedure init;
procedure free;
end;
program PR_KONSTR1;
Klas  to pola i metody 
przykład cd. W1.15XII
type
TProstokat = class
a, b :Integer; //wymiary prostokata
function obwod :Integer;
function pole:Integer;
end;
function TProstokat.obwod:Integer;
begin Result := (a+b)*2; end;
function TProstokat.pole:Integer;
begin Result := a*b; end;
Var Pro1, Pro2: TProstokat;
Begin
Pro1:= Tprostokat.Create;
Pro1.a := 4; Pro1.b := 2;
// pro2.a:=10; pro2.b:=20; // bład! -Brak create
writeln('obwod= ',Pro1.obwod);
writeln('Pole = ',Pro1.pole);
//writeln('Pole 2= ',Pro2.pole);
Pro1.Free;
readln; end.
Klas  to pola i metody -
program PrKONSTR2;
przykład
type
Var Pro1 :TProstokat;
TProstokat = class
a, b :Integer; //wymiary prostok tro1:Trojkat;
function obwod :Integer;
function pole:Integer;
Pro1:=TProstokat.Create;
end;
//obowiazkowe
function TProstokat.obwod:Integer;
Pro1.a := 5;
begin Result := (a+b)*2; end;
Pro1.b := 7;
function TProstokat.pole:Integer;
writeln('obwod pr= ',Pro1.obwod);
begin Result := a*b; end;
writeln('Pole pr= ',Pro1.pole);
readln;
type
Trojkat = class Tro1:=Trojkat.Create;
a, b,c :Integer; //wymiary
tro1.a := 2;
function obwod :Integer;
tro1.b := 3;
function pole:Integer;
tro1.c := 4;
end;
writeln('obwod tr= ',tro1.obwod);
writeln('Pole tr= ',tro1.pole);
function Trojkat.obwod:Integer;
begin Result := (a+b+c); end;
Pro1.Free; //obowiazkowe
function Trojkat.pole:Integer;
Tro1.Free; //obowiazkowe
begin Result := a*(b+c) div 2; end;
readln; end.
Klasa  dostęp pól klasy
program PrKonstr3;
type
TProstokat = class
Var Pro1 :TProstokat;
a :Integer; //wymiary prostok
begin
procedure ustaw(_d:integer);
Pro1:=Tprostokat.Create;
function wypisz:integer;
Pro1.a := 4; Pro1.b := 2;
private
Pro1.c := 50;
d: integer;
//Pro1.d := 1; //w module mozna
protected
b: integer;
writeln('a= ',Pro1.a);
public
writeln('b = ',Pro1.b);
c:integer;
writeln('c = ',Pro1.c);
end;
Pro1.ustaw(100);
procedure TProstokat.ustaw(_d:integer);
writeln('d=',Pro1.Wypisz);
begin
readln;
d:=_d;
end;
Pro1.Free
function TProstokat.wypisz:integer;
end.
begin
Result:=d;
end;
Klasy  konstruktor, destruktor
żðkonstruktor Create tworzy obiekt (przydziela wymaganÄ…
pamięć)
żðdestruktor Free zwalnia przydzielonÄ… pamięć
żðklasa może zawierać wiÄ™cej niż jeden konstruktor, a powinna
zawierać jeden destruktor
żðkonstruktor powinien być wywoÅ‚any jako pierwsza metoda dla
nowego obiektu
żðwywoÅ‚aniu destruktora koÅ„czy pracÄ™ z obiektem, aby
ponownie korzystać z obiektu należy wywołać konstruktor
Klasy  konstruktor, destruktor
żðUżycie konstruktora Create jest obowiÄ…zkowe dla każdego
egzemplarza klasy (przydziela wymaganą pamięć)
Np.. TABC=class..
var ob1 : TABC
ob1:=TABC.Create;
żðUżycie destruktor Free jest obowiÄ…zkowe dla każdego
Egzemplarza klasy (zwalnia przydzieloną pamięć)
Np.. ob1.Free;
program Pr_Constructor4;
Klasy 
Type TProst=class
konstruktor, destruktor
x,y: integer ;
a,b :integer; {bok}
constructor Create;
destructor Free;
function pole:longint;
end;
constructor TProst.Create;
begin Inherited Create;
a:=20; b:=4; end;
destructor Tprost.Free;
begin Inherited Free; {koniec pracy z TKwadrat} end;
function TProst.pole:longint;
begin Result:= a * b; end;
var Pkat :TProst;
BEGIN
Pkat:=Tprost.Create;
writeln('Pole prostokata: ', Pkat.pole);
Pkat.a:=100;
writeln('Pole prostokata: ', Pkat.pole);
Pkat.Free;
readln; END.
program pr_konstruktor5; {constructor i destructor}
Klasy 
Type TProst=class
a,b :integer; {bok}
konstruktor, destruktor
constructor Create(_a,_b :integer);
destructor Destroy;
function pole:longint;
end;
constructor TProst.Create(_a, _b:Integer);
begin Inherited Create; //obowiazowe
a:=_a;
b:=_b;
writeln('Konstruktor TProst'); end;
destructor TProst.Destroy;
begin writeln('Destruktor - Koniec pracy z TProst');
Inherited Destroy; end;
function TProst.pole:longint;
begin pole:= a * b; end;
var P1 ,p2:TProst;
BEGIN
P1:= Tprost.Create(20,?);
p2:= Create(4,7);
writeln(' Pole prostokata : ', P1.pole);
P1.Destroy; //Pkat.Free;
p2.Destroy;
readln; END.
Klasy  konstruktor, destruktor
program PrKonstr6
uses SysUtils;
type
procedure TFig.wypisz;
TFig = class
Begin writeln( 'bok = ', bok^);
bok: ^byte;
end;
constructor Create(x:byte); overload;
constructor Create; overload;
destructor Free;
function Tfig.pole: Integer;
procedure wypisz;
begin
function pole: Integer;
Result:=bok^*bok^;
end;
end;
constructor TFig.Create;
var Kwadrat: TFig;
begin New( bok ); end;
begin
constructor TFig.Create( x:Byte );
begin
Kwadrat := TFig.Create( 5 );
Create;
bok^ := x;
Kwadrat.wypisz;
end;
Writeln(Kwadrat.pole)
destructor TFig.Free;
Kwadrat.Destroy;
begin
end.
Dispose( bok );
end;
Jeżeli nie zdefiniujemy żadnego
Typy konstruktorów
konstruktora, kompilator wykorzysta
konstruktor klasy TObject
Program konstruktory;
-wyróżniamy trzy rodzaje
{}
konstruktorów:
type
a) domyślny (bez parametrów)
TPot = class
b) zwykły (z parametrami, może być
private
wiele takich konstruktorów)
x, y: Integer;
public
c) kopiujÄ…cy
constructor Create; overload;
Instrukcja przypisania tylko nazwÄ™ i
//domyślny
adres obiektu.
constructor Create( dx, dy: Integer );
overload; //zwykÅ‚y vðJeÅ›li zadeklarujemy jakikolwiek
konstruktor pobierajÄ…cy parametry,
musimy także zadeklarować
constructor Create( const dxy: TPot );
konstruktor domyślny
overload; //kopiujÄ…cy
(bezparametrowy).
vðPrzy definicji konstruktora
end;
domyślnego pożądane jest
inicjalizowanie danych.
Klasy  konstruktory
Program PrKonstr7;
var a, b, c, d : TPot;
type begin
TPot = class
a := TPot.Create;
private
b := TPot.Create( 7,13 );
x, y: Integer;
c := TPot.Create( b );
public
//d := TPot.Create;
constructor Create; overload;
d:=b; //od wskaz
nika
constructor Create( dx, dy: Integer );
writeln(' a: ',a.x,' ',a.y);
overload;
writeln(' b: ',b.x,' ',b.y);
constructor Create( const DK: TPot );
writeln(' c ',c.x,'  ,c.y);
overload;
end; writeln(' d ',d.x,' ',d.y);
constructor TPot.Create;
Begin inherited Create;
a.Free;
x := 1; y := 0; end;
b.Free;
constructor TPot.Create(dx, dy: Integer);
c.Free;
Begin inherited Create;
d.Free; //ten sam co b bo d=b
x := dx; y := dy; end;
Readln
constructor TPot.Create(const DK: TPot);
end;.
Begin inherited Create;
x := DK.x; y := DK.y; end;