Transcript 3. Objektorientētas programmēšanas pamati (Lekcijas

Objektorientētas
programmēšanas pamati
Objektorientētā programmēšana
(OOP) - tā ir programmu izstrādāšanas
metodika, kuras pamatā ir jēdziens
objekts. Objekts - tas ir daža struktūra,
kas ir attiecīga reālas pasaules
objektam, viņa uzvedībai.
Pamatjēdzieni un principi ООP.
Objektorientētā programmēšana turas uz
četriem pamatjēdzieniem: abstrakcija,
pārmantojamība, iekapsulēšana un
polimorfisms. Īsi apstāsimies uz katra
no jēdzieniem.
Abstrakcija
Abstrakcija noslēdzas ārēju objekta īpašību
priekšstatā bez viņa iekšējās organizācijas un
konkrētas realizācijas uzskaites. Abstrakcija –
tā ir programmēšanas valodas spēja aprakstīt
apkārtējas pasaules objektus ietvaros liktā
uzdevuma. Ar objektu, kurš ir pakļauts
aprakstam, var būt viss ko vēlies: cilvēks, ēka,
automobilis un tā tālāk. No redzes viedokļa
konkrēta uzdevuma mūs parasti neinteresē
visi objekta raksturojumi.
Ja mēs aprakstām cilvēku kā bankas klientu
ienešanas procesa automatizācijai uz kontu
un dažu summu noņemšanu no konta, mēs
diez vai interesēs tādas cilvēka īpašības, kā
svaru, augšanu, rakstura tipu, acu un matu
krāsu. Mums ievajadzēsies konta numurs,
naudas daudzums, dati, kas apstiprina
personību, mājas adresi u.t.t.
Visticamāk, mēs nosauksim šo objektu
«Klients», un ar zem tā apkopoto nosaukumu
pacentīsimies vākt visus raksturojumus
(īpašības) banku dokumentācijas pareizai
noformēšanai. Bez tam, mēs pacentīsimies
izcelt un nokārtot darbības, kuras notiek ar šo
objektu noņemšanas vai ienešanas naudas
laikā, aprakstīsim visu to programmēšanas
valodas termiņos.
Rezultātā mēs saņemsim dažu klienta
apkopoto tipu, kam ir parametru tipi, kuri ir
kopīgi visiem klientiem, un mākošs izmainīt
šos parametrus ar tēlu, kurš ir kopīgs visiem
klientiem.
Programmēšanas valodas spēja pārvest
reālas pasaules parādības abstraktos
objektos ar to īpašībām un uzvedību (tas ir
radīt klases) un dēvējas ar abstrakciju.
Reālas pasaules jebkuru objektu pārvedumā
programmēšanas valodas terminos parasti apraksta
divas bāziskas lietas:
• ka šis objekts no sevis iedomājas, kādi viņam ir
esamas īpašības un kādā daudzumā. Ar citiem
vārdiem pārrakstās objekta (dati var būt atšķirīgu
tipu) dati un šie apraksti dēvējas ar objekta
laukiem;
• kā objekts uzvedas, kādas darbības viņš ir
spējīgs veikt tajā vai citā situācijā, kā objekts var
manipulēt ar savējiem laukiem, un kādas reakcijas
uz ārējām īsziņām viņš var nodrošināt. Šīs darbības
pārrakstās ar procedūrām un funkcijām, kuras
saņēma nosaukumu objekta metodes.
Pārmantojamība
Pārmantojamību pārstāv objektu hierarhijas
būves princips no kopīgāka un vienkārša pie
daudz konkrētam un sarežģītam. Salīdzinot
atšķirīgu reālu objektu īpašības, var izcelt
īpašību grupu, kas ir vienādas tiem visiem.
Tad ir jēgu radīt klasi-sencis (vecāki), kurā
apvienot laukus un metodes, kas ir kopīgi
atšķirīgiem objektiem, bet no šīs klases radīt
citas klases ar savējo specifiku, pie tam katra
radāmā klase manto visus laukus un vecāku
klases metodes.
Viena objekta spēja būt radītam no
cita objekta, uzņemot visas viņa
īpašības un uzvedību, dēvējas ar
pārmantojamību.
Pārmantojamība pakļaujas dažiem likumiem
un ir savējā terminoloģija:
• objekts, no kura ir radāms cits objekts,
dēvējas ar bāzisku klasi, vecāku klasi vai
senci;
• radītais objekts dēvējas ar klasi-mantotājs,
atvasinātu klasi vai pēcnācēju;
• pēcnācējs var tikai pielikt savējā
izsludināšanā kaut kas pie tā, ko viņš mantoja
no bāziskas klases, bet nevar nekā aizvākt.
Tādējādi, pēcnācējs vienmēr nes aiz sevis
visas bāziska objekta pazīmes un īpašības;
-
pie atvasinātas klases var būt tikai viena
bāziska klase. Tas dēvējas ar vienkārtēju
pārmantojamību un rada objektu hierarhiju,
kurā pie visām klasēm bez izņēmuma ir
vienmēr esams kaut vai viens kopīgs sencis
(Delphi vidē tā ir Tobject klase).
Iekapsulēšana
Zem iekapsulēšanas domājas klases
(objekta) spēja slēpt no ārpasaules
nevajadzīgas realizācijas detaļas, un tieši –
lauki un metodes, kuras ir vajadzīgas tikai
iekšējam klases darbam un nevar būt derīgi
programmētājiem, kas rada šīs klases
objektus vai izmantojoši šo klasi kā bāzisks.
Tādējādi, labi iekapsulētā klasē no ārpuses ir
redzami tikai tie lauki un metodes, kuras būs
derīgas, un labi ir apslēpti lauki un metodes,
kuras ir nepieciešamas tikai iekšējam klases
darbam. Bez slēpšanas nevajadzīgu lauku un
metožu iekapsulēšanas domā uzticamu
objekta neatkarību. Tas nozīmē, ka viss
nepieciešams klases darbam vajag būt
realizētam iekšpus objekta, bet visi resursi,
kurus objekts sagrābj savējā darba laikā,
viņam pašam ir korekti jāatbrīvo (piemēram,
taisīt ciet pēc sev failus un atbrīvot sagrābto
atmiņu).
Polimorfisms
Programmēšanā efekts, kad viena un tā pati
komanda, kas ir pievērsta pie dažādiem
objektiem, tiek izpildīta ar tiem pie katra pa
savu, dēvējas ar polimorfismu. Polimorfisms
ļauj programmētājam nevis rūpēties par
uzrunu pie katra objekta atsevišķā, bet gan ir
vienkārši norādīt objektu grupai izpildīt vienu
un to pašu komandu.
Objektu klases
Katrs objekts vienmēr pieder dažai objektu
klasei. Objektu klase - tas ir viena tipa
objektu lielas kopas apkopotais (abstrakts)
apraksts. Objekti ir savējās klases konkrētie
pārstāvji, tos pieņemts saukt par klases
eksemplāriem. Piemēram, Suns klase ir
jēdziens abstrakts, bet šīs klases eksemplārs
Manējais Suns BOBIK ir jēdziens konkrēts.
Klases
OOP atbalstam Delphi valodā ir ievesti
objektu datu tipi, ar kuru palīdzību vienlaikus
aprakstītās dati un operācijas pār tiem.
Objektu datu tipi sauc par klasēm, bet to
eksemplāri - ar objektiem.
Objektu klases tiek noteiktas globāla bloka type
sekcijā. Klases apraksts iesākas no atslēgu vārda
class un noslēdzas ar atslēgu vārdu end. Pa formu
izsludināšanas klases ir līdzīgas parastiem
ierakstiem, bet bez datu laukiem var saturēt lietotāja
procedūru un funkciju izsludināšanas. Tādas
procedūras un funkcijas apkopoti sauc par
metodēm, tie ir paredzēti dažādu operāciju izpildei
ar objektiem.
Piemērs 1.
Minēsim klases izsludināšanas piemēru, kura
ir paredzēta tekstu faila lasīšanai "delimited
text” formātā (fails tādā formātā pārstāv rindu
secīgumu; katra rinda sastāv no nozīmēm,
kuras nodalīja viens no otra simbolsatdalītājs):
type
TDelimitedReader = class
// Lauki
FileVar: TextFile;
Items: array of string;
Delimiter: Char;
// Metodes
procedure PutItem(Index: Integer; const Item: string);
procedure SetActive(const AActive: Boolean);
function ParseLine(const Line: string): Integer;
function NextLine: Boolean;
function GetEndOfFile: Boolean;
end;
Klase satur laukus (Filevar, Items, Delimiter)
un metodes (PutItem, SetActive, ParseLine,
NextLine, GetEndOffile). Metožu virsraksti
vienmēr ir nākami aiz lauku saraksta.
Programmisks metožu kods ir uzrakstāms
atsevišķi no klases definēšanu un tiks atvests
vēlāk.
Klase parasti apraksta būtību, kas ir
modelējama programmā. Piemēram,
Tdelimitedreader klasi pārstāv tekstu faila
"lasītājs" ar salasījumu rindu izjaukšanu uz
elementiem (apakšrindām), kurus nodalīja
viens no otra dažs simbols, saucamais
atdalītājs.
Klase satur daži lauku:
• Filevar ir failu mainīgais, kas ir
nepieciešams piekļūšanai pie faila;
• Delimiter - simbols, kurš kalpo par elementu
atdalītāju;
• Items - elementu masīvs, ko saņēma
pēdējās salasīdamas rindas
izjaukšana;
Klase tāpat satur metožu rindu (procedūru un
funkciju):
• PutItem - novieto elementu Items masīvā pa
Index indeksu; ja indekss pārsniedz augšēju
masīva robežu, tad masīva izmērs
automātiski palielinās;
• SetActive - ver vaļā vai taisa ciet failu, no
kura ir ražojama rindu lasīšana;
• ParseLine - īsteno rindas izjaukšanu: iedala
elementus no rindas un novieto tos Items
masīvā; atdod izcelto elementu daudzumu;
• NextLine – nolasa kārtējo rindu no faila un
ar ParseLine metodes palīdzību īsteno tās
izjaukšanu; kārtējās rindas sekmīgās
lasīšanas gadījumā funkcija atdod nozīmi
True, bet citādi - nozīme False (ir sasniegtas
faila beigas);
• GetEndOffile - atdod būla vērtību, kas
rāda, vai ir sasniegtas faila beigas.
Pievērsīsiet uzmanību, ka apraksts, kurš ir
atvests augstāk, ir nekas cits, kā interfeisa
deklarācija darbam ar Tdelimitedreader klases
objektiem. PutItem , SetActive, ParseLine,
NextLine un GetEndOffile metožu realizācijas
uz šo brīdi nav, tomēr radīšanai un klases
eksemplāru izmantošanai viņa pagaidām un
nevajadzīga.
Objekti
Lai no klases apraksta pārietu pie objekta,
vajag izpildīt atbilstošo izsludināšanu var
sekcijā:
var
Reader: Tdelimitedreader;
Šīs izsludināšanas darbā ar parastiem datu
tipiem būtu pietiek tipa eksemplāra
saņemšanai. Tomēr objekti Delphi vidē ir
dinamiski dati, t.i. izkārtojas dinamiskā
atmiņā.
Tādēļ mainīgais Reader - tas ir vienkāršs
atsauce uz eksemplāru (objekts ir atmiņā),
kurš fiziski vēl neeksistē. Lai konstruētu
Tdelimitedreader klases objektu (izcelt
atmiņu eksemplāram) un sasaistītu ar viņu
mainīgu Reader, vajag programmas tekstā
novietot sekojošo operatoru:
Reader := Tdelimitedreader.Create;
Create - tas ir tā saucamais objekta
konstruktors; viņš vienmēr ir klāt klasē un
kalpo eksemplāra radīšanai un inicializēšanai.
Radot objektu atmiņā izceļas vieta tikai viņa
laukiem. Metodes, tāpat kā parastas
procedūras un funkcijas, novietojas
programmas koda apgabalā; tie māk strādāt
ar savējās klases jebkuriem eksemplāriem un
nedublējas atmiņā.
Pēc radīšanas objektu var izmantot
programmā: saņemt un uzstādīt viņa lauku
vērtības, izsaukt viņa metodes. Piekļūšana
pie laukiem un objekta metodēm notiek ar
precizēto vārdu palīdzību, piemēram:
Reader.NextLine;
Bez tam, tāpat kā darbā ar ierakstiem,
pieļaujams with operatora izmantošana,
piemēram:
with Reader do Nextline;
Ja objekts top nevajadzīgs, viņš ir jāattālina ar
speciālas Destroy metodes izsaukumu,
piemēram:
Reader.Destroy; // atmiņas atbrīvošana, ko
aizņem objekts
Destroy - tā ir tā saucamais objekta
destruktors; viņš ir klāt klasē līdzās
konstruktoram un kalpo objekta noraidīšanai
no dinamiskas atmiņas.
Pēc destruktora izsaukuma mainīgais Reader top
nesaistīts un nav jāizmanto piekļūšanai pie laukiem
un metodēm jau neesošā objekta. Lai atšķirtu
programmā saistītus objekta mainīgus no
nesaistītiem, pēdēji vajag inicializēt ar nil vērtību.
Piemēram, sekojošajā fragmentā uzruna pie Destroy
destruktoram tiek izpildīta tikai tajā gadījumā, ja
objekts reāli eksistē:
Reader := nil;
...
if Reader <> nil then Reader.Destroy;
Destruktora izsaukums neesošajiem
objektiem nepieņemsim un izpildot
programmu atvedīs pie kļūdas. Lai atpestītu
programmētājus no liekām kļūdām, objektos
ieveda iepriekš noteiktu Free metodi, kuru
vajag izsaukt destruktora vietā. Free metode
pats izsauc Destroy destruktoru, bet tikai tajā
gadījumā, ja objekta mainīga vērtība nav
vienāda nil. Tādēļ pēdējo rindiņu piemērā,
kurš ir minēts augstāk, var pārrakstīt sekojoši.
Reader.Free;
Piemērs 2.
Iekapsulēšana un īpašības
Par iekapsulēšanu tiek saprasta objekta lauku
slēpšana ar piekļūšanas nodrošinājuma mērķi pie
tiem tikai ar klases metožu palīdzību.
Delphi valodā piekļūšanas ierobežojums pie
objekta laukiem realizēsies ar objekta īpašību
palīdzību. Objekta īpašība ir raksturojama ar lauku,
kas saglabā īpašības vērtību, un divām metodēm
(write un read), kas nodrošina piekļūšanu pie
īpašības lauka.
Klases aprakstā pirms īpašības vārda
ieraksta property vārdu (īpašība). Pēc
īpašības vārda ir norādāms viņa tips, pēc tam
- metožu vārdi, kas nodrošina piekļūšanu pie
īpašības nozīmes. Pēc read vārda ir
norādāms metodes vārds, kas nodrošina
īpašības lasīšanu, pēc write vārda - metodes
vārds, kas atbild par īpašības ierakstu.
Zemāk ir minēts Tperson klases apraksta
piemērs, kas satur divas īpašības: Name Un
Address.
type
TName = string[15]; TAddress = string[35];
TPerson = class // klase
private
FName: TName; // Name īpašības vērtība
FAddress: TAddress; // Address īpašības vērtība
Constructor Create(Name:Tname);
Procedure Show;
Function GetName: TName;
Function GetAddress: TAddress;
Procedure SetAddress(NewAddress:TAddress);
public
Property Name: Tname // īpašība Name
read GetName; // tikai lasīšana
Property Address: TAddress // īpašība
Address
read GetAddress // lasīšāna
write SetAddress; // un ierakstīšana
end;
Programmā īpašības vērtības uzstādīšanai nevis
vajag ierakstīt īpašības vērtības uzstādīšanas
metodes pielietojuma pie objekta instrukciju, bet gan
ir jāieraksta vērtības īpašībai piesavināšanās
parastu instrukciju. Piemēram, lai piesavinātos
vērtību student objekta Address īpašībai, pietiek
ierakstīt
student.Address := ‘Daugavpils, Smilšu ielā 21,dz.3';
Kompilators pārtranslē vērtības īpašībai
piesavināšanās atvesto instrukciju metodes
izsaukuma instrukcijā
student.SetAddress(‘Daugavpils, Smilšu ielā 21,dz.3
');
Uzstādīt īpašības vērtību, kas ir aizsargāta no ieraksta, var
objekta inicializēšanas laikā. Zemāk ir atvestas Tperson
klases metodes, kas nodrošina objekta Tperson klases
radīšanu un piekļūšana pie viņa īpašībām.
// Tperson objekta konstruktors
Constructor TPerson.Create(Name:TName);
begin
FName:=Name;
end;
// īpašības Name vērtības saņemšanas metode
Function TPerson.GetName;
begin
Result:=FName;
end;
// īpašības Address vērtības saņemšanas metode
function TPerson.GetAddress;
begin
Result:=FAddress;
end;
// īpašības Address vērtības izmaiņas metode
Procedure TPerson.SetAddress(NewAddress:TAddress);
begin
if FAddress = ‘’ then FAddress := NewAddress;
end;
Tperson objekta konstruktors rada objektu
un uzstāda Fname lauka vērtību, kas noteic
Name īpašības vērtību.
Instrukcijas programmas, kas nodrošina
Tperson klases objekta radīšanu un viņa
īpašības uzstādīšanu, var būt, piemēram,
tādi:
student := Tperson.Create('Ivanovs');
student.Address := ‘Smilšu ielā, m.3, dz.25';
Pārmantojamība
Objektorientētas programmēšanas
koncepcija paredz iespēju noteikt jaunas
klases ar lauku, īpašību un metožu
piemetinājuma palīdzību pie jau
eksistējošajām klasēm. Jaunu klašu
saņemšanas tāds mehānisms dēvējas ar
radīšanu. Pie tam jauna, radītā klase
(pēcnācējs) manto savējās bāziskās, vecāku
klases īpašības un metodes.
Klases-pēcnācēja izsludināšanā ir norādāma
vecāku klase. Piemēram, Temployee (līdzstrādnieks)
klase var būt radīts no Tperson klases, kura ir
aplūkota augstāk, ar Fdepartment (nodaļa) lauka
pielikšanu. Templioyee klases izsludināšana šajā
gadījumā var izskatīties tā:
Temployee = class(Tperson)
Fdepartment: string; // nodaļas nosaukums
constructor Create(Name:tname;Dep:integer);
end;
Tperson klases vārds, kurš ir noslēgts iekavas,
rāda, ka Temployee klase tiek atvasināta no
Tperson klases. Savukārt, Tperson klase ir bāzisks
Temployee klasei.
Temployee klasei jābūt savējo personīgo
konstruktoru, kas nodrošina klases-vecāku un
savējo lauku inicializēšanu. Lūk Temployee klases
konstruktora realizācijas piemērs:
constructor Temployee.Create(Name:tname;Dep:integer);
begin
inherited Create(Name);
Fdepartment:=dep;
end;
Minētajā piemērā ar inherited direktīvu izsaucas
vecāku klases konstruktors. Pēc tā piesavinās
vērtība klases-pēcnācēja laukam.
Pēc atvasinātas klases objekta radīšanas
programmā var izmantot laukus un vecāku klases
metodes. Zemāk ir atvests programmas fragments,
kas demonstrē šo iespēju.
engineer := Temployee.Create('Sidorov',’RTU DF’);
engineer.address := ‘Jātnieku ielā m.8, dz.10';
Pirmā instrukcija rada tipa Temployee objektu, otrā uzstāda īpašības vērtību, kura attiecas pret vecāku
klasi.
Redzamības līmeņi
Klases atribūtiem iespējami četri aizsardzības līmeņi:
Private (privātie) - pieejami tikai šīs klases metodēm, klases
apakšklasē nav pieejami.
Protected (aizsargātie) - pieejami šīs klases apakšklasēm,
kuras tos var atstāt aizsargātus vai padarīt publiskus.
Public (publiskie) - pieejami no ārpuses, paliek publiski arī
apakšklasē.
Published (publicētie) – pēc aizsardzības pakāpes līdzīgi
publiskajiem.
Protected un private direktīvas
Bez klases (lauku, metožu, īpašību) elementu
izsludināšanai klases apraksts, kā likums,
satur protected (aizsargāts) un private
(aizvērts) direktīvas, kuri uzstāda klases
elementu redzamības pakāpi programmā.
Klases elementi, kas ir izziņoti protected
sekcijā, ir pieejami tikai klasēs, kuras ir
radītas no viņa. Šīs sekcijas klases elementu
redzamības apgabals neaprobežojas ar
moduli, kurā atrodas klases apraksts. Parasti
protected sekcijā novieto klases metožu
aprakstu.
Klases elementi, kas ir izziņoti private
sekcijā, redzami tikai iekšpus moduļa. Šie
elementi nav pieejami aiz robežām moduļa,
pat atvasinātās klasēs. Parasti private sekcijā
novieto klases lauku aprakstu, bet metodes,
kas nodrošina piekļūšanu pie šiem laukiem,
novieto protected sekcijā.
TPerson = class
private
FName: TName; // Name īpašības vērtība
FAddress: TAddress; // Address īpašības vērtība
protected
Constructor Create(Name:TName);
Function GetName: TName;
Function GetAddress: TAddress;
Procedure SetAddress(NewAddress:TAddress);
Property Name: TName read GetName;
Property Address: TAddress read GetAddress
write SetAddress;
end;
Polimorfisms un virtuālas metodes
Polimorfisms - tā ir iespēja izmantot vienādus
vārdus metodēm, kas ienāk dažādās klasēs.
Polimorfisma koncepcija nodrošina tieši tās
metodes izmantošanu, kura atbilst objekta
klasei.
Lai ir noteiktas trīs klases, viens no kuriem ir
bāzisks diviem citiem:
tуре
// bāzes klase
TPerson = class
fname: string; // имя
constructor Create(name:string);
function info: string; virtual;
end;
// atvasinātā klase no TPerson
TStud = class(TPerson)
fgr:integer; // mācību grupas numurs
constructor Create(name:string;gr:integer);
function info: string; override;
end;
// atvasinātā klase no TPerson
TProf = class(TPerson)
fdep:string; // katedras nosaukums
constructor Create(name:string;dep:string);
function info: string;override;
end;
Katrā no šīm klasēm ir noteikta info metode.
Bāziskā klasē ar direktīvas palīdzību virtual info
metode ir izziņota virtuāla. Metodes izsludināšana
virtuāla dod iespēju meitas klasei ražot virtuālas
metodes aizstāšanu savējais personīgais. Katrā
meitas klasē ir noteikta savējā info metode, kurš
aizvieto vecāku klases atbilstošo metodi (radītās
klases metode, kas aizvieto vecāku klases virtuālu
metodi, iezīmējas ar override direktīvu).
Zemāk ir atvesta info metodes definēšana katrai
klasei.
function TPerson.info:string;
begin
result := '';
end;
function TStud.info:string;
begin
result := fname + ' gr.' + IntTostr(fgr);
end;
function TProf.info:string;
begin
result := fname + ' kat.' + fdep;
end;
Programmas piemērs, kura saformē un izved
studentu un pasniedzēju sarakstu.
Dialoglodziņš:
unit polimor_;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls;
type
TForm1 = class(TForm)
Edit1: TEdit;
Edit2: TEdit;
GroupBox1: TGroupBox;
RadioButton1: TRadioButton;
RadioButton2: TRadioButton;
Label1: TLabel;
Label2: TLabel;
Button1: TButton;
Button2: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
// bāzes klase
TPerson = class
fName: string; // Vārds, Uzvārds
constructor Create(name:string);
function info:string; virtual;
end;
// klase Students
TStud = class(TPerson)
fGr:string; // Grupas nosaukums
constructor Create(name:string;gr:string);
function info:string; override;
end;
// Klase pasniedzējs
TProf = class(TPerson)
fdep:string; // nodaļa
constructor Create(name:string;dep:string);
function info:string; override;
end;
const
SZL = 10; // Saraksta daudzums
n:integer = 0;
// Cilvēku skaits sarakstā
var
Form1: TForm1;
List: array[1..SZL] of TPerson; // saraksts
Implementation
{$R *.DFM}
constructor TPerson.Create(name:string);
begin
fName := name;
end;
constructor TStud.Create(name:string;gr:string);
begin
inherited create(name); // bāzes klases
konstruktora izsaukums
fGr := gr;
end;
constructor TProf.create(name:string; dep:string);
begin
inherited create(name); // bāzes klases
konstruktora izsaukums
fDep := dep;
end;
function TPerson.Info:string;
begin
result := fname;
end;
function TStud.Info:string;
begin
result := fname + ' gr.' + fGr;
end;
function TProf.Info:string;
begin
result := fname + ' kat.' + fDep;
end;
// Poga "Papildināt"
procedure TForm1.Button1Click(Sender: TObject);
begin
if n < SZL then
begin
// papildināt sarakstu
n:=n+1;
if Radiobutton1.Checked
then // veidot objektu TStud
List[n]:=TStud.Create(Edit1.Text,Edit2.Text)
else // veidot objektu TProf
List[n]:=TProf.Create(Edit1.Text,Edit2.Text);
// attīrīt ievades laukus
Edit1.Text := '';
Edit2.Text := '';
Edit1.SetFocus; // ievietot kursoru "Uzvārds" laukā
end
else ShowMessage('saraksts ir aizpildīts!');
end;
// Poga "Saraksts"
procedure TForm1.Button2Click(Sender: TObject);
var
i:integer; // indekss
st:string; // saraksts
begin
for i:=1 to SZL do
if list[i] <> NIL then st:=st + list[i].info + #13;
ShowMessage ('Saraksts'+#13+st);
end;
end.
Piemērs 2.
{type}
Tpunkts = class
protected
punktX,punktY:integer;
public
constructor create (x,y:integer); virtual;
procedure paradit; virtual;
procedure paslept; virtual;
end;
Tlinija = class (Tpunkts)
protected
punktx1,punkty1:integer;
public
constructor create(x,y,x1,y1:integer);
reintroduce;
procedure paradit; override;
procedure paslept; override;
end;
Ttrissturis = class (Tlinija)
protected
punktx2,punkty2:integer;
public
constructor create (x,y,x1,y1,x2,y2:integer);
reintroduce;
procedure paradit; override;
procedure paslept; override;
end;
TAploce = class (Tpunkts)
protected
radiuss:integer;
public
constructor create (x,y,r:integer); reintroduce;
procedure paradit; override;
procedure paslept; override;
end;
var
Form1: TForm1;
punkts1:tpunkts;
linija1:tlinija;
trissturis1:Ttrissturis;
aploce:Taploce;
x,y,x1,y1,x2,y2,r:integer;
implementation
constructor Tpunkts.create (x,y:integer);
begin
punktX := x;
punktY := y;
end;
constructor Tlinija.create (x,y,x1,y1:integer);
begin
inherited create (x,y);
punktX1 := x1;
punktY1 := y1;
end;
constructor TAploce.create (x,y,r:integer);
begin
inherited create (x,y);
radiuss := r;
end;
constructor Ttrissturis.create (x,y,x1,y1,x2,y2:integer);
begin
inherited create (x,y,x1,y1);
punktX2 := x2;
punktY2 := y2;
end;
procedure Tpunkts.paradit;
begin
form1.image1.canvas.pixels[punktx,punkty]:=clred ;
end;
procedure Tpunkts.paslept;
begin
form1.image1.canvas.pixels[punktx,punkty]:=clwhite;
end;
procedure Tlinija.paradit;
begin
form1.image1.Canvas.Pen.Color :=clred;
form1.image1.Canvas.moveto(punktx,punkty);
form1.image1.canvas.lineto(punktx1,punkty1);
end;
procedure Tlinija.paslept;
begin
form1.image1.Canvas.Pen.Color :=clWhite;
form1.image1.Canvas.moveto(punktx,punkty);
form1.image1.canvas.lineto(punktx1,punkty1);
end;
procedure TAploce.paradit;
begin
form1.image1.Canvas.Pen.Color :=clred;
form1.image1.Canvas.ellipse(punktx-radiuss,punktyradiuss,
punktx+radiuss,punkty+radiuss);
end;
procedure TAploce.paslept;
begin
form1.image1.Canvas.Pen.Color :=clWhite;
form1.image1.Canvas.ellipse(punktx-radiuss,punktyradiuss, punktx+radiuss,punkty+radiuss);
end;
procedure Ttrissturis.paradit;
begin
form1.image1.Canvas.Pen.Color :=clred;
form1.image1.Canvas.moveto(punktx,punkty);
form1.image1.canvas.lineto(punktx1,punkty1);
form1.image1.Canvas.moveto(punktx1,punkty1);
form1.image1.canvas.lineto(punktx2,punkty2);
form1.image1.Canvas.moveto(punktx2,punkty2);
form1.image1.canvas.lineto(punktx,punkty);
end;
procedure Ttrissturis.paslept;
begin
form1.image1.Canvas.Pen.Color :=clwhite;
form1.image1.Canvas.moveto(punktx,punkty);
form1.image1.canvas.lineto(punktx1,punkty1);
form1.image1.Canvas.moveto(punktx1,punkty1);
form1.image1.canvas.lineto(punktx2,punkty2);
form1.image1.Canvas.moveto(punktx2,punkty2);
form1.image1.canvas.lineto(punktx,punkty);
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
close;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
punkts1:=tpunkts.Create(x,y);
linija1:=tlinija.Create(x,y,x1,y1);
trissturis1:=ttrissturis.Create (x,y,x1,y1,x2,y2);
aploce := taploce.create (x,y,r);
end;
procedure TForm1.Button10Click(Sender: TObject);
var xp,yp:integer;
begin
xp:= strtoint(edit7.text);
yp:= strtoint(edit8.text);
punkts1.punktx:=xp;
punkts1.punkty:=yp;
punkts1.paradit;
end;
procedure TForm1.Button11Click(Sender: TObject);
var xp,yp:integer;
begin
xp:= strtoint(edit7.text);
yp:= strtoint(edit8.text);
punkts1.punktx:=xp;
punkts1.punkty:=yp;
punkts1.paslept;
end;
procedure TForm1.Button2Click(Sender: TObject);
var xp,yp,xp1,yp1:integer;
begin
xp:= strtoint(edit1.text);
yp:= strtoint(edit2.text);
xp1:= strtoint(edit9.text);
yp1:= strtoint(edit10.text);
linija1.punktx:=xp;
linija1.punkty:=yp;
linija1.punktx1:=xp1;
linija1.punkty1:=yp1;
linija1.paradit;
end;
procedure TForm1.Button3Click(Sender: TObject);
var xp,yp,xp1,yp1:integer;
begin
xp:= strtoint(edit1.text);
yp:= strtoint(edit2.text);
xp1:= strtoint(edit9.text);
yp1:= strtoint(edit10.text);
linija1.punktx:=xp;
linija1.punkty:=yp;
linija1.punktx1:=xp1;
linija1.punkty1:=yp1;
linija1.paslept;
end;
procedure TForm1.Button4Click(Sender: TObject);
var xp,yp,xp1,yp1,xp2,yp2:integer;
begin
xp:= strtoint(edit11.text);
yp:= strtoint(edit12.text);
xp1:= strtoint(edit13.text);
yp1:= strtoint(edit14.text);
xp2:= strtoint(edit15.text);
yp2:= strtoint(edit16.text);
trissturis1.punktx:=xp;
trissturis1.punkty:=yp;
trissturis1.punktx1:=xp1;
trissturis1.punkty1:=yp1;
trissturis1.punktx2:=xp2;
trissturis1.punkty2:=yp2;
trissturis1.paradit;
end;
procedure TForm1.Button5Click(Sender: TObject);
var xp,yp,xp1,yp1,xp2,yp2:integer;
begin
xp:= strtoint(edit11.text);
yp:= strtoint(edit12.text);
xp1:= strtoint(edit13.text);
yp1:= strtoint(edit14.text);
xp2:= strtoint(edit15.text);
yp2:= strtoint(edit16.text);
trissturis1.punktx:=xp;
trissturis1.punkty:=yp;
trissturis1.punktx1:=xp1;
trissturis1.punkty1:=yp1;
trissturis1.punktx2:=xp2;
trissturis1.punkty2:=yp2;
trissturis1.paslept;
end;
procedure TForm1.Button6Click(Sender: TObject);
var xp,yp,xp1:integer;
begin
xp:= strtoint(edit3.text);
yp:= strtoint(edit4.text);
xp1:= strtoint(edit5.text);
aploce.punktx:=xp;
aploce.punkty:=yp;
aploce.radiuss:=xp1;
aploce.paradit;
end;
procedure TForm1.Button7Click(Sender: TObject);
var xp,yp,xp1:integer;
begin
xp:= strtoint(edit3.text);
yp:= strtoint(edit4.text);
xp1:= strtoint(edit5.text);
aploce.punktx:=xp;
aploce.punkty:=yp;
aploce.radiuss:=xp1;
aploce.paslept;
end;
end.