C# i NET Framework 4 0 Prirucnik-potpuna verzija final · Str.11 § §C# I .NET FRAMEWORK 2.0 Zagreb - Maksimirska 58a § ALGEBRA § 2.2 Klasa, objekt, struktura 2.2.1 Klasa, objekt

autor: Silvije Davila; Marko Petričević urednica: Ana Rutar, prof. naslov: C# I .NET FRAMEWORK 4.0 stručni recezent: mr. sc. Goran Đambić lektorica: Anka Munić grafički urednik: Krešimir Pletikosa, ACE nakladnik: Algebra d.o.o., 2010. za nakladnika: mr.sc. Mislav Balković mjesto i godina izdavanja: Zagreb, 2010 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 744148 ISBN 978-953-322-034-5

Sadržaj: 1. Poglavlje: ...... UVOD ...................................................................................................................... 3

1.1 Kratki pregled razvoja programskih jezika ........................................................................ 4 1.1.1 Strojno zavisni jezici ..................................................................................................... 4 1.1.2 Programski jezici više razine ........................................................................................ 5

1.2 Algoritmi ............................................................................................................................ 6 1.2.1 Rješavanje problema primjenom računala ................................................................... 6 1.2.2 Pojam i karakteristike algoritma ................................................................................... 7

2. Poglavlje: ...... OBJEKTNO ORIJENTIRANO PROGRAMIRANJE ............................................... 9 2.1 Osnovni principi ............................................................................................................... 10 2.2 Klasa, objekt, struktura.................................................................................................... 11

2.2.1 Klasa, objekt (svojstva, metode – događaji, operatori) .............................................. 11 2.2.2 Strukture ..................................................................................................................... 14 2.2.3 Osnovni tipovi podataka ............................................................................................. 14 2.2.4 Deklaracija i definicija varijable .................................................................................. 17 2.2.5 Izrazi, operatori, konverzije ........................................................................................ 19 2.2.6 Aritmetički operatori ................................................................................................... 19 2.2.7 Relacijski operatori ..................................................................................................... 20 2.2.8 Logički operatori ......................................................................................................... 21 2.2.9 Tekstualni operator .................................................................................................... 22 2.2.10 Operator dodjele ................................................................................................... 22 2.2.11 Konverzije podataka .............................................................................................. 24

3. Poglavlje: ...... UVOD U .NET FRAMEWORK .............................................................................. 27 3.1 Osnovni principi ............................................................................................................... 28 3.2 Hello World – pisanje prve aplikacije .............................................................................. 29

4. Poglavlje: ...... VISUAL STUDIO .NET 2010 (VS2010) ................................................................ 31 4.1 Visual studio .NET 2010 (VS2010) – pokretanje aplikacije ............................................. 32 4.2 Hello World – pisanje aplikacije u VS2010 ..................................................................... 33 4.3 Objašnjenje sučelja ......................................................................................................... 34

4.3.1 InteliSense ................................................................................................................. 34 4.3.2 Solution Explorer ........................................................................................................ 36 4.3.3 Ostali okviri (paneli) u VS2010 ................................................................................... 36

5. Poglavlje: ...... OSNOVNI TIPOVI PODATAKA ........................................................................... 37 5.1 Varijable .......................................................................................................................... 38

5.1.1 Matematički operatori ................................................................................................. 38 5.1.2 Varijable ..................................................................................................................... 38 5.1.3 Učitavanje podataka s tipkovnice ............................................................................... 39 5.1.4 Metoda Parse ............................................................................................................. 40

5.2 Uvjetno grananje ............................................................................................................. 41 5.2.1 Naredba If ................................................................................................................ 41 5.2.2 Naredba Switch .......................................................................................................... 44 5.2.3 Strukturirano upravljanje greškama ........................................................................... 46 5.2.4 Logički operatori ......................................................................................................... 47 5.2.5 Ostatak pri cjelobrojnom dijeljenju ............................................................................. 49

5.3 Cikličke petlje .................................................................................................................. 49 5.3.1 Petlja For .................................................................................................................... 50 5.3.2 Petlja While ................................................................................................................ 52

6. Poglavlje: ...... NIZOVI .................................................................................................................. 55 6.1 Nizovi (Arrays) ................................................................................................................. 56 6.2 Objekt ArrayList ............................................................................................................... 57

6.2.1 Petlja Foreach ............................................................................................................ 58 7. Poglavlje: ...... PROCEDURE (METODE) .................................................................................... 61

7.1 Procedure (metode) ........................................................................................................ 62 7.2 Potprogrami ..................................................................................................................... 63 7.3 Funkcije ........................................................................................................................... 66

8. Poglavlje: ...... OBJEKTI ............................................................................................................... 69 8.1 Svojstva, metode, događaji (Properties, Methods, Events) ............................................ 70

8.1.1 Objekti ........................................................................................................................ 70 8.1.2 Klase .......................................................................................................................... 70 8.1.3 Svojstva (Properties) .................................................................................................. 74

8.2 Doseg varijabli ................................................................................................................. 80 8.2.1 Metode Static ............................................................................................................. 81 8.2.2 Prosljeđivanje varijabli po vrijednosti i po referenci .................................................... 83

8.3 Nasljeđivanje ................................................................................................................... 85 8.3.1 Premošćivanje (override) ........................................................................................... 88 8.3.2 Kolekcija objekata ...................................................................................................... 88

8.4 ClassLibrary (dll) ............................................................................................................. 90 8.4.1 Kreiranje ClassLibrary projekta .................................................................................. 90

8.5 Događaji .......................................................................................................................... 93

9. Poglavlje: ...... RAD S TEKSTOM ................................................................................................ 97 9.1 Klasa String ..................................................................................................................... 98

9.1.1 Metode ToLower i ToUpper ....................................................................................... 98 9.1.2 Metoda SubString ...................................................................................................... 98 9.1.3 Metoda Replace ......................................................................................................... 98 9.1.4 Metoda Split .............................................................................................................. 99 9.1.5 Svojstvo Length .......................................................................................................... 99

9.2 String, char ...................................................................................................................... 99 10. Poglavlje: .... DATOTEKE ........................................................................................................ 101

10.1 System.IO namespace .................................................................................................. 102 10.1.1 Klase FileStream, StreamReader, StreamWriter ................................................ 102 10.1.2 Klase Path, File, Directory ................................................................................... 104

11. Poglavlje: .... DATUMI .............................................................................................................. 107 11.1 DateTime struktura ........................................................................................................ 108

11.1.1 Uspoređivanje datuma ........................................................................................ 108 11.1.2 Važnije metode ................................................................................................... 109

11.2 TimeSpan struktura ....................................................................................................... 109 12. Poglavlje: .... ENUMERACIJE .................................................................................................. 113

12.1 Enumeracije .................................................................................................................. 114 13. Poglavlje: .... INTERFEJSI ....................................................................................................... 115

13.1 Interfejsi ......................................................................................................................... 116 14. Poglavlje: .... POPIS KLJUČNIH RIJEČI ................................................................................. 119

U ovom poglavlju naučiti ćete:

Osnovne principe objektnog programiranja

Što je klasa, objekt, struktura?

2. Poglavlje: OBJEKTNO ORIJENTIRANO PROGRAMIRANJE

Str.10§ §2. Poglavlje: OBJEKTNO ORIJENTIRANO PROGRAMIRANJE

Tel: 01 2332 861, Fax: 01 2305 004 e-mail: [email protected] § www.algebra.hr §

2.1 Osnovni principi Kod objektno orijentiranog programiranja programer polazi od objekata iz realnoga svijeta. Njegov je posao napraviti model tog objekta u programu. U tom modeliranju osnovni je alat apstrakcija. Apstrakcija je kontrolirano uključivanje i isključivanje nekih detalja o objektima koji su bitni, odnosno nisu bitni u programu. Ti objekti iz realnoga svijeta posjeduju statičke i dinamičke osobine. Uzmimo primjer automobila. Za njega možemo reći da ima određenu boju, određen broj sjedišta, određenu kubikažu – statičke osobine. Međutim, automobil se može kretati, stati, okrenuti se – dinamičke osobine. Vidimo, dakle, da su akcije koje objekt može napraviti zapravo sastavni dio samog objekta. Objektno orijentirano programiranje vodi se ovim činjenicama, pa stoga objekti imaju svoja unutrašnja stanja – svojstva, ali i skup akcija – metoda koje objekt može izvršiti. Samo programiranje je sklapanje više objekata u cjelinu. Općenito, u radu s računalom osnovna misao vodilja jest automatizacija poslova. Tako je i kod objektnog programiranja objekte iste vrste prirodno tretirati na isti način. Stoga govorimo o klasama. Klasa je dakle apstrakcija (uopćenje) konkretnih objekata iste vrste. Svaki objekt u programu jest objekt određene klase. Klasa objekta određuje dakle njegovo interfejs, tj. njegova svojstva, metode i događaje preko kojih možemo komunicirati s njim u programu. Kažemo da je taj objekt instanca te klase. Objekti su osnova modularnosti i strukturiranosti objektno orijentiranog programiranja. Oni predstavljaju samostalne cjeline koje možemo sklapati s drugim objektima u skladu s potrebama, te tako rješavati složenije probleme. Svaki objekt može primati poruke, a može ih i slati drugim objektima. Korisnici nekog objekta ne mogu mijenjati unutrašnja stanja i metode objekata. To se svojstvo zove enkapsulacija. Bilo kojem objektu može se pristupiti samo preko njegova interfejsa, koristeći samo njegove javne metode. Nasljeđivanje je također važna osobina objektno orijentiranog programiranja. Ono je posljedica generalizacije. Dakle, ako krenemo od naše klase Automobil, pa zatim uzmemo klasu Brod, generalizacija bi mogla rezultirati nastankom klase vozilo. Obrnuta operacija naziva se specijalizacija. Sve klase nastale specijalizacijom zatim nasljeđuju sve atribute i metode polazne ili generičke klase. Generalizacijom i specijalizacijom može doći do pojave da ista metoda djeluje na različite načine, ovisno o objektu na koji se primjenjuje, što se onda naziva polimorfizmom. Vezano uz to, možete uočiti i potrebu uvođenja apstraktnih klasa. Na primjer, pogledajte klasu cestovna vozila, pri čemu možete govoriti o nasljeđivanju svojstava i metoda iz klase vozila. Ali, ta klasa zapravo ne rezultira konkretnim objektom - vozilom. Umjesto toga, bolje bi bilo napraviti potklase Automobili ili Kamioni pa tek iz njih instancirati konkretne objekte koji će zatim naslijediti sva svojstva i metode apstraktne klase Cestovna vozila. Iz svega opisanog možemo zaključiti da korištenje objektno orijentiranog programskog jezika omogućuje modeliranje sustava na visokoj razini apstrakcije, onako kako on u prirodi i postoji, bez razmišljanja kako će se i na kojem stroju realizirati.

Str.11§ §C# I .NET FRAMEWORK 2.0

Zagreb - Maksimirska 58a § A L G E B R A §

2.2 Klasa, objekt, struktura 2.2.1 Klasa, objekt (svojstva, metode – događaji, operatori) Pogledajte opet primjer automobila u kontekstu voznog parka neke tvrtke. Vozni park čine objekti klase Automobil. Do klase se dolazi polazeći od pojedinačnih objekata. Promatranjem svih automobila uočavaju se njihova zajednička svojstva (marka automobila, boja, kubikaža, godina proizvodnje, registracija...). Također, svim automobilima možete pridružiti iste "akcije" (kreni, stani...). Te akcije u okviru klase nazivaju se metodama klase, a njima se opisuje funkcionalnost objekata te klase. Dakle, klasa Automobil je uopćenje (apstrakcija) pojedinačnih automobila našeg voznog parka. Svaki taj pojedinačni automobil zapravo je primjerak (instanca, objekt) klase Automobil, a opisan je skupom vrijednosti svojstava te klase. Vrijednost svojstva marka za konkretan automobil je npr. "Mercedes", a vrijednost svojstva godina proizvodnje je 2005. "Mercedes" i 2005. su pojedinačni podaci. Iako se svaki od tih podataka u memoriji čuva u obliku nizova 0 i 1 (bez obzira na to je li to broj, slovo, slika ili zvuk), jasno je da se različite vrste podataka registriraju na različite načine i da su nad različitim vrstama podataka dopuštene različite operacije. Stoga računalu morate dati informaciju o tome koja je vrsta podataka registrirana da bi ga ono na pravi način tumačilo i obrađivalo. To se postiže tipom podataka. Tipom podataka definiran je:

• način registriranja podataka u memoriji • skup mogućih vrijednosti podataka • skup mogućih akcija nad podacima.

Može se reći da su vrijednosti atributa - svojstava (marka, godina proizvodnje) podaci na najnižoj razini apstrakcije i za njihovo definiranje koriste se primitivni tipovi podataka. Klasa je, pak, tip podataka na višoj razini apstrakcije, jer opisuje skup objekata koji imaju zajednička svojstva i jednako se ponašaju. Klasu definirate navođenjem ključne riječi class iza koje slijedi ime klase. Ako formirate klasu koja nasljeđuje neku prethodno definiranu klasu, onda poslije imena navodite dvotočku (':'), a zatim slijedi ime klase koja se nasljeđuje. Nakon toga, u vitičastim zagradama definirate članove klase (svojstva i metode):

class imeKlase :imePrethodnoDefiniraneKlase { opis / definicija članova klase }

U ovom primjeru klasu automobila možete definirati na sljedeći način:

class Automobil { // Svojstva string markaAutomobila; int godinaProizvodnje; string boja; int brojSjedišta; int brojVrata;



string registracija; double KS; // konjskih snaga // Metode void Kreni() { ...

} void OtvoriVrata(Vrata x) {

... } double KSuKW() {

... }

} Svojstva se definiraju navođenjem njihova tipa (koji mora biti prethodno definiran) i imena. Pristup svojstvima u programskom jeziku C# realizirate navođenjem imena objekta, zatim točke ('.'), pa imena svojstva. Na primjer, ako je A1 objekt klase Automobil, tada svojstvu markaAutomobila pristupate ovako:

A1.markaAutomobila Svojstvima opisujete osobine objekta i njihove vrijednosti definiraju njegovo stanje. Metoda klase je imenovani blok naredbi koji se sastoji od zaglavlja i tijela metode. U zaglavlju navodite povratni tip (ili riječ void ako nema povratne vrijednosti), a zatim ime metode. Slijede zagrade. U zagradama se, ako postoje, navode zarezima odvojeni parametri. Za svaki parametar navodi se tip i ime. Poslije zaglavlja u vitičastim zagradama navodite tijelo metode koje se sastoji od odgovarajućih naredbi programskog jezika C#. Metodama opisujete ponašanje objekta u određenoj situaciji i pod određenim uvjetima (Kreni, OtvoriVrata), ali i određujete nove vrijednosti na temelju osobina koje objekt posjeduje (KSuKW). Na taj način opisujete funkcionalnost objekta:

povratniTip imeMetode (listaParametara) { tijelo metode }

U programskom jeziku C# metodu nekog objekta pozivate na sljedeći način:

imeObjekta.imeMetode (lista stvarnih parametara) Na primjer, ako je A1 objekt klase Automobil, tada metodu Kreni pozivate

A1.Kreni()



a metodu OtvoriVrata

A1.OtvoriVrata(V1) gdje je V1 objekt klase Vrata. Neke od metoda automatski se pokreću kao reakcija na događaje koji nastaju tijekom izvršavanja aplikacije, pa se takve metode i nazivaju događajima (engl. events). Svaka klasa sadrži metode koje omogućuju kreiranje objekata (konstruktora) na više načina, kao i metodu koja "uništava" objekt (destruktor). Unutar programskog kôda možete upisivati kratke komentare navođenjem dviju kosih crta ("//"). Tada sve što napišete do kraja linije kompajliranjem programa biva ignorirano i ne izvršava se. Kada želite napisati dulji komentar, koji će se protezati kroz više linija, ograničit ćete ga na sljedeći način:

/* ... komentar ... */ Jedan od osnovnih koncepata objektno orijentiranog programiranja jest kontroliranje pristupa članovima objekta. Za svaki član klase (svojstva i metode) morate definirati razinu pristupa (dostupnosti). U programskom jeziku C# postoji više razina pristupa, a najosnovnije su privatna (private) i javna (public). Privatni članovi klase dostupni su samo metodama te klase i to je najviša razina zaštite. Suprotno tome, public članovima klase može pristupiti bilo koji drugi objekt. Primijetite da se svi dosad spomenuti članovi klase konkretiziraju tek instanciranjem objekta, odnosno tek kada stvorite novi objekt, možete koristiti njegova svojstva i metode. Međutim, pri definiranju članova klase poslije razine pristupa možete navesti i ključnu riječ static kojom omogućujete postojanje i korištenje tog člana bez kreiranja konkretnih instanci. Takvim članovima pristupate navođenjem imena klase umjesto imena objekta. Tada bez obzira na broj instanci klase koja sadrži static svojstvo postoji točno jedna kopija tog svojstva u aplikaciji. Statičko svojstvo je zapravo svojstvo klase, a ne svojstvo objekta. U programskom jeziku C# postoje klase koje sadrže uglavnom statičke članove (Math, Convert, Array...). Konkretne objekte takvih klasa ne možete čak ni instancirati, već vam one omogućuju korištenje sistemskih metoda koje se mogu primjenjivati na objektima različitog tipa. Ako novu klasu nasljeđujete od neke već postojeće, treba dodati da nova klasa od postojeće nasljeđuje sva njezina svojstva i metode, a vama preostaje samo da definirate nove i predefinirate postojeće. Ova mogućnost programskog jezika C# izuzetno ubrzava i olakšava kreiranje aplikacija. Za klasu se kaže da je referentni tip podataka jer, kad se tijekom izvršavanja aplikacije kreira novi objekt određene klase, prostor za njegovo registriranje odvija se u memoriji računala izvan aplikacije (u heapu – dinamičkoj memoriji), a aplikacija s njim komunicira preko njegove adrese – reference.



2.2.2 Strukture Budući da je svaki objekt primjerak neke klase, a svaka klasa sadrži svojstva koja mogu biti objekti neke druge klase, jasno je da moraju postojati neki osnovni (temeljni) podaci na kojima objekt (a samim tim i aplikacija) počiva. U programskom jeziku C# osnovni podaci su predstavljeni strukturama. Strukture se definiraju na sljedeći način:

struct imeStrukture { definicija atributa u metoda strukture }

Članovima strukture možete definirati razinu pristupa kao i kod klasa. Ali, za razliku od klasa, strukturu ne možete naslijediti iz druge strukture ili klase, niti iz nje može biti naslijeđena druga struktura ili klasa. Isto tako, struktura je vrijednosni tip podataka, a klasa referentni. C# sadrži ugrađene (sistemske) biblioteke klasa i struktura, gdje su, kao strukture, definirani i osnovni tipovi podataka (cijeli brojevi, decimalni brojevi, tekstualni i logički tip). Stoga su svi osnovni tipovi vrijednosni tipovi podataka.

2.2.3 Osnovni tipovi podataka Kako smo već spomenuli, navođenjem tipa podataka određujete način registriranja podataka u memoriji, skup mogućih vrijednosti tog podatka te skup mogućih akcija nad podatkom. Cijeli brojevi predstavljaju se u binarnom brojevnom sustavu određenim brojem bitova. U N bitova možemo registrirati "neoznačene" cijele brojeve od 0 do 2N-1, odnosno "označene" cijele brojeve od -2N-1 do 2N-1. Prema tome razlikujemo više cjelobrojnih tipova.



Tip Dopuštene vrijednosti Veličina sbyte od -128 do 127 (od -27 do 27-1) 1 bajt (8 bita) byte od 0 do 255 (od 0 do 28-1) 1 bajt (8 bita) short od -32 768 do 32 767 (od -215 do 215-1) 2 bajta (16 bita) ushort od 0 do 65 535 (od 0 do 216-1) 2 bajta (16 bita) int od -2 147 483 648 do 2 147 483 647

(od -231 do 231-1) 4 bajta (32 bita)

uint od 0 do 4 294 967 295 (od 0 do 232-1) 4 bajta (32 bita) long od -9 223 372 036 854 775 808

do 9 223 372 036 854 775 807 (od -263 do 263-1)

8 bajta (64 bita)

ulong od 0 do 18 446 744 073 709 551 615 (od 0 do 264-1)

8 bajta (64 bita)

Realni su brojevi u programskom jeziku C# predstavljeni trima tipovima podataka:

1. float 2. double 3. decimal.

Oni se razlikuju po skupu dopuštenih vrijednosti i po broju značajnih decimala (preciznosti). Tip Dopuštene vrijednosti Preciznost Veličina float od ±1,5 x 10-45

do ±3,4 x 1038 7 decimala 4 bajta (32 bita)

double od ±5,0 x 10-324 do ±3,4 x 10308

15-16 decimala

8 bajta (64 bita)

decimal od ±1,0 x 10-28 do ±3,4 x 1028

28-29 decimala

16 bajta (128 bita)

Osim osnovnih brojevnih tipova, postoje još dva tipa:

1. char 2. bool.



Tip Dopuštene vrijednosti Veličina char pojedinačni Unicode znak

cijeli broj od 0 do 65535 2 bajta (16 bita)

bool true, false 1 bajt Konstante tipa char pišu se navođenjem znaka između apostrofa ('A', 'b', '1'...). Neki znakovi nemaju svoju grafičku interpretaciju (tab, novi red...), pa ih u kodu zapisujemo pomoću određene specijalne oznake, tzv. escape sekvence. Escape sekvenca Znak \' jednostruki navodnik \" dvostruki navodnik \\ obrnuta kosa crta (backslash) \n novi red \t tab Svi navedeni osnovni tipovi podataka realizirani su sistemskim strukturama. Tip Sinonimna struktura sbyte System.Sbyte byte System.Byte short System.Int16 ushort System.UInt16 int System.Int32 uint System.UInt32 long System.Int64 ulong System.UInt64 float System.Single double System.Double decimal System.Decimal char System.Char bool System.Bool U kodu je svejedno koristimo li ime tipa ili ime odgovarajuće strukture. Posebno mjesto među tipovima podataka zauzima znakovni tip string koji je zapravo niz charova. Stoga je on, za razliku od ostalih osnovnih tipova, realiziran referentnim tipom – sistemskom klasom System.String. Broj znakova u stringu nije ograničen, pa tako ni količina memorije koju zauzima string nije unaprijed određena. Konstante tipa string pišu se između znakova navoda ("A", "Ovo je string", "").



2.2.4 Deklaracija i definicija varijable Varijabla je ime (identifikator) memorijske lokacije u kojoj aplikacija čuva vrijednost. To ime (identifikator) mora biti jedna riječ sastavljena od slova engleske abecede, znamenki ili znaka za podvlačenje ("_"). Ime mora početi slovom ili znakom "_". Evo primjera ispravno imenovanih varijabli:

imeOsobe, osoba1, prezime_osobe, _spol...

No, ovo nisu imena varijabli: ime Osobe, prezime-osobe, 1osoba... Programski jezik C# razlikuje velika i mala slova ("Case Sensitive"), pa stoga varijable ImeOsobe i imeOsobe nisu iste. U programskom jeziku C# postoje dvije vrste varijabli:

1. vrijednosne 2. referentne.

Memorijska lokacija imenovana varijablom vrijednosnog tipa direktno sadrži vrijednost, a lokacija imenovana varijablom referentnog tipa sadrži adresu lokacije u dinamičkoj memoriji u kojoj se čuva informacija. Za podatke osnovnih tipova (int, double, char, bool... – sistemske strukture) samo ime predstavlja vrijednost pa su to vrijednosne varijable. S druge strane, za objekte sistemskih i programerski definiranih klasa ime varijable predstavlja adresu (referencu) memorijske lokacije u dinamičkoj memoriji gdje objekt egzistira, pa su to referentne varijable. Deklaracija varijable:

imeTipa imeVarijable...; Primjer 2.2.4.1 – primjeri deklaracija

int x,y; char a,b; Osoba osoba1, osoba2;

Deklaracijom varijable vrijednosnog tipa odvaja se u memoriji sav prostor potreban za registriranje podatka zadanog tipa, a deklaracijom varijable referentnog tipa odvaja se samo prostor za registriranje adrese memorijske lokacije na kojoj će se nalaziti objekt. Samom deklaracijom varijabli se ne dodjeljuje vrijednost, nego ju je još potrebno i inicijalizirati.



Inicijalizacija varijable vrijednosnog tipa obavlja se pomoću operatora dodjele ("=") na sljedeći način:

varijabla = izraz. Tip vrijednosti izraza mora se poklapati s tipom varijable. Primjer 2.2.4.2

int x,y; x=1; y=x+3;

Inicijalizacija varijable referentnog tipa obavlja se pomoću operatora new:

new imeKlase (listaParametara) U dinamičkoj memoriji odvaja se prostor za registriranje objekta klase imeKlase, a operator new vraća adresu tog prostora koju onda možete dodijeliti referentnoj varijabli. Primjer 2.2.4.3

mojaKlasa x; x = new mojaKlasa(); Osoba o1; o1 = new Osoba("Marko", "Marković");

Možete primijetiti da nakon operatora new zapravo slijedi poziv metode koja nosi isto ime kao i sama klasa. Ta metoda (može ih biti i više) naziva se konstruktor i sastavni je dio svake klase. Pozivom konstruktora nastaje novi objekt te klase. Dakle, definicija varijable uvijek se sastoji od dva koraka: deklaracije i inicijalizacije. U programskom jeziku C# zgodno je što se ta dva koraka mogu objediniti. Primjer 2.2.4.4

int x = 1, y; mojaKlasa = new mojaKlasa(); Osoba o1 = new Osoba("Marko", "Marković");



2.2.5 Izrazi, operatori, konverzije Tijekom implementiranja vašeg programskog algoritma stalno se događa da na podatke primjenjujete različite operacije kojima nastaju nove vrijednosti. Niz varijabli i konstanti, međusobno povezanih operatorima, eventualno odvojenih zagradama, koji kao rezultat daju nekakvu novu vrijednost naziva se izrazom. Primjer 2.2.5.1 – primjeri izraza

123 'a' a + 4 * b "Moje ime je "+ime x > y + 5 (x +1) * y

Izrazi se, s obzirom na tipove podataka i operatore koji u njima sudjeluju, mogu podijeliti kao u sljedećoj tablici: Izrazi Tipovi podataka Operatori aritmetički svi numerički tipovi + – * / % relacijski svi usporedivi tipovi == != < > <= >= logički logički tip ! && || tekstualni tekstualni tipovi + Svaki od navedenih operatora karakteriziraju sljedeće osobine:

• arnost operatora (koliko izraza povezuje – unarni, binarni, ternarni) • tip izraza na koje se primjenjuje i tip vrijednosti rezultata • prioritet operatora u odnosu na druge operatore • asocijativnost (određuje redoslijed izvršavanja operacija istog

prioriteta).

2.2.6 Aritmetički operatori Operatori +, –, *, / predstavljaju osnovne računske operacije. To su binarni operatori, s tim da se + i – mogu koristiti i kao unarni (predznak). Operatori * i / višeg su prioriteta od operatora + i –. Binarni operator % vraća ostatak pri cjelobrojnom dijeljenju. Svi aritmetički operatori su lijevo asocijativni (operacije istog prioriteta izvode se slijeva nadesno).



Primjer 2.2.6.1

x + y * z Prvo se računa y * z jer je operator * većeg prioriteta od operatora +, a tek onda se provodi zbrajanje. Primjer 2.2.6.2

x * y / z Prvo se računa x * y, a zatim se rezultat dijeli sa z (lijeva asocijativnost).

2.2.7 Relacijski operatori Svi relacijski operatori su binarni i vraćaju rezultat true ili false (istina ili laž). Oni služe za uspoređivanje vrijednosti operanada. Relacijski operatori su nižeg prioriteta od aritmetičkih operatora. Primjer 2.2.7.1

x + 5 * y > y -2 Prvo se računa vrijednost aritmetičkog izraza s lijeve strane relacijskog operatora >, zatim vrijednost aritmetičkog izraza s njegove desne strane, i tek tada se te dvije vrijednosti uspoređuju. Operator == ispituje jesu li vrijednosti operanada iste, ali samo ako se radi o operandima vrijednosnog tipa ili tipa string. Ako su operandi referentnog tipa, onda taj operator ispituje pokazuju li oni na isti objekt. Primjer 2.2.7.2 Ako je definirano

int x = 1, y = 2; tada je vrijednost izraza

x == y – 1 true jer su vrijednosti izraza s lijeve i s desne strane operatora == iste. Primjer 2.2.7.3 Ako je definirano

string ime1 = "Marko"; string ime2 = "Marko";



tada je vrijednost izraza

ime1 == ime2 true jer su vrijednosti obiju varijabli iste. Primjer 2.2.7.4 Ako je definirano

Osoba o1 = new Osoba("Marko", "Marković"); Osoba o2 = new Osoba("Marko", "Marković");


o1 == o2 false jer, bez obzira na to što su definirana dva objekta klase Osoba s istim ulaznim parametrima, operator new je svakom dodijelio novu memorijsku lokaciju. Primjer 2.2.7.5 Ako je definirano

Osoba o1 = new Osoba("Marko", "Marković"); Osoba o2 = o1;


o1 == o2 true jer sada o1 i o2 pokazuju na isti memorijski prostor. Suprotno operatoru ==, operator != na isti način ispituje različitost svojih operanada.

2.2.8 Logički operatori Binarni logički operatori && i || služe za povezivanje logičkih vrijednosti svojih operanada. Operator && povezuje po pravilu logičke konjunkcije (logika "i"), a operator || logičke disjunkcije (logičko "ili"). Ovi operatori imaju jako nizak prioritet (niži od relacijskih operatora). Primjer 2.2.8.1

izraz1 && izraz2 ima vrijednost true samo ako i izraz1 i izraz2 imaju vrijednost true. U suprotnome, taj izraz ima vrijednost false.



Primjer 2.2.8.2

izraz1 || izraz2 ima vrijednost false samo ako i izraz1 i izraz2 imaju vrijednost false. U suprotnome, taj izraz ima vrijednost true. Unarni logički operator ! negira logičku vrijednost na koju se primjenjuje i on je operator najvišeg prioriteta. Primjer 2.2.8.3

!izraz ima vrijednost false ako izraz ima vrijednost true.

2.2.9 Tekstualni operator Ako binarnim operatorom + djelujete na operande od kojih je barem jedan tekstualnog tipa, tada se radi o konkatenaciji (spajanju) stringova. Tada se i eventualni numerički operand automatski konvertira u svoj tekstualni oblik. Primjer 2.2.9.1 Ako je definirano

string ime = "Marko"; string prezime = "Marković"; int starost = 21;


"Ja se zovem " + ime + " " + prezime + " i imam " + starost + " godinu." jednaka

Ja se zovem Marko Marković i imam 21 godinu.

2.2.10 Operator dodjele U prethodnim primjerima moglo se zaključiti da operator dodjele ("=") ima najniži prioritet. Ponovimo još jednom kako se odvija inicijalizacija varijable:

varijabla = izraz Dakle, prvo se izračunava vrijednost izraza, a zatim se ta vrijednost dodjeljuje varijabli. Iz toga dalje možete zaključiti da je operator dodjele desno asocijativan.



Primjer 2.2.10.1 Ako je definirano

int x, y; bool p; string ime, recenica;

tada su izrazi

x = 5; x = x + 1; x = x * 2 + 1; p = (x > 5) && (y < x) ime = "Marko"; recenica = "Ja se zovem " + ime;

primjeri ispravno upotrijebljenog operatora dodjele ("=").

Napomena: Programski jezik C# dopušta i korištenje specifičnih operatora dodjele op=, gdje je op neki od aritmetičkih operatora.

Primjer 2.2.10.2 Ako je definirano

int x = 2; tada operacija

x += 1 vrijednost varijable x povećava za 1 (ekvivalentno operaciji x = x + 1). Čak i ako se radi o često potrebnom povećavanju ili smanjivanju vrijednosti neke varijable za 1, mogu se koristiti i unarni operatori ++ i -- koji imaju postfiksnu i prefiksnu notaciju (x++, ++x, x--, --x). Kad je u pitanju postfiksna notacija, rezultat je vrijednost varijable prije operacije, a kad je u pitanju prefiksna notacija, rezultat je vrijednost varijable poslije operacije. Primjer 2.2.10.3 Ako je definirano

double x = 1.5, y; y = x++;

tada su vrijednosti

x = 2.5 y = 1.5



no ako je definirano

double x = 1.5, y; y = ++x;

vrijednosti su

x = 2.5 y = 2.5

2.2.11 Konverzije podataka Konverzija podataka je prevođenje podataka iz jednog tipa u drugi. U programskom jeziku C# konverzija se može raditi automatski (implicitna konverzija) ili pod kontrolom programera (eksplicitna konverzija).

2.2.11.1 Implicitna konverzija Dvije su situacije u kojima se primjenjuje implicitna konverzija:

1. pri izračunavanju vrijednosti izraza 2. pri dodjeljivanju vrijednosti varijabli.

Primjer 2.2.11.1

double x = 12.34; int y = 10; x = x + y;

U gornjem primjeru pri računanju vrijednosti x + y dolazi do implicitne konverzije podatka x u tip double. Obrnuta konverzija u programskom jeziku C# nije dopuštena, jer se inače ne bi sačuvala preciznost podataka. Implicitne konverzije najčešće se primjenjuju kod numeričkih tipova podataka. Tip Može se implicitno konvertirati u sbyte short, int, long, float, double, decimal byte short, ushort, int, uint, long, ulong, float, double, decimal short int, long, float, double, decimal ushort int, uint, long, ulong, float, double, decimal int long, float, double, decimal uint long, ulong, float, double, decimal long float, double, decimal char ushort, int, uint, long, ulong, float, double, decimal float double ulong float, double, decimal

2.2.11.2 Eksplicitna konverzija Eksplicitna konverzija provodi se operatorom cast ili korištenjem klase Convert. Primjer 2.2.11.2 Ako pokušate prevesti sljedeći kod

int x;



double y = 5.32; x = y;

kompajler će javiti grešku:

Cannot implicitly convert type 'double' do 'int' Ovaj problem možete riješiti eksplicitnom konverzijom pomoću operatora cast:

x = (int)y; ali morate biti svjesni da tu može doći do gubitka informacije jer, naravno, kad podatak tipa double konvertiramo u tip int, njegov decimalni dio jednostavno se odbacuje. Dakle, operator cast upotrebljava se tako da se u zagradama navede tip u koji želimo konvertirati vrijednost izraza koji slijedi za operatorom. Dopušteno "kastanje" numeričkih tipova podataka slijedi u tablici: Tip Može se eksplicitno konvertirati u sbyte byte, ushort, uint, ulong, char byte sbyte, char short sbyte, byte, ushort, uint, ulong, char ushort sbyte, byte, short, char int sbyte, byte, short, ushort, uint, ulong, char uint sbyte, byte, short, ushort, int, char long sbyte, byte, short, ushort, int, uint, ulong, char ulong sbyte, byte, short, ushort, int, uint, long, char char sbyte, byte, short float sbyte, byte, short, ushort, int, uint, long, ulong, char, decimal double sbyte, byte, short, ushort, int, uint, long, ulong, char, float,

decimal decimal sbyte, byte, short, ushort, int, uint, long, ulong, char, float,

double Primjer 2.2.11.3

int x = 1; string s1 = (string) x; string s2 = "2"; int y = (int)s2;

Prevođenjem navedenog koda dobili biste sljedeće poruke o greškama:

Cannot convert type 'int' to 'string' Cannot convert type 'string' to 'int'

Eksplicitne konverzije iz ovog primjera nije moguće provesti operatorom cast, već morate upotrijebiti neku od metoda klase Convert.



U skladu s tim, prethodni primjer mogli biste prepraviti na sljedeći način:

int x = 1; string s1 = Convert.ToString(x); string s2 = "2"; int y = Convert.ToInt32(s2);

Naravno, eksplicitna konverzija Convert.ToInt32(s2) bit će uspješna samo ako string s2 predstavlja ispravno zapisani cijeli broj. Konverziju Convert.ToString(x), pak, niste ni morali striktno provoditi, jer zapravo sve strukture kojima su predstavljeni osnovni tipovi sadrže metodu ToString. Primjer 2.2.11.4

int x = 1; string s = x.ToString();

Documents

C# i NET Framework 4 0 Prirucnik-potpuna verzija final · Str.11 § §C# I .NET FRAMEWORK 2.0 Zagreb - Maksimirska 58a § ALGEBRA § 2.2 Klasa, objekt, struktura 2.2.1 Klasa, objekt