objektorientētas programmēšanas pamati

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 simbols-

atdalī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.

ObjektiLai 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ītstudent.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 metodeFunction 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ībaprotected 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_;interfaceuses 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; // sarakstsImplementation{$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; // sarakstsbegin 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,punkty-radiuss, punktx+radiuss,punkty+radiuss); end;procedure TAploce.paslept; begin form1.image1.Canvas.Pen.Color :=clWhite; form1.image1.Canvas.ellipse(punktx-radiuss,punkty-

radiuss, 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.