OBJEKTNO ORIJENTIRANO PROGRAMIRANJE

autor: Marko Petričević, dipl.ing., prof. urednica: Silvija Jurak, prof. naslov: Objektno orijentirano programiranje stručni recezenti: Danijel Kučak, dipl.ing Ivan Mesic lektorica: Dijana Stilinović, prof. grafički urednik: Krešimir Pletikosa, ACE nakladnik: Algebra d.o.o., 2009. za nakladnika: mr.sc. Mislav Balković mjesto i godina izdavanja: Zagreb, 2009 Sva prava pridržana. Niti jedan dio ove knjige ne smije se reproducirati ili prenositi u bilo kojem obliku, niti na koji način. Zabranjeno je svako kopiranje, citiranje te upotreba knjige u javnim i privatnim edukacijskim organizacijama u svrhu organiziranih školovanja, a bez pisanog odobrenja nositelja autorskih prava. Copyright © Algebra d.o.o. CIP zapis dostupan u računalnom katalogu Nacionalne i sveučilišne knjižnice u Zagrebu pod brojem xxxxxx ISBN 978-953-7390-53-2

autor: Marko Petričević, dipl.ing., prof. urednica: Silvija Jurak, prof. naslov: Objektno orijentirano programiranje stručni recezenti: Danijel Kučak, dipl.ing Ivan Mesic lektorica: Dijana Stilinović, prof. grafički urednik: Krešimir Pletikosa, ACE nakladnik: Algebra d.o.o., 2009. za nakladnika: mr.sc. Mislav Balković mjesto i godina izdavanja: Zagreb, 2009 Sva prava pridržana. Niti jedan dio ove knjige ne smije se reproducirati ili prenositi u bilo kojem obliku, niti na koji način. Zabranjeno je svako kopiranje, citiranje te upotreba knjige u javnim i privatnim edukacijskim organizacijama u svrhu organiziranih školovanja, a bez pisanog odobrenja nositelja autorskih prava. Copyright © Algebra d.o.o. CIP zapis dostupan u računalnom katalogu Nacionalne i sveučilišne knjižnice u Zagrebu pod brojem 715230 ISBN 978-953-7390-53-2

Sadržaj: 1. Poglavlje: .......... Uvod ...................................................................................................................................................................... 5

1.1. Uvod 6 1.2. Osnovni principi ........................................................................................................................................................................... 7 1.3. Objektno orijentirano programiranje i programski jezik C# ........................................................................................................... 8 1.4. "Hello World!" ............................................................................................................................................................................ 10

1.4.1. Primjer – program "Hello World" u programskom jeziku C# .............................................................................................. 10 1.4.2. Razlikovanje velikih i malih slova ...................................................................................................................................... 10 1.4.3. Prazan prostor ................................................................................................................................................................. 10 1.4.4. Tipovi, klase ..................................................................................................................................................................... 10 1.4.5. Metode ............................................................................................................................................................................. 11 1.4.6. Ključna riječ static ......................................................................................................................................................... 11 1.4.7. Komentari......................................................................................................................................................................... 11 1.4.8. Konzolni programi ............................................................................................................................................................ 11 1.4.9. Operator točka (.) ............................................................................................................................................................. 12 1.4.10. Imenski prostori .............................................................................................................................................................. 12 1.4.11. Pokretanje programa ...................................................................................................................................................... 12 1.4.12. Ključna riječ using ......................................................................................................................................................... 14 1.4.13. Ključna riječ namespace ................................................................................................................................................. 15 1.4.14. Parametri metode Main (string[] args) ............................................................................................................................ 15

2. Poglavlje: .......... Osnove programskog jezika C# ......................................................................................................................... 17 2.1. Tipovi 18

2.1.1 UgraĎeni tipovi .......................................................................................................................................................... 18 2.2. Varijable i konstante .................................................................................................................................................................. 21

2.2.1. Varijable ........................................................................................................................................................................... 21 2.2.2.Obavezna deklaracija i inicijalizacija .................................................................................................................................. 22 2.2.3. Konstante ......................................................................................................................................................................... 23 2.2.4. Enumeracije ..................................................................................................................................................................... 24 2.2.5. Nizovi znakova – tip podataka string ............................................................................................................................. 26

2.3. Iskazi 27 2.3.1. Blokovi iskaza .................................................................................................................................................................. 27 2.3.2. Izrazi ................................................................................................................................................................................ 27 2.3.3. Iskazi bezuvjetnog grananja ............................................................................................................................................. 28 2.3.4. Iskazi uvjetnog grananja ................................................................................................................................................... 30 2.3.5. Iskazi switch: alternativa ugnijeţĎenim iskazima if .......................................................................................................... 33 2.3.6. Iteracijski iskazi ................................................................................................................................................................ 35

2.4. Operatori ................................................................................................................................................................................... 40 2.4.1. Operator pridruţivanja ...................................................................................................................................................... 40 2.4.2. Matematički operatori ....................................................................................................................................................... 40 2.4.3. Operatori za uvećavanje i umanjivanje ............................................................................................................................. 42 2.4.4. Relacijski operatori ........................................................................................................................................................... 45 2.4.5. Logički operatori ............................................................................................................................................................... 46 2.4.6. Prednost operatora .......................................................................................................................................................... 46 2.4.7. Ternarni operator ............................................................................................................................................................. 47

3. Poglavlje: .......... Klase i objekti ..................................................................................................................................................... 49 3.1. Klase i objekti ............................................................................................................................................................................ 50

3.1.1. Deklariranje i definiranje klase .......................................................................................................................................... 50 3.1.2. Modifikatori pristupa ......................................................................................................................................................... 51 3.1.3. Instanciranje (stvaranje) objekata ..................................................................................................................................... 52 3.1.4. Primjer deklaracije, definicije i instanciranja novog objekta klase ...................................................................................... 53 3.1.5. Konstruktori ...................................................................................................................................................................... 55 3.1.6. Inicijalizatori ..................................................................................................................................................................... 58 3.1.1 Ključna riječ this ...................................................................................................................................................... 58 3.1.8. Uništavanje objekata ........................................................................................................................................................ 59

3.2. Statički članovi i članovi instance ............................................................................................................................................... 59 3.2.1. Pozivanje statičkih članova ............................................................................................................................................... 60 3.2.2. Statičke metode za pristup statičkim poljima .................................................................................................................... 62 3.2.3. Korištenje statičkog konstruktora ...................................................................................................................................... 62 3.2.4. Statičke klase ................................................................................................................................................................... 62

3.3. Metode ...................................................................................................................................................................................... 63 3.3.1. ProsljeĎivanje parametara ................................................................................................................................................ 64 3.3.2. Preopterećivanje metoda i konstruktora ........................................................................................................................... 66

3.4. Svojstva .................................................................................................................................................................................... 69 3.4.1. Korištenje svojstava ......................................................................................................................................................... 69 3.4.2. Pristupnik get ................................................................................................................................................................... 70 3.4.3. Pristupnik set ................................................................................................................................................................... 71 3.4.4. Readonly i writeonly svojstva ........................................................................................................................................... 72 3.4.5. Polja readonly .................................................................................................................................................................. 73

4. Poglavlje: .......... NasljeĊivanje i polimorfizam .............................................................................................................................. 75 4.1. NasljeĎivanje i polimorfizam ...................................................................................................................................................... 76

4.1.1. Specijalizacija i generalizacija .......................................................................................................................................... 76 4.1.2. NasljeĎivanje .................................................................................................................................................................... 77

4.1.3. Polimorfizam .................................................................................................................................................................... 77 4.1.4. Primjer korištenja nasljeĎivanja i polimorfizma.................................................................................................................. 78 4.1.5. Stvaranje polimorfnih tipova ............................................................................................................................................. 80 4.1.6. Pozivanje konstruktora osnovne (bazne) klase ................................................................................................................. 81 4.1.7. Kontrola pristupa .............................................................................................................................................................. 82 4.1.8. Korištenje ključnih riječi new i override u praćenju inačica .............................................................................................. 83

4.2. Apstraktne klase ........................................................................................................................................................................ 83 4.2.1. Primjer korištenja apstraktne klase ................................................................................................................................... 84 4.2.2. Zapečaćena (sealed) klasa ............................................................................................................................................. 85

4.3. Korijen svih klasa: Object ......................................................................................................................................................... 86 4.3.1. Primjer upotrebe metode ToString() naslijeĎene iz Object ........................................................................................... 86

4.4. Pakiranje i raspakiravanje tipova ............................................................................................................................................... 88 4.4.1. Primjer boxinga i unboxinga ............................................................................................................................................. 89

4.5. UgnjeţĎivanje klasa .................................................................................................................................................................. 90 4.5.1. Primjer korištenja ugnijeţĎene klase ................................................................................................................................ 91

5. Poglavlje: .......... Preopterećivanje operatora ............................................................................................................................... 93 5.1. Preopterećivanje operatora ....................................................................................................................................................... 94

5.1.1. Preopterećivanje operatora .............................................................................................................................................. 94 5.1.2. Podrška ostalim .NET jezicima ......................................................................................................................................... 94 5.1.1. Umjerenost u korištenju operatora .................................................................................................................................... 95 5.1.4. Logički parovi ................................................................................................................................................................... 95 5.1.5. Operator jednakosti .......................................................................................................................................................... 95 5.1.6. Operatori pretvaranja ....................................................................................................................................................... 96 5.1.7. Primjer korištenja preopterećivanja operatora................................................................................................................... 96

6. Poglavlje: .......... Strukture ........................................................................................................................................................... 103 6.1. Strukture ................................................................................................................................................................................. 104

6.1.1. Definiranje struktura ....................................................................................................................................................... 104 6.1.2. U strukturi nema inicijalizatora ........................................................................................................................................ 106 6.1.3. Eksplicitno definirani konstruktor mora inicijalizirati varijable članice ............................................................................... 106 6.1.4. Strukture su vrijednosni, a klase referentni tipovi ............................................................................................................ 106 6.1.5. Implicitno nasljeĎivanje iz Object .................................................................................................................................. 107 6.1.6. Stvaranje struktura ......................................................................................................................................................... 108

7. Poglavlje: .......... Suĉelja ............................................................................................................................................................... 111 7.1. Sučelja .................................................................................................................................................................................... 112

7.1.1. Definiranje i implementiranje sučelja .............................................................................................................................. 112 7.1.2. Pretvaranje u sučelje ...................................................................................................................................................... 115 7.1.3. Pristupanje metodama sučelja ....................................................................................................................................... 115

7.2. Implementiranje više od jednog sučelja ................................................................................................................................... 116 7.2.1. Proširivanje sučelja ........................................................................................................................................................ 116 7.2.2. Kombiniranje sučelja ...................................................................................................................................................... 116 7.2.3. Primjer proširivanja i kombiniranja sučelja ...................................................................................................................... 117 7.2.4. Operator as .................................................................................................................................................................... 120 7.2.5. Pretvaranje u proširena i kombinirana sučelja ................................................................................................................ 122 7.2.6. Operator is .................................................................................................................................................................... 122 7.2.7. Usporedba sučelja s apstraktnom klasom ...................................................................................................................... 125

7.3. Premošćivanje implementacije sučelja .................................................................................................................................... 126 7.3.1. Primjer premošćivanja implementacije sučelja................................................................................................................ 126

7.4. Eksplicitna implementacija sučelja ........................................................................................................................................... 129 7.4.1. Primjer korištenja eksplicitne implementacije sučelja ...................................................................................................... 129 7.4.2. Selektivno izlaganje metoda sučelja ............................................................................................................................... 131

7.5. Pristupanje zapečaćenim klasama i vrijednosnim tipovima ...................................................................................................... 131 7.5.1. Implementacija sučelja kroz strukturu ............................................................................................................................. 132

8. Poglavlje: .......... Polja, indekseri i kolekcije ............................................................................................................................... 135 8.1. Polja, indekseri i kolekcije ........................................................................................................................................................ 136 8.2. Polja 136

8.2.1. Deklariranje polja ........................................................................................................................................................... 137 8.2.2. Podrazumijevane vrijednosti ........................................................................................................................................... 139 8.2.3. Pristupanje elementima polja ......................................................................................................................................... 139 8.2.4. Primjer korištenja polja ................................................................................................................................................... 140 8.2.5. Iskaz foreach ................................................................................................................................................................ 141 8.2.6. Inicijaliziranje elemenata polja ........................................................................................................................................ 142 8.2.7. Ključna riječ params ....................................................................................................................................................... 143 8.2.8. Višedimenzionalna polja ................................................................................................................................................. 144 8.2.9. Postavljanje granica polja ............................................................................................................................................... 150 8.2.10. Pretvaranje polja .......................................................................................................................................................... 152 8.2.11. Sortiranje polja ............................................................................................................................................................. 153

8.3. Indekseri ................................................................................................................................................................................. 154 8.3.1. Primjer definiranja indeksera .......................................................................................................................................... 155

8.4. Sučelja kolekcija ...................................................................................................................................................................... 158 8.4.1. Sučelje IEnumerable<T> ............................................................................................................................................... 159 8.4.2. List<T> ......................................................................................................................................................................... 161 8.4.3. Implementiranje sučelja IComparable ........................................................................................................................... 163

8.4.4. Implementacija sučelja IComparer ................................................................................................................................. 165 8.4.5. Ograničenja .................................................................................................................................................................... 168

8.5. Redovi 171 8.5.1. Primjer korištenja klase Queue ........................................................................................................................................ 172

8.6. Stogovi .................................................................................................................................................................................... 173 8.6.1. Primjer korištenja klase Stack ........................................................................................................................................ 173

8.7. Rječnici ................................................................................................................................................................................... 175 8.7.1. IDictionary<K, V> ...................................................................................................................................................... 176 8.7.2. Primjer korištenja klase Dictionary .............................................................................................................................. 176

9. Poglavlje: .......... Nizovi znakova .................................................................................................................................................. 179 9.2. Nizovi znakova ........................................................................................................................................................................ 180

9.1.1. Klasa String ................................................................................................................................................................. 180 9.1.2. Stvaranje nizova znakova............................................................................................................................................... 181 9.1.3. Metoda ToString()....................................................................................................................................................... 181 9.1.4. Metode i svojstva klase String ...................................................................................................................................... 182 9.1.5. Primjer rada s nizovima .................................................................................................................................................. 183 9.1.6. Traţenje podnizova – metoda Substring() .................................................................................................................. 187 9.1.7. Dijeljenje nizova – metoda Split() ............................................................................................................................... 189

9.2. Rad s dinamičkim nizovima ..................................................................................................................................................... 190 9.2.1. Klasa StringBuilder .................................................................................................................................................... 190

9.3. Regularni izrazi ....................................................................................................................................................................... 192 9.3.1. Klasa Regex ................................................................................................................................................................... 192

10. Poglavlje: ........ Obrada iznimaka ............................................................................................................................................... 195 10.1. Obrada iznimaka ................................................................................................................................................................... 196

10.1.1. Izbacivanje i hvatanje iznimaka – iskazi throw i catch................................................................................................. 196 10.1.2. Namjenski catch iskazi ................................................................................................................................................ 200 10.1.3. Iskaz finally .............................................................................................................................................................. 201

10.2. Objekti klase Exception ....................................................................................................................................................... 204 10.2.1. Primjer korištenja objekta klase Exception .................................................................................................................. 204 10.2.2. PrilagoĎene iznimke ..................................................................................................................................................... 206 10.2.3. Ponovno izbacivanje iznimaka ...................................................................................................................................... 208

11. Poglavlje: ........ Delegati i dogaĊaji ............................................................................................................................................ 213 11.1. Delegati i dogaĎaji ................................................................................................................................................................. 214

11.1.1. Delegati ........................................................................................................................................................................ 214 11.1.2. Primjer korištenja delegata ........................................................................................................................................... 215 11.1.3. Delegati i metode instance ........................................................................................................................................... 220 11.1.4. Statički delegati ............................................................................................................................................................ 221 11.1.5. Delegati kao svojstva ................................................................................................................................................... 221 11.1.6. Višeodredišni delegati .................................................................................................................................................. 222

11.2. DogaĎaji ................................................................................................................................................................................ 225 11.2.1. Delegati i dogaĎaji ........................................................................................................................................................ 226 11.2.2. Primjer implementacije dogaĎaja s pomoću delegata ................................................................................................... 227 11.2.3. Problemi u implementaciji dogaĎaja s pomoću delegata............................................................................................... 231 11.2.4. Ključna riječ event ....................................................................................................................................................... 232 11.2.5. Anonimne metode ........................................................................................................................................................ 235

U ovom poglavlju nauĉit ćete:

Deklariranje i definiranje klase

Instanciranje objekata, konstruktori

Statičke članove i članove instance

Metode

Svojstva

3. Poglavlje: Klase i objekti

Str.50§

§3. POGLAVLJE: KLASE I OBJEKTI

tel: 01 2222 182, e-mail: [email protected]

§www.racunarstvo.hr §

3.1. Klase i objekti

U prethodnom poglavlju ukratko smo objasnili primitivne tipove koji su dio programskog jezika C#. MeĎutim, bit C#-a je mogućnost stvaranja novih, sloţenih tipova, koje sami definiramo, a koji jasno preslikavaju objekte od kojih se sastoji problem koji pokušavamo riješiti. Nove tipove u programskom jeziku C# zadajemo deklariranjem i definiranjem klasa. Kad je klasa definirana, iz nje moţemo instancirati (stvarati) objekte. Kaţemo da je svaki objekt instanca neke klase. Na klase i objekte moţemo analogno gledati kao na tipove i varijable. U tom kontekstu klasa je zapravo tip objekta, a objekt je varijabla odreĎene klase. Sjetimo se primjera osobe iz prvog poglavlja. Klasa Osoba definira osobine i ponašanja vaţna za

pojam osobe u našem programu. Objekti klase Osoba stvaraju se u memoriji prilikom izvoĎenja

programa. Kad imamo konkretan objekt (instancu klase), moţemo vidjeti konkretne vrijednosti njegovih osobina (Ime=Ivan, Starost=25, Spol=muški, Zanimanje="Tajni agent"...) i

konkretno mu (objektu klase Osoba) moţemo zadati ponašanje (Promatraj).

Klase u objektno orijentiranom programiranju imaju veliku prednost jer su u njima osobine i sposobnosti nekog pojma (entiteta) uĉahurene (engl. encapsulated) u jedinstvenoj, samostojećoj i samoodrţivoj jedinici programskog kôda. Tako i u našem primjeru, kada ţelimo objektu "Ivan" klase Osoba zadati ponašanje Promatraj,

samo pozovemo njegovu metodu Promatraj(). Kako će on to učiniti, uopće nam nije bitno, bitno

jest samo da se ta metoda izvede. Stari programerski vic kaţe: "Koliko je objektno orijentiranih programera potrebno da se promijeni ţarulja? Odgovor: Niti jedan. Ţarulji se jednostavno kaţe da se sama promijeni ". A ako nam je ipak bitno kako se izvršava ta metoda, onda ćemo na jedinstvenom mjestu, u definiciji klase Osoba, pronaći jedinstvenu definiciju metode Promatraj() i tamo utvrditi detalje koji

nas zanimaju. U ovom poglavlju objasnit ćemo kako se definiraju klase i njihovi elementi - ĉlanovi klase (engl. members): ponašanja (engl. behaviors) i svojstva (engl. properties) u programskom jeziku C#. Opisat ćemo kako se metode koriste za definiranje ponašanja klase i kako se stanje klase odrţava u varijablama članicama (često se nazivaju i polja (engl. fields)). Vidjet ćemo takoĎer i kako se kreiraju svojstva koja razvojnim inţenjerima izgledaju kao metode, a klijentima klase kao polja.

3.1.1. Deklariranje i definiranje klase

U programskom jeziku C# potpuna sintaksa za definiranje klase glasi: [modifikator pristupa] class identifikator [:osnovna klasa [, sučelje(a)]] { // tijelo klase: definicija svojstava, metoda i događaja }

Uočavamo da se klasa deklarira pomoću ključne riječi class koju slijedi proizvoljan naziv klase (identifikator) i zatim, unutar bloka vitičastih zagrada ({}), slijede definicije članova od kojih se

sastoji tijelo klase. Modifikator pristupa je neobavezni dio definicije. Obično se koristi public.

Dio deklaracije iza naziva (identifikatora): osnovna klasa i sučelje(a) odnosi se na

nasljeĎivanje. Klasa u C#-u moţe naslijediti članove jedne klase i članove proizvoljnog broja sučelja. NasljeĎivanje je isto neobavezan dio deklaracije, a o njemu će više govora biti u nastavku. Uzmimo za primjer našu klasu Osoba i pokušajmo analizirati njezinu deklaraciju i definiciju:

Str.51§

§OBJEKTNO ORIJENTIRANO PROGRAMIRANJE

Zagreb – Ilica 242

§

V i s o k a š k o l a z a p r i m i j e n j e n o r a č u n a r s t v o §

public class Osoba { // javno dostupna polja public string Ime; public string Prezime; public int Starost; public string Spol; public string Zanimanje; // privatno polje private DateTime VrijemeInstanciranja = DateTime.Now; // javna metoda public void IspisiDetalje() { Console.WriteLine("Objekt klase Osoba - detalji:"); Console.WriteLine( "Ime: " + Ime + "\n" + "Prezime: " + Prezime + "\n" + "Starost: " + Starost + "\n" + "Spol: " + Spol + "\n" + "Zanimanje: " + Zanimanje + "\n" + "Vrijeme instanciranja: " + VrijemeInstanciranja.ToLongTimeString() ); } }

Dakle, naša klasa deklarirana je pomoću modifikatora pristupa public i zove se Osoba. Unutar nje

definirano je pet public polja (Ime, Prezime, Starost, Spol, Zanimanje), jedno private polje

(VrijemeInstanciranja) i jedna public void metoda IspisiDetalje().

Napomena: Za definiranje privatnog polja VrijemeInstanciranja koristili smo sistemsku

strukturu DateTime koja u .NET platformi opisuje podatak za datum i vrijeme.

DateTime.Now daje trenutni datum i vrijeme sistemskog sata računala na kojem se

program izvršava. Dakle, u trenutku instanciranja novog objekta, vrijednost ovog privatnog polja bit će postavljena na trenutačni datum i vrijeme.

3.1.1.1. Operator konkatenacije (+)

Zadatak metode IspisiDetalje() je ispisati vrijednosti pojedinih članova klase (objekta koji će

biti instanciran iz klase) na konzolu. U metodi IspisiDetalje() operator plus (+) predstavlja

operator konkatenacije (lijepljenja znakova), a ne operator zbrajanja kao kod pitanja brojčanih vrijednosti. Ovaj operator prvo spaja sve znakovne isječke u jedinstveni niz znakova, a zatim se taj niz ispisuje u jednom pozivu metode Console.WriteLine().

3.1.2. Modifikatori pristupa

Modifikator pristupa kontrolira dostupnost elementa kojeg odreĎuje vanjskim objektima. U prethodnom primjeru modifikator pristupa public ispred ključne riječi class označava klasu Osoba

kao javno dostupnu, tj. dostupnu svima. Pod tim podrazumijevamo da bilo koji objekt iz bilo kojeg imenskog prostora moţe vidjeti klasu Osoba i iz nje instancirati novi objekt, tj. moţe ju normalno

koristiti.

Str.52§




Isto tako, pet public polja unutar klase Osoba bit će javno dostupno i izvan same klase, tj. vidljivo

svim korisnicima objekta instanciranog iz te klase. MeĎutim, suprotno tomu, private polje VrijemeInstanciranja neće biti javno dostupno, nego je

ono privatno polje koje se moţe koristiti jedino unutar klase Osoba.

Public (javna) metoda IspisiDetalje() objektima instanciranim iz klase Osoba dostupna je

samo za pozivanje, tj. objekt moţe dohvatiti samo njezino ime. Korisnik objekta moţe ju pozvati, ali ne moţe vidjeti njezino tijelo. Ovaj princip omogućuje programerima da po ţelji detaljno oblikuju sučelje svojim objektima (uočimo u primjeru da će se u ispisu detalja o objektu nalaziti informacija o vremenu instanciranja, ali nitko izvana neće vidjeti da je to omogućilo private polje

VrijemeInstanciranja definirano unutar klase Osoba).

U sljedećoj tablici pogledajmo saţetak modifikatora pristupa u programskom jeziku C#.

Modifikator pristupa Ograniĉenja

public Nema ograničenja. Članovi ograničeni modifikatorom public vidljivi su

svim metodama iz svih klasa.

private Članovima neke klase A označenima modifikatorom private mogu

pristupiti samo metode klase A.

protected Članovima klase A označenima modifikatorom protected mogu

pristupiti metode klase A i metode onih klasa izvedenih (naslijeĎenih) iz klase A.

internal Članovima klase A označenima modifikatorom internal mogu pristupiti

metode klase svih klasa iz sklopa klase A.

protected internal Članovima klase A označenima modifikatorom protected internal

mogu pristupiti metode klase A, metode klasa izvedenih (naslijeĎenih) iz klase A i metode svih klasa iz sklopa klase A. Ovo je zapravo protected ILI internal koncept (ne postoji protected I internal)

Tablica 6 – Modifikatori pristupa u programskom jeziku C#

Napomena: Iako se moţemo osloniti na činjenicu da se sve klase i svi članovi klase prema podrazumijevanim postavkama deklariraju kao private, dobro je prakticirati i

eksplicitno pisanje private modifikatora pristupa. Izričito zadavanje pristupa

označava svjesnu odluku i olakšava pregled kôda.

3.1.3. Instanciranje (stvaranje) objekata

Već smo rekli da postoji analogija u parovima pojmova tip-varijabla i klasa-objekt. Po toj analogiji, kao što nije moguće napisati: int = 5;

nije moguće napisati niti nešto kao: Osoba = Ivan;

Str.53§



§


Drugim riječima, kao što nije moguće dodijeliti vrijednost ugraĎenom tipu, tako ni sintaksa programskog jezika C# ne dozvoljava dodjeljivanje vrijednosti samoj klasi kao novom definiranom tipu. Umjesto toga, kod primitivnih tipova uvijek smo deklarirali varijablu odreĎenog tipa, a zatim se toj varijabli mogla dodijeliti vrijednost. int x = 5; Isto je potrebno napraviti i s klasom – instancirati (stvoriti) novi objekt te klase, a zatim dodijeliti vrijednosti njegovim poljima. Ipak, sintaksa za stvaranje novih objekata nije u potpunosti ista kao za stvaranje novih varijabli. Razlika postoji jer su primitivni tipovi varijabli (int, char...) vrijednosni tipovi i stvaraju se na

stogu, dok su objekti referentni tipovi podataka i stvaraju se na hrpi. Stoga za instanciranje objekata koristimo ključnu riječ new, kao na primjer: Osoba o1 = new Osoba();

Varijabla objekta o1 zapravo ne sadrţi vrijednost za instancirani objekt klase Osoba, već samo

adresu tog (neimenovanog) objekta koji je stvoren na hrpi. o1 je samo referenca tog objekta.

3.1.4. Primjer deklaracije, definicije i instanciranja novog objekta klase

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace DeklaracijaKlase { public class Osoba { // javno dostupna polja public string Ime; public string Prezime; public int Starost; public string Spol; public string Zanimanje; // privatno polje private DateTime VrijemeInstanciranja = DateTime.Now; // inicijalizator // javna metoda public void IspisiDetalje() { Console.WriteLine("Objekt klase Osoba - detalji:"); Console.WriteLine( "Ime: " + Ime + "\n" + "Prezime: " + Prezime + "\n" + "Starost: " + Starost + "\n" + "Spol: " + Spol + "\n" + "Zanimanje: " + Zanimanje + "\n" + "Vrijeme instanciranja: " + VrijemeInstanciranja.ToLongTimeString() ); } } class Program

Str.54§




{ static void Main(string[] args) { Osoba o1 = new Osoba(); // instanciranje novog objekta klase Osoba // dodjeljivanje vrijednosti javnim poljima objekta o1.Ime = "Ivan"; o1.Prezime = "Ivanković"; o1.Starost = 25; o1.Spol = "Muški"; o1.Zanimanje = "Tajni agent"; // poziv public metode objekta o1.IspisiDetalje(); } } }

U ovom programu nalaze se dvije klase: Osoba i Program.

Klasa Osoba je javno dostupna korisnički definirana klasa koja definira pojam osobe. U klasi Osoba

su zato javno dostupni članovi koji opisuju osobine osobe – polja: Ime, Prezime, Starost, Spol i

Zanimanje te metoda IspisiDetalje() koja ima zadatak na konzoli ispisati vrijednosti svih

definiranih polja. Klasa Program je uobičajeno definirana sa svojom metodom Main() u kojoj počinje izvoĎenje

programa. U toj metodi instanciran je novi objekt o1 klase Osoba. Tek sada, kad je objekt stvoren,

preko njegovog imena moţemo dohvatiti sve javne (public) članove definirane u njegovoj

matičnoj klasi Osoba i dodijeliti im konkretne vrijednosti.

Pozivom public metode IspisiDetalje() na konzoli se ispisuju sve dodijeljene vrijednosti.

Pokrenemo li program, dobit ćemo sljedeći prikaz na konzoli:

Slika 14 – Primjer deklaracije, definicije i instanciranja novog objekta klase

Pokušamo li u Main() metodi pozvati i privatno (private) polje VrijemeInstanciranja, kao na

primjer: o1. VrijemeInstanciranja = DateTime.Now; prevoditelj će javiti sljedeću grešku: 'DeklaracijaKlase.Osoba' does not contain a definition for 'VrijemeInstanciranja' and no extension method 'VrijemeInstanciranja' accepting a first argument of type 'DeklaracijaKlase.Osoba' could be found (are you missing a using directive or an assembly reference?)

Str.55§



§


što nam govori da on uopće nije svjestan postojanja polja VrijemeInstanciranja u objektu o1

klase Osoba.

Dakle, privatno polje klase nije dio sučelja objekta instanciranog iz te klase, nego se moţe koristiti isključivo unutar klase za oblikovanje drugih članova tog sučelja (npr. kao u ovom slučaju za metodu IspisiDetalje()).

3.1.5. Konstruktori

Iz sintakse koja se koristi za instanciranje novog objekta: Osoba o1 = new Osoba();

vidimo da taj iskaz izgleda kao da poziva metodu, i to zajedno sa zagradama (()). Zapravo,

metoda se i poziva svaki put kad instanciramo novi objekt. Ta metoda naziva se konstruktor. Zadatak konstruktora je stvaranje objekta koji je definiran klasom i njegovo postavljanje u ispravno stanje. Klasa Osoba iz našeg primjera ne definira konstruktor eksplicitno pa ga u tom slučaju CLR i

prevoditelj sami pruţaju. Taj podrazumijevani (defaultni) konstruktor stvara u memoriji objekt klase Osoba, ali ne izvodi nikakvu drugu akciju.

Varijable, koje su članice klase (polja), inicijaliziraju se u bezazlene vrijednosti (cjelobrojne vrijednosti se inicijaliziraju s nulom, nizovi znakova s praznim nizom). U sljedećoj tablici nalazi se popis vrijednosti koje se podrazumijevano dodjeljuju primitivnim tipovima.

Tip Podrazumijevana vrijednost

Brojčani (int, long, itd.) 0

char '\0' (null)

enum 0

logički false

reference null

Tablica 7 – Podrazumijevane vrijednosti primitivnih tipova u programskom jeziku C#

Pokušajmo u prethodnom primjeru zakomentirati linije unutar metode Main() u kojima smo

dodjeljivali vrijednosti public poljima objekta o1 klase Osoba:

static void Main(string[] args) { Osoba o1 = new Osoba(); // instanciranje novog objekta klase Osoba // dodjeljivanje vrijednosti javnim poljima objekta // o1.Ime = "Ivan"; // o1.Prezime = "Ivanković"; // o1.Starost = 25; // o1.Spol = "Muški"; // o1.Zanimanje = "Tajni agent"; // poziv public metode objekta o1.IspisiDetalje(); }

Str.56§




Pokretanjem ovako izmijenjenog programa dobit ćemo sljedeći rezultat u konzoli:

Slika 15 – Inicijalizacija polja na bezazlene vrijednosti

3.1.5.1. Eksplicitna definicija konstruktora

U većini ćemo slučajeva konstruktor definirati sami i proslijediti mu parametre da bi mogao postaviti objekt u početno stanje. Naš prethodni primjer mogao bi se onda preraditi ovako: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Konstruktori { public class Osoba { // Eksplicitno navedeni konstruktor public Osoba(string ime, string prezime, int starost, string spol, string zanimanje) { this.Ime = ime; this.Prezime = prezime; this.Starost = starost; this.Spol = spol; this.Zanimanje = zanimanje; } // javno dostupna polja public string Ime; public string Prezime; public int Starost; public string Spol; public string Zanimanje; // privatno polje private DateTime VrijemeInstanciranja = DateTime.Now; // inicijalizator // javna metoda public void IspisiDetalje() { Console.WriteLine("Objekt klase Osoba - detalji:"); Console.WriteLine( "Ime: " + Ime + "\n" +

Str.57§



§


"Prezime: " + Prezime + "\n" + "Starost: " + Starost + "\n" + "Spol: " + Spol + "\n" + "Zanimanje: " + Zanimanje + "\n" + "Vrijeme instanciranja: " + VrijemeInstanciranja.ToLongTimeString() ); } } class Program { static void Main(string[] args) { // instanciranje novog objekta pomoću eksplicitno definiranog konstruktora Osoba o1 = new Osoba("Ivan", "Ivanković", 25, "Muški", "Tajni agent"); o1.IspisiDetalje(); } } }

Dakle, u klasi osoba deklarirali smo i definirali konstruktor na sljedeći način: public Osoba(string ime, string prezime, int starost, string spol, string zanimanje) { this.Ime = ime; this.Prezime = prezime; this.Starost = starost; this.Spol = spol; this.Zanimanje = zanimanje; }

Deklaracija konstruktora počinje ključnom riječi public koja osigurava mogućnost poziva ove

metode vanjskim objektima. Zatim se navodi ime metode (konstruktora) koje je zapravo ime same klase (Osoba) te unutar zagrada (()) slijedi deklaracija parametara. Za svaki parametar navodi se

njegov povratni tip i ime. Parametri se odvajaju zarezima (,).

Napomena: Primijetimo da je konstruktor metoda koja nema povratni tip. Tip kojeg ova metoda vraća je zapravo sama klasa u kojoj ju definiramo (Osoba). Drugim riječima, poziv

konstruktora vratit će instancirani objekt te klase (objekt klase Osoba).

Unutar tijela konstruktora definirano je da se svakom public polju klase vrijednost inicijalizira na

vrijednost odgovarajućeg parametra. Definiranje konstruktora na ovakav način omogućuje stvaranje novog objekta klase Osoba pomoću

samo jedne linije kôda, kao što moţemo vidjeti u metodi Main():

Osoba o1 = new Osoba("Ivan", "Ivanković", 25, "Muški", "Tajni agent");

Nadalje, u pozivu konstruktora prosljeĎuju se konkretne vrijednosti parametara ("Ivan", "Ivanković"). Kad je novi objekt o1 klase Osoba instanciran, konstruktor se pobrinuo i za

ispravno inicijaliziranje svih njegovih javno dostupnih polja. Pokretanjem ovog programa dobit ćemo u konzoli isti rezultat kao i u prethodnom primjeru.

Str.58§




3.1.6. Inicijalizatori

Umjesto u konstruktoru, vrijednosti polja (varijabli članica) mogu se inicijalizirati u inicijalizatorima (engl. initializer). Inicijalizator moţemo stvoriti pridruţivanjem početne vrijednosti članu klase. U našem primjeru pomoću inicijalizatora smo dodijelili početnu vrijednost privatnom polju VrijemeInstanciranja na vrijednost trenutnog datuma i vremena sistemskog sata:

private DateTime VrijemeInstanciranja = DateTime.Now; // inicijalizator

Napomena: Izostavimo li inicijalizator u prethodnom primjeru, konstruktor bi obavio bezazlenu inicijalizaciju privatnog polja VrijemeInstanciranja i na konzoli bi se kao vrijeme

instanciranja ispisalo 0:00:00.

3.1.1 Kljuĉna rijeĉ this

Ključna riječ this upućuje na trenutnu instancu objekta. Moţemo reći i ovako: kad se instancira objekt iz klase, this predstavlja taj objekt.

Referenca this je skrivena referenca dostupna svim nestatičkim metoda klase (metodama koje

nemaju ključnu riječ static u svojoj deklaraciji). Preko reference this svaka nestatička metoda

moţe pozivati sve druge nestatičke članove (metode i varijable) objekta. this se moţe koristiti na razne načine.

3.1.7.1. Kvalifikacija ĉlanova instance skrivenih parametrima pomoću this

U prethodnom primjeru imamo definiran konstruktor koji dodjeljuje članovima klase (poljima) vrijednosti proslijeĎene parametrima. Primijetimo da se i članovi klase, i parametri jednako nazivaju (Ime – ime, Prezime – prezime...). Kod ovakvog stila imenovanja dobro je to što je iz naziva

jasno koji parametar inicijalizira koje polje. Loša je strana što isti nazivi mogu zbuniti. Referenca this stoga se ovdje koristi za rješavanje višeznačnosti naziva. Kad napišemo

this.Ime, jasno je da se radi o članu klase, a ne o parametru. Stoga je za pozivanje člana klase

preporučljivo uvijek navoditi this.

Metoda IspisiDetalje() tada bi izgledala ovako:

public void IspisiDetalje() { Console.WriteLine("Objekt klase Osoba - detalji:"); Console.WriteLine( "Ime: " + this.Ime + "\n" + "Prezime: " + this.Prezime + "\n" + "Starost: " + this.Starost + "\n" + "Spol: " + this.Spol + "\n" + "Zanimanje: " + this.Zanimanje + "\n" + "Vrijeme instanciranja: " + this. VrijemeInstanciranja.ToLongTimeString() ); }

Napomena: Referenca this koristi se još i kod prosljeĎivanja cijelog objekta kao parametra u

drugu metodu, prilikom rada s indekserima i kod korištenja preopterećenih konstruktora. Detalje o tim primjenama vidjet ćemo u narednim poglavljima.

Documents

OBJEKTNO ORIJENTIRANO PROGRAMIRANJE