21. Objasniti pojam stanja objekta. Navesti primere i nacrtati dijagrame.

Pojam stanja objekta je ključni koncept u objektno-orijentisanom programiranju (OOP) koji se odnosi na
trenutno svojstvo i ponašanje objekta u određenom trenutku. Svaki objekt u OOP-u može se nalaziti u
određenom stanju, što je rezultat interakcija i promena koje se događaju tokom vremena.

Evo primera i dijagrama koji ilustruju pojam stanja objekta:

Primer 1: Stanje Svjetiljke

Recimo da imamo klasu "Svjetiljka" u OOP-u. Svjetiljka može biti u različitim stanjima, kao što su
"uključena" ili "isključena".

+----------------------+
| Svjetiljka |
+----------------------+
| - stanje: boolean |
+----------------------+
| + ukljuci() |
| + iskljuci() |
+----------------------+

U ovom primeru, objekat klase "Svjetiljka" može biti u stanju "uključena" ili "isključena" u zavisnosti od
toga koje metode (npr. "ukljuci()" ili "iskljuci()") pozivamo nad njim. Stanje objekta "Svjetiljka" se menja
tokom vremena u skladu sa pozivima ovih metoda.

22. Navesti elemente kojima je opisan objekat u OOP. Navesti primere i nacrtati dijagrame.

23. Navesti primere objekata u programiranju koji ne predstavljaju fizičke predmete u stvarnom svetu. Nacrtati
dijagrame sa elementima objekata.

Objekti u programiranju ne moraju nužno predstavljati fizičke predmete iz stvarnog sveta; oni mogu
predstavljati apstraktne ili konceptualne entitete. Evo nekoliko primera takvih objekata i dijagrama sa
elementima objekata:

Primer 1: Korisnik

Objekt "Korisnik" može predstavljati korisnika sistema ili aplikacije. Ovaj objekat može sadržavati
informacije o korisniku kao što su ime, e-mail adresa i uloga.

plaintext
+---------------------+
| Korisnik |
+---------------------+
| - ime: string |
| - email: string |
| - uloga: string |
+---------------------+
| + prijaviSe() |
| + promeniLozinku() |
+---------------------+

Primer 2: Poruka
Objekt "Poruka" može predstavljati poruku koja se šalje u komunikaciji između korisnika. Ovaj objekat
može sadržavati informacije kao što su sadržaj poruke, datum slanja i status isporuke.

plaintext
+---------------------+
| Poruka |
+---------------------+
| - sadrzaj: string |
| - datum: date |
| - status: string |
+---------------------+
| + posalji() |
| + prikazi() |
+---------------------+

Primer 3: Bankovni Račun

Objekt "Bankovni Račun" može predstavljati bankovni račun korisnika. Ovaj objekat može sadržavati
informacije kao što su saldo, broj računa i istorija transakcija.

plaintext
+---------------------+
| Bankovni Račun |
+---------------------+
| - brojRačuna: string|
| - saldo: decimal |
| - transakcije: [] |
+---------------------+
| + uplati() |
| + podigni() |
+---------------------+

Ovi primeri prikazuju objekte koji ne predstavljaju fizičke predmete u stvarnom svetu, već konceptualne
entitete koji imaju svoje atribute i metode. Dijagrami klasa prikazuju strukturu ovih objekata i kako su
atributi i metode organizovani unutar njih.

24. Objasniti vezu i razlike između pojmova Klasa i Objekat u OOP. – 6. pitanje PONOVLJENO *

25. Veza između klase i objekta. Pojam instance. Primere ilustrovati dijagramima. – 13 .pitanje PONOVLJENO *

26. Pojam enkapsulacije. Navesti koristi u dizajnu softvera koje se dobijaju primenom enkapsulacije. Pokazati kako se
enkapsulacija predstavlja na dijagramu klasa. -

27. Objasniti koncept nasleđivanja u OOP. Navesti i objasniti koje su koristi od primene koncepta nasleđivanja u
dizajnu softvera. Ilustrovati primerom pomoću dijagrama klasa.

28. Objasniti pojmove Superclass i Subclass. Ilustrovati primerima.

Superclass i Subclass su koncepti u objektno-orijentisanom programiranju koji se odnose na hijerarhiju

klasa.
 1. Superclass (Nadklasa): Superclass, ili nadklasa, je klasa koja se nalazi na višem nivou u hijerarhiji
klasa. To je opšta klasa koja može da sadrži zajedničke osobine i metode koje će biti nasleđene od
strane jedne ili više podklasa. Superclass definiše osnovne karakteristike i ponašanje.
2. Subclass (Podklasa): Subclass, ili podklasa, je klasa koja nasleđuje osobine i metode od nadklase.
Podklasa može dodatno proširiti ili predefinisati metode koje je nasledila od nadklase. Podklase se
koriste za specifičnije implementacije ili dodatne osobine koje su jedinstvene za tu klasu.

Evo primera koji ilustruju koncepte Superclass i Subclass:

Primer sa Geometrijskim Oblicima:

Pretpostavimo da imamo Superclass "Oblik" koja predstavlja opšti oblik. Ova klasa može da sadrži metode
kao što su "povrsina()" i "obim()" koje su zajedničke svim geometrijskim oblicima.

+---------+
| Oblik |
+---------+
| povrsina() |
| obim() |
+---------+

Sada možemo kreirati Subclasses koje nasleđuju od nadklase "Oblik", ali predstavljaju specifične oblike kao
što su "Krug" i "Kvadrat". Ove Subclasses mogu predefinisati metode "povrsina()" i "obim()" kako bi se
prilagodile svakom konkretnom obliku.

+---------+
| Oblik |
+---------+
| povrsina() |
| obim() |
+---------+
^
|
+---------+
| Krug |
+---------+
| povrsina() |
| obim() |
+---------+

+---------+
| Kvadrat |
+---------+
| povrsina() |
| obim() |
+---------+

U ovom primeru, "Oblik" je Superclass, a "Krug" i "Kvadrat" su Subclasses. Subclasses nasleđuju metode
"povrsina()" i "obim()" od Superclass-a, ali ih mogu predefinisati kako bi se prilagodile svakom obliku.

Ovaj koncept omogućava da se zajednički kod deli između različitih klasa, a istovremeno omogućava
specifičnim klasama da imaju svoje jedinstvene osobine i ponašanje.

29. Objasniti na primeru sa dijagramima vezu između pojmova nasleđivanje i polimorfizam. Objasniti koncept
Overriding.
Da bismo bolje razumeli vezu između nasleđivanja, polimorfizma i koncepta overridinga, koristićemo
primer sa dijagramima klasa.

Primer sa Geometrijskim Oblicima:

Pretpostavimo da imamo hijerarhiju klasa za geometrijske oblike. Imamo Superclass "Oblik" koji
predstavlja opšti oblik i Subclasses "Krug" i "Kvadrat" koji predstavljaju specifične oblike. Sada ćemo
dodati koncept polimorfizma i overridinga.

Dijagram klasa:

plaintext
+---------+
| Oblik |
+---------+
| povrsina() |
| obim() |
+---------+
^
|
+---------+
| Krug |
+---------+
| povrsina() |
| obim() |
+---------+

+---------+
| Kvadrat |
+---------+
| povrsina() |
| obim() |
+---------+

Sada, zamislite da imamo funkciju koja računa površinu i obim za različite oblike. Upotrebićemo
polimorfizam da bismo omogućili da ista funkcija radi za različite tipove oblika.

python
def racunajPovrsinuIObim(oblik):
povrsina = oblik.povrsina()
obim = oblik.obim()
return povrsina, obim

Sada možemo koristiti ovu funkciju sa različitim objektima različitih klasa:

python
krug = Krug(5) # Kreiranje objekta klase Krug sa poluprečnikom 5
kvadrat = Kvadrat(4) # Kreiranje objekta klase Kvadrat sa dužinom stranice 4

povrsina_kruga, obim_kruga = racunajPovrsinuIObim(krug)

povrsina_kvadrata, obim_kvadrata = racunajPovrsinuIObim(kvadrat)

print("Površina kruga:", povrsina_kruga)

print("Obim kruga:", obim_kruga)

print("Površina kvadrata:", povrsina_kvadrata)

print("Obim kvadrata:", obim_kvadrata)

U ovom primeru, funkcija racunajPovrsinuIObim prima objekat klase "Oblik" kao argument, ali zbog
polimorfizma će se pravilno ponašati i za objekte klase "Krug" i "Kvadrat". Ovo omogućava istoj funkciji da
radi sa različitim tipovima objekata.
Koncept overridinga se odnosi na situaciju kada Subclass (npr. "Krug" ili "Kvadrat") reimplementira
(predefiniše) metod koji je već definisan u Superclass-u ("Oblik"). Na primer, ako želimo da svaka Subclass
ima svoju specifičnu implementaciju metoda povrsina(), možemo ih predefinisati u svakoj Subclass-i. Ovo
omogućava da se ponašanje metoda prilagodi specifičnostima svake Subclass-e.

Sve u svemu, nasleđivanje, polimorfizam i overriding su koncepti koji omogućavaju da se kreiraju

fleksibilni i efikasni objektno-orijentisani modeli, omogućavajući deljenje koda, prilagodljivost i ponovnu
upotrebu.

30. Navesti i objasniti osnovne korake (5) analize i dizajna Objektno orijentisanog sistema koje treba uraditi pre
početka pisanja koda.

1. PRIKUPLJANJE ZAHTEVA (ŠTA TA APLIKACIJA TREBA DA RADI) MAGLOVITE IDEJE

2. OPIŠEŠ ALIKACIJU PROSTIM JEZIKOM USE CASE , USER STORIES

3. IDENTIFIKUJEM NAJVAŽNIJE OBJEKTE

4. FORMALNO OPISUJEŠ INTERAKCIJE IZMEDJU OBJEKATA

5. KREIRAMO DIJAGRAM KLASA

31. Osnovne smernice i metode za prikupljanje zahteva korisnika pri projektovanju aplikacije.

FUNKCIONALNI I NEFUNKCIONALNI ZAHTEVI. KRATKE PROSTE REČENICE

32. Use cases - dizajn aplikacije sa tačke gledišta korisnika. Smernice za sastavljanje Use cases. Objasniti pojmove
Title, Actor, Scenario. Napisati (na srpskom) jedan Use Case u aplikaciji po vašem izboru.

Use Case (Slučaj upotrebe) je tehnika u analizi sistema i dizajnu softvera koja pomaže definisanju
funkcionalnih zahteva aplikacije sa tačke gledišta korisnika. Use Case se fokusira na to šta korisnik može da
radi sa aplikacijom i kako sistem reaguje na korisničke interakcije.

Evo osnovnih smernica za sastavljanje Use Cases i objašnjenje ključnih termina:

1. Naslov (Title): Naslov Use Case-a treba jasno i sažeto da opiše šta se dešava u tom Use Case-u.
Naslov treba da bude jedinstven i opisno.
2. Aktor (Actor): Aktor je entitet koji interaguje sa sistemom. To može biti korisnik aplikacije, drugi
sistem, ili neki drugi entitet koji ima ulogu u Use Case-u. Aktor se obično označava i opisuje.
3. Scenario: Scenario je opis sekvence koraka ili interakcija između aktora i sistema u okviru
određenog Use Case-a. Scenario treba da bude dovoljno detaljan da se razumeju koraci koje korisnik
preduzima i kako sistem reaguje na te korake.

Evo primera Use Case-a za aplikaciju za rezervaciju bioskopskih karata:

Naslov: Rezervacija bioskopske karte

Aktor: Registrovani korisnik

Scenario:

1. Korisnik se prijavljuje na svoj nalog.

2. Korisnik pretražuje listu dostupnih filmova i izabira film koji želi da gleda.
 3. Korisnik bira datum i vreme projekcije za taj film.
4. Sistem prikazuje slobodna mesta u sali za odabrani film i projekciju.
5. Korisnik bira željeno sedište ili sedišta.
6. Korisnik potvrđuje rezervaciju.
7. Sistem rezerviše odabrana sedišta i generiše potvrdu rezervacije.
8. Korisnik prima potvrdu rezervacije putem e-maila.

Ovaj Use Case opisuje kako registrovani korisnik interaguje sa aplikacijom za rezervaciju bioskopskih
karata, uključujući sve korake od prijave do potvrde rezervacije. Ovaj scenarijo je koristan za definisanje
funkcionalnosti sistema i bolje razumevanje kako korisnici koriste aplikaciju.

33. Objasniti pojam Actor-a pri kreiranju Use Case scenarija. Objasniti razliku između primarnog i sekundarnog Actor-
a.

Aktor u kontekstu Use Case scenarija predstavlja entitet ili korisnika koji interaguje sa sistemom kako bi
izvršio određeni Use Case. Aktor je ključni element u definisanju Use Case scenarija, jer identifikuje ko su
korisnici ili entiteti koji će koristiti određeni Use Case i šta će od sistema tražiti ili očekivati.

Postoje dve osnovne vrste aktera:

1. Primarni Aktor (Primary Actor): Primarni aktor je ključni ili glavni korisnik Use Case-a. On je
entitet koji pokreće i inicira Use Case i ima direktnu korist od njega. Primarni aktor predstavlja
glavnu ulogu u izvršavanju Use Case-a. Na primer, u Use Case-u za rezervaciju bioskopske karte,
primarni aktor bi mogao biti "Registrovani korisnik" koji želi da rezerviše kartu.
2. Sekundarni Aktor (Secondary Actor): Sekundarni aktor je entitet koji može da interaguje sa
sistemom u okviru Use Case-a, ali nije glavni korisnik niti inicijator Use Case-a. Sekundarni aktor
obično pruža podršku ili ima neku manje važnu ulogu u izvršavanju Use Case-a. Na primer, u Use
Case-u za rezervaciju bioskopske karte, "Blagajnik" bi mogao biti sekundarni aktor koji pomaže u
prodaji i ispravci rezervacija, ali nije glavni korisnik.

Razlika između primarnog i sekundarnog aktora leži u njihovim ulogama i nivou značaja u kontekstu Use
Case-a. Primarni aktor je centralna figura koja pokreće Use Case i čiji su interesi direktno povezani sa
njegovim izvršavanjem, dok je sekundarni aktor obično prateći entitet ili podrška za primarnog aktora.

Identifikacija i jasno definisanje aktera su važni koraci pri kreiranju Use Case scenarija, jer pomažu u
razumevanju kako će različite uloge interagovati sa sistemom i šta se od sistema očekuje u određenim
situacijama.

34. Navesti pravila za pisanje Use Case scenarija. Napisati jedan Use case scenario za primer aplikacije po izboru.

Pravila za pisanje Use Case scenarija obuhvataju smernice i strukturu koja pomažu da scenariji budu jasni i
razumljivi. Evo nekoliko pravila za pisanje Use Case scenarija:

1. Koristite jasan i opisni naslov: Naslov Use Case-a treba da jasno opiše šta se dešava u scenariju.
Naslov treba da bude sažet i opisno.
2. Identifikujte aktore: Navesti sve aktere (korisnike ili entitete) koji su uključeni u Use Case.
Razlikujte između primarnih i sekundarnih aktera.
3. Definišite preduslove: Opišite uslove ili stanje sistema koji moraju biti ispunjeni pre nego što se Use
Case pokrene.
 4. Opis glavnih koraka: Detaljno opišite glavne korake koji se dešavaju u Use Case-u. Koraci treba da
budu jasno navedeni, počevši od inicijacije Use Case-a.
5. Opišite alternativne putanje: Identifikujte i opišite sve alternativne putanje ili korake koji se mogu
dogoditi u scenariju. Ovo uključuje greške, izuzetne situacije ili alternativne akcije koje korisnici
mogu preduzeti.
6. Navesti postuslove: Opišite stanje sistema nakon završetka Use Case-a. Koje promene ili akcije su
rezultat izvršavanja Use Case-a?
7. Koristite jasan jezik: Pisanje Use Case scenarija treba da bude sačinjeno od strane tima koristeći
jasan, razumljiv jezik. Izbegavajte tehnički žargon koji nije razumljiv korisnicima.
8. Koristite dijagrame i grafikone po potrebi: Ponekad je korisno koristiti dijagrame, grafikone ili
slike kako biste ilustrovali tok Use Case-a ili interakciju između aktera i sistema.

Evo primera Use Case scenarija za aplikaciju za online kupovinu proizvoda:

Naslov: Naručivanje proizvoda

Aktor: Registrovani kupac

Preduslovi: Kupac je prijavljen na svoj nalog i nalazi se na početnoj stranici prodavnice.

Glavni koraci:

1. Kupac pretražuje katalog proizvoda.

2. Kupac izabira proizvod koji želi da kupi.
3. Kupac dodaje proizvod u korpu.
4. Kupac pregleda sadržaj korpe i prilagođava količinu proizvoda po potrebi.
5. Kupac nastavlja na stranicu za naručivanje.
6. Kupac bira adresu isporuke i način plaćanja.
7. Kupac potvrđuje naručivanje.
8. Sistem generiše potvrdu narudžbine i šalje je na e-mail kupca.

Alternativna putanja:

 Ako proizvod nije dostupan, sistem obaveštava kupca i omogućava mu da izabere drugi proizvod.
 Ako korpa ostane prazna, kupac ne može da nastavi na stranicu za naručivanje i dobija obaveštenje.

Postuslovi: Narudžbina je uspešno zabeležena, proizvod je rezervisan, a kupcu je poslata potvrda

narudžbine na e-mail.

Ovaj Use Case scenarij opisuje proces narudžbine proizvoda u aplikaciji za online kupovinu sa svim
koracima, preduslovima i alternativnim putanjama. Ovaj scenarij je koristan za razumevanje kako kupci
koriste aplikaciju za naručivanje proizvoda.

35. Opisati postupak za identifikovanje klasa na osnovu Use Case scenarija. Prepoznavanje objekata i ponašanja.

Identifikacija klasa na osnovu Use Case scenarija je ključan korak u procesu dizajniranja softverskog
sistema. Ovaj proces uključuje identifikaciju klase objekata (objekti su instancirane klase) i ponašanja
(metode koje klase mogu da izvrše) kako bi se ostvarili funkcionalni zahtevi definisani Use Case
scenarijima. Evo postupka za identifikaciju klasa na osnovu Use Case scenarija:
 1. Analizirajte Use Case scenarije: Prvo, detaljno analizirajte sve Use Case scenarije kako biste
razumeli interakcije između aktera i sistema. Identifikujte glavne korake, preduslove, alternativne
putanje i postuslove za svaki Use Case.
2. Identifikujte objekte: Na osnovu analize scenarija, identifikujte objekte ili entitete koji su relevantni
za izvršavanje Use Case-a. Objekti su stvarni ili apstraktni entiteti koji imaju svoja svojstva i
ponašanja. Na primer, u Use Case-u za rezervaciju bioskopske karte, objekti mogu biti "Korisnik",
"Film", "Projekcija", "Karta", itd.
3. Definišite svojstva objekata: Za svaki identifikovani objekat, razmislite o njegovim svojstvima ili
atributima. Svojstva su informacije koje objekti čuvaju o sebi. Na primer, objekat "Karta" može
imati svojstva kao što su "Broj sedišta", "Cena", "Status rezervacije", itd.
4. Identifikujte ponašanje objekata: Za svaki objekat identifikujte ponašanja ili metode koje objekti
mogu da izvrše. Ponašanja objekata su akcije koje se primenjuju na objekte ili akcije koje objekti
mogu da izvrše. Na primer, objekat "Karta" može imati ponašanja kao što su "Rezervacija",
"Otkazivanje rezervacije", "Izračunavanje cene", itd.
5. Definište klase: Na osnovu identifikovanih objekata, njihovih svojstava i ponašanja, definište klase.
Klase predstavljaju šablone ili predloške za objekte iste vrste. Svaka klasa ima svojstva i metode koji
su zajednički za sve instance te klase. Na primer, klasa "Karta" može sadržavati svojstva kao što su
"Broj sedišta" i "Cena", kao i metode kao što su "Rezervacija" i "Otkazivanje rezervacije".
6. Usaglasite klase sa Use Case scenarijima: Proverite da li klase koje ste identifikovali odgovaraju
Use Case scenarijima i da li mogu da zadovolje funkcionalne zahteve. Ako su potrebne dodatne klase
ili ako neke klase nisu relevantne, prilagodite dizajn.
7. Razmotrite odnose između klasa: Na kraju, razmotrite kako se klase međusobno povezuju i
komuniciraju kako biste postigli funkcionalni sistem. Razmotrite koncepte poput nasleđivanja,
asocijacija i agregacija ako su potrebni za modeliranje odnosa između klasa.

Ovaj postupak identifikacije klasa na osnovu Use Case scenarija pomaže da se precizno definišu klase i
njihova ponašanja kako bi se stvorio dobro dizajniran softver koji zadovoljava potrebe korisnika.

36. Crtanje dijagrama klasa. Nacrtati jednu klasu za aplikaciju po izboru. Pravila za imenovanje klase, atributa,
ponašanja. Objasniti kako se na dijagramu označava vidljivost članova klase.

Crtanje dijagrama klasa je važan korak u dizajniranju softverskog sistema. Evo primera kako nacrtati
dijagram klase za klasu "Korisnik" u aplikaciji za upravljanje korisničkim nalozima. Ovde ćemo pratiti
konvencije za imenovanje klasa, atributa i metoda, kao i označavanje vidljivosti članova klase:

1. Ime Klase: Ime klase treba da bude jasno i opisno. U ovom primeru, ime klase je "Korisnik".
2. Atributi Klase: Atributi su svojstva ili varijable koje klase čuvaju o svojim instancama. Svaki
atribut ima ime i tip podatka. Primeri atributa za klasu "Korisnik" mogu uključivati:
o id: int - jedinstveni identifikator korisnika.
o ime: string - ime korisnika.
o email: string - e-mail adresa korisnika.
o lozinka: string - lozinka korisnika.
3. Ponašanje Klase (Metode): Metode su funkcije ili akcije koje klase mogu da izvrše. Svaka metoda
ima ime, parametre (ako su potrebni) i tip povratne vrednosti. Primeri metoda za klasu "Korisnik"
mogu uključivati:
o prijaviSe(username: string, password: string): bool - metoda za prijavljivanje
korisnika na nalog.
o promeniLozinku(novaLozinka: string): void - metoda za promenu lozinke korisnika.
o izmeniPodatke(ime: string, email: string): void - metoda za izmenu informacija o
korisniku.
 4. Vidljivost Članova Klase: Vidljivost članova klase određuje ko može pristupiti atributima i
metodama klase. U dijagramu klasa, vidljivost se označava pomoću simbola. Evo nekoliko najčešćih
vidljivosti:
o + - Public (Javna vidljivost): Atributi i metode sa ovom oznakom su vidljivi izvan klase i
mogu se koristiti iz drugih klasa.
o - - Private (Privatna vidljivost): Atributi i metode sa ovom oznakom su vidljivi samo unutar
klase i ne mogu se koristiti iz drugih klasa.
o # - Protected (Zaštićena vidljivost): Atributi i metode sa ovom oznakom su vidljivi samo u
klasi i njenim podklasama (ako postoje).

Dijagram klase za klasu "Korisnik" može izgledati ovako:

php
+-----------------------------------+
| Korisnik |
+-----------------------------------+
| - id: int |
| - ime: string |
| - email: string |
| - lozinka: string |
+-----------------------------------+
| + prijaviSe(username: string, |
| password: string): bool|
| + promeniLozinku(novaLozinka: |
| string): void |
| + izmeniPodatke(ime: string, |
| email: string): void|
+-----------------------------------+

U ovom dijagramu klasa, atributi imaju privatnu vidljivost (-), dok su metode javno vidljive (+). Ovo zavisi
od dizajna klase i toga koje atribute i metode želite da budu dostupne izvan klase.

37. Objasniti postupak kreiranja objekata od klase. Nacrtati dijagram klase i napisati naredbu za kreiranje novog
objekta.

Kreiranje objekata od klase je proces instanciranja klase kako biste stvorili konkretan objekat koji možete
koristiti u vašem programu. Evo postupka za kreiranje objekata od klase:

1. Dizajniranje Klase: Prvo, morate dizajnirati klasu koja će služiti kao predložak za objekte koje
želite da kreirate. Klasa definiše svojstva (atribute) i ponašanja (metode) koje će objekti imati.
2. Instanciranje Klase: Da biste stvorili objekat od klase, koristite proces koji se naziva
"instanciranje". Ovo se obično radi pomoću ključne reči new u programskom jeziku.
3. Pristup Objektu: Nakon što ste stvorili objekat, možete pristupiti njegovim svojstvima i metodama
koristeći tačku notaciju (objekat.svojstvo ili objekat.metoda()), gde je objekat instanca klase.

Evo primera kako to može izgledati sa dijagramom klase i naredbom za kreiranje objekta u programskom
jeziku kao što je Java:

Dijagram klase:

plaintext
+--------------------------------+
| Osoba |
+--------------------------------+
| - ime: string |
| - godine: int |
+--------------------------------+
| + setIme(ime: string): void |
| + setGodine(godine: int): void |
| + prikaziPodatke(): void |
+--------------------------------+

Naredba za kreiranje objekta u Java programskom jeziku:

public class Main {

public static void main(String[] args) {
// Kreiranje objekta od klase Osoba
Osoba osoba1 = new Osoba();

// Postavljanje svojstava objekta

osoba1.setIme("Ana");
osoba1.setGodine(30);

// Pristup metodi objekta

osoba1.prikaziPodatke();
}
}

U ovom primeru, Osoba je klasa sa svojstvima ime i godine, kao i metodama setIme, setGodine i
prikaziPodatke. Naredba Osoba osoba1 = new Osoba(); instancira novi objekat klase Osoba, a zatim
postavljamo svojstva objekta i pozivamo metodu prikaziPodatke().

Ovako se stvara i koristi objekt od klase.

38. Pojam i namena konstruktora u objektno orijentisanom programiranju. Pravilo imenovanja konstruktora. Šta je
podrazumevani konstruktor? Nacrtati primer dijagrama klase i napisati naredbe za kreiranje ojekata.

Pojam konstruktora: Konstruktor je posebna metoda u objektno orijentisanom programiranju (OOP) koja
se koristi za inicijalizaciju objekta određene klase. Konstruktor ima isto ime kao i klasa koju inicijalizuje i
poziva se prilikom kreiranja objekta te klase. Glavna svrha konstruktora je postavljanje početnih vrednosti
svojstava objekta ili izvođenje drugih inicijalizacionih operacija.

Pravilo imenovanja konstruktora: Ime konstruktora mora biti isto kao ime klase. U mnogim programskim
jezicima, konstruktor nema eksplicitni povratni tip (ni "void" ni drugi tipovi), što ga razlikuje od običnih
metoda. Konstruktor se automatski poziva prilikom kreiranja objekta i obavlja inicijalizaciju.

Podrazumevani konstruktor: Ako klasa nema definisan konstruktor, programski jezik može automatski
generisati podrazumevani konstruktor. Podrazumevani konstruktor nema parametre i obično postavlja
početne vrednosti na podrazumevane vrednosti za svojstva klase (nule, false, null, itd.).

Evo primera dijagrama klase i naredbi za kreiranje objekata sa konstruktorom u programskom jeziku kao što
je Java:

Dijagram klase:

plaintext
+-------------------+
| Osoba |
+-------------------+
| - ime: string |
| - godine: int |
+-------------------+
| + Osoba() |
| + Osoba(ime: string, godine: int) |
| + prikaziPodatke(): void |
+-------------------+

Kreiranje objekta sa konstruktorom:

java
public class Main {
public static void main(String[] args) {
// Kreiranje objekta koristeći podrazumevani konstruktor
Osoba osoba1 = new Osoba();

// Postavljanje svojstava objekta

osoba1.setIme("Ana");
osoba1.setGodine(30);

// Pristup metodi objekta

osoba1.prikaziPodatke();

// Kreiranje objekta koristeći konstruktor sa parametrima

Osoba osoba2 = new Osoba("Marko", 25);

// Pristup metodi objekta

osoba2.prikaziPodatke();
}
}

39. Pojam i namena konstruktora u objektno orijentisanom programiranju. Pravilo imenovanja konstruktora.
Podrazumevani konstruktor i konstruktor sa parametrima. Nacrtati primer dijagrama klase i napisati naredbe za
kreiranje ojekata. – 38. pitanje

40. Na primeru klase po izboru objasniti koncept Constructor overloading. Nacrtati primer dijagrama klase i napisati
naredbe za kreiranje objekata.

Constructor overloading je koncept u objektno orijentisanom programiranju gde klasa može imati više od
jednog konstruktora sa različitim brojem ili tipom parametara. Ovo omogućava kreiranje objekata sa
različitim početnim vrednostima ili omogućava fleksibilniju upotrebu klase.

Evo primera sa dijagramom klase i naredbama za kreiranje objekata koristeći konstruktor overloading.
Uzmimo klasu "Automobil" kao primer:

Dijagram klase:

+---------------------+
| Automobil |
+---------------------+
| - marka: string |
| - model: string |
| - godiste: int |
+---------------------+
| + Automobil() |
| + Automobil(marka: string) |
| + Automobil(marka: string, model: string) |
| + Automobil(marka: string, model: string, godiste: int) |
| + prikaziPodatke(): void |
+---------------------+

41. Statički članovi klase. Objasniti namenu i navesti primer primene. Primer ilustrovati dijagramima.

Statički članovi klase (često nazivani i statičke promenljive ili metode) su članovi klase koji pripadaju samoj
klasi, a ne pojedinačnim instancama klase. To znači da se ista vrednost ili metoda može koristiti sa svim
instancama klase, a ne samo sa jednim objektom. Statički članovi se često koriste za čuvanje informacija
koje su zajedničke svim instancama klase ili za pružanje funkcionalnosti koja nije specifična za pojedinačne
objekte.

Namena statičkih članova klase:

1. Deljenje informacija: Statičke promenljive omogućavaju deljenje podataka između svih instanci
klase. Na primer, brojač instanci klase može se održavati kao statička promenljiva kako bi se pratio
broj kreiranih objekata.
2. Pravljenje pomoćnih funkcija: Statičke metode se koriste za pružanje funkcionalnosti koja nije
vezana za konkretne instance klase, kao što su metode za matematičke operacije, pretvaranje
podataka ili provjera stanja sistema.
3. Konstante: Statičke promenljive se često koriste za definisanje konstantnih vrednosti koje su
relevantne za klasu.

Evo primera primene statičkih članova klase sa dijagramom klase:

Dijagram klase:

plaintext
+------------------+
| Radnik |
+------------------+
| - ime: string |
| - prezime: string|
| - radniBroj: int |
| + brojac: int (static) |
+------------------+
| + Radnik(ime: string, prezime: string) |
| + prikaziPodatke(): void |
+------------------+

42. Statički atributi i statičke metode klase. Objasniti na primeru aplikacije za banku i klase računa.
Pokazati kako se statički članovi označavaju na dijagramu klase.

Statički atributi i metode klase su članovi klase koji pripadaju klasi kao celini, a ne pojedinačnim instancama
klase. Ovo znači da se statički atributi dele između svih objekata kreiranih iz te klase, a statičke metode su
dostupne bez potrebe za instanciranjem objekta klase.

Pogledajmo primer aplikacije za banku sa klasom računa kako bismo bolje razumeli koncept statičkih
članova klase.

Dijagram klase za klasu "Račun" u banci:

+----------------+
| Račun |
+----------------+
| - brojRačuna: int |
| - saldo: double |
| - vlasnik: string |
| + kamatnaStopa: double (static) |
+----------------+
| + Račun(brojRačuna: int, saldo: double, vlasnik: string) |
| + uplati(iznos: double): void |
| + isplati(iznos: double): void |
| + prikažiStanje(): void |
+----------------+

U ovom dijagramu klase, imamo klasu "Račun" sa tri instancirana atributa (broj računa, saldo i vlasnik) i
jednim statičkim atributom (kamatna stopa). Takođe, imamo tri metode koje rade sa instanciranim
atributima: "uplati", "isplati" i "prikažiStanje".

43. Objasniti koncepta prednosti koje su dobijene u programiranju pomoću nasleđivanja. Ilustrovati dijagramom
klasa sa atributima i metodama za aplikaciju po izboru.

Nasleđivanje je ključni koncept u objektno orijentisanom programiranju (OOP) koji omogućava kreiranje
nove klase (podklase ili potklase) na osnovu postojeće klase (natklase ili roditeljske klase). Prednosti
nasleđivanja u programiranju uključuju:

1. Reutilizacija koda: Nasleđivanje omogućava ponovnu upotrebu koda koji je već napisan u
roditeljskoj klasi. Ovo smanjuje potrebu za ponovnim pisanjem istog koda i olakšava održavanje
programa.
2. Struktura i organizacija koda: Nasleđivanje pomaže u organizaciji koda jer omogućava grupisanje
sličnih atributa i metoda u logičke celine (klase). Ovo olakšava razumevanje i upravljanje
programom.
3. Proširenje funkcionalnosti: Podklase mogu dodavati nove atribute i metode ili prepravljati
postojeće metode iz roditeljske klase. Ovo omogućava prilagođavanje i proširenje funkcionalnosti
programa.
4. Hierarhijska struktura: Nasleđivanje može stvarati hierarhijsku strukturu klasa, gde se jedna klasa
može nasleđivati od druge, čime se omogućava organizacija različitih nivoa apstrakcije.
5. Polimorfizam: Nasleđivanje omogućava primenu polimorfizma, gde se objekti podklasa mogu
koristiti kao objekti roditeljske klase. Ovo olakšava generičko programiranje i povećava
fleksibilnost.

Evo jednostavnog dijagrama klasa sa atributima i metodama za aplikaciju "Geometrijske Figure" kao primer
nasleđivanja:

Dijagram klasa:

plaintext
+------------------+
| Geometrija |
+------------------+
| |
| + izračunajPovršinu(): double |
| + izračunajObim(): double |
+------------------+
^
|
 |
+-------------------+
| Pravougaonik |
+-------------------+
| - dužina: double |
| - širina: double |
+-------------------+
| + Pravougaonik(dužina: double, širina: double) |
| + izračunajPovršinu(): double (override) |
| + izračunajObim(): double (override) |
+-------------------+
^
|
|
+-------------------+
| Krug |
+-------------------+
| - poluprečnik: double |
+-------------------+
| + Krug(poluprečnik: double) |
| + izračunajPovršinu(): double (override) |
| + izračunajObim(): double (override) |
+-------------------+

U ovom dijagramu, "Geometrija" je apstraktna klasa koja definiše osnovne metode za izračunavanje
površine i obima. "Pravougaonik" i "Krug" su podklase koje nasleđuju "Geometrija" i prepravljaju
(override) metode za izračunavanje površine i obima kako bi se prilagodile svojim specifičnim
geometrijskim oblicima.

Prednost ovog nasleđivanja je to što možemo koristiti zajednički interfejs "Geometrija" za sve geometrijske
oblike, a istovremeno omogućavamo svakom obliku da ima svoje specifične metode za izračunavanje
površine i obima.

44. Koncept nasleđivanja. Objasniti i ilustrovati primerom dijagrama klasa za aplikaciju po izboru. Objasniti koncept
method overriding.

45. Objasniti pojam i namenu apstraktnih klasa. Ilustrovati dijagramom klasa za aplikaciju po izboru.

Apstraktne klase su klase koje se ne mogu instancirati direktno, već služe kao osnova za kreiranje
konkretnih (instancirajućih) podklasa. Glavna namena apstraktnih klasa je da definišu zajedničke atribute i
metode koje će biti nasleđene od strane podklasa. Ove zajedničke metode mogu imati implementaciju ili ne,
a podklase su obavezne da implementiraju sve apstraktne metode iz roditeljske apstraktne klase.

Prednosti apstraktnih klasa uključuju:

1. Organizacija koda: Apstraktne klase omogućavaju organizaciju koda tako da se zajedničke

funkcionalnosti grupišu na jednom mestu.
2. Definisanje zajedničkog interfejsa: Apstraktne klase definišu zajednički interfejs ili kontrakt koji
podklase moraju da ispunjavaju.
3. Pravila za nasleđivanje: Apstraktne klase mogu postaviti pravila i uslove koje podklase moraju da
ispoštuju, obezbeđujući doslednost u dizajnu.

Evo primera dijagrama klasa za aplikaciju "Životinje" koristeći apstraktne klase:

Dijagram klasa:
+-------------------+
| Životinja |
+-------------------+
| - ime: string |
+-------------------+
| + Životinja(ime: string) |
| + zvuk(): void (apstraktna) |
+-------------------+
^
|
+-------------------+
| Pas |
+-------------------+
| + Pas(ime: string) |
| + zvuk(): void (override) |
+-------------------+
^
|
+-------------------+
| Mačka |
+-------------------+
| + Mačka(ime: string) |
| + zvuk(): void (override) |
+-------------------+

U ovom dijagramu, "Životinja" je apstraktna klasa koja definiše atribut "ime" i apstraktnu metodu "zvuk()".
"Pas" i "Mačka" su konkretne podklase koje nasleđuju "Životinja" i pružaju svoju implementaciju za
apstraktnu metodu "zvuk()".

Korišćenjem apstraktnih klasa, možemo zajedničke osobine i ponašanja životinja grupisati u "Životinja"
klasu, a zatim dodati specifične detalje u podklasama kao što su "Pas" i "Mačka". Ovo olakšava organizaciju
i održavanje koda, posebno u situacijama gde postoji mnogo različitih vrsta životinja sa zajedničkim
osobinama.

46. Objasniti pojam i namenu interfejsa. Objasniti kako se interfejs razlikuje od klase i kakva je veza klasa i interfejsa.
Ilustrovati dijagramom klasa za aplikaciju po izboru.

Interfejs je koncept u objektno-orijentisanom programiranju (OOP) koji definiše apstraktne metode, ali ne
sadrži konkretne implementacije tih metoda. Interfejsi se koriste za deklaraciju metoda koji moraju biti
prisutni u klasama koje ih implementiraju. Namena interfejsa je da obezbedi zajednički set metoda koji se
može koristiti u različitim klasama, čime se omogućava konzistentno ponašanje i omogućava polimorfizam.

Glavne karakteristike interfejsa su:

1. Apstraktnost: Interfejsi definišu apstraktne metode, što znači da ne sadrže konkretne

implementacije ovih metoda. Samo deklarišu metode i njihove potpise.
2. Implementacija: Klase koje implementiraju interfejs moraju pružiti konkretne implementacije svih
metoda definisanih u tom interfejsu.
3. Višestruko nasleđivanje: Klase mogu implementirati više interfejsa, čime se omogućava višestruko
nasleđivanje metoda iz različitih interfejsa.

S druge strane, klasa je konkretna struktura koja definiše svoje atribute (promenljive članice) i metode
(funkcije članice). Klase mogu sadržavati konkretne implementacije metoda.

Veza između klase i interfejsa je da klasa može implementirati jedan ili više interfejsa. To znači da će klasa
obezbediti konkretne implementacije svih metoda definisanih u tim interfejsima. Implementiranje interfejsa
je način da se obezbedi određeno ponašanje klase.
Evo ilustracije toga pomoću dijagrama klasa za jednostavnu aplikaciju koja sadrži klase Automobil i Avion,
zajedno sa interfejsom Vozilo:

plaintext
Vozilo (Interfejs)
/ \
Automobil Avion

U ovom dijagramu, Vozilo je interfejs koji definiše apstraktne metode kao što su ubrzaj(), uspori() i
zaustavi(). Klase Automobil i Avion implementiraju ovaj interfejs i pružaju konkretne implementacije
ovih metoda.

Na primer, Automobil može implementirati metodu ubrzaj() tako da automobil ubrzava kretanje, dok
Avion može implementirati ovu metodu tako da avion ubrzava uzlijetanje. Obe klase imaju zajednički
interfejs Vozilo, ali pružaju različite implementacije za svoje specifične potrebe.

47. Objasniti pojmove kompozicije i agregacije u OOP. Sličnost i razlika. Ilustrovati UML dijagramima za primer po
izboru.

Kompozicija i agregacija su dva različita koncepta za modeliranje odnosa između klasa u objektno
orijentisanom programiranju (OOP). Oba koncepta se koriste za prikazivanje veza između objekata, ali
imaju različite semantičke značajke i trajanja.

Agregacija:

 Agregacija se koristi kada postoji "celina-ceo" odnos između dve klase, gde jedan objekat (celina)
sadrži druge objekte (delovi), ali ti delovi mogu postojati i nezavisno od celine.
 Veza između celine i dela nije čvrsta i delovi se mogu koristiti u više različitih celina.
 Ako se instanca celine uništi, instance delova obično ostaju netaknute.
 U UML dijagramima, agregacija se obično predstavlja strelicom koja ide od celine ka delu.

Kompozicija:

 Kompozicija se koristi kada postoji "celina-ceo" odnos između dve klase, ali u ovom slučaju, delovi
ne mogu postojati nezavisno od celine.
 Veza između celine i dela je čvrsta, što znači da delovi ne postoje bez celine i uništavanje instance
celine obično povlači uništavanje instanci delova.
 Kompozicija se često koristi za modeliranje hijerarhija objekata, gde se članovi hijerarhije smatraju
delovima.
 U UML dijagramima, kompozicija se takođe obično predstavlja strelicom koja ide od celine ka delu,
ali sa oznakom "crna dijamantska" strelica na strani celine.

Evo primera sa UML dijagramima:

Primer Agregacije:

plaintext
+-----------+ +----------+
| Auto | -------> | Motor |
+-----------+ +----------+
U ovom primeru, "Auto" agregira "Motor". Auto može imati motor, ali motor može postojati i nezavisno od
automobila.

Primer Kompozicije:

plaintext
+-----------+ +----------+
| Računar | -------> | CPU |
+-----------+ +----------+

U ovom primeru, "Računar" komponuje "CPU". Računar se sastoji od CPU-a, ali CPU ne može postojati
nezavisno od računara.

U suštini, razlika između kompozicije i agregacije je u čvrstoći veze i trajanju delova u odnosu na celinu.
Agregacija je slabija veza gde delovi mogu postojati nezavisno, dok je kompozicija čvršća veza gde delovi
ne mogu postojati bez celine.

48. Šta su Design Patterns i čemu služe. Ukratko objasniti Singleton Design Pattern.

Dizajn obrasci (Design Patterns) su rešenja za česte probleme u programiranju koji se ponavljaju iz projekta
u projekat. Oni predstavljaju proverene prakse i obrasce rešavanja problema koji su se tokom vremena
razvijali i dokumentovali u različitim programskim jezicima i okruženjima. Dizajn obrasci pomažu
programerima da rešavaju probleme na efikasan i održiv način, pružajući im uputstva i smernice za strukturu
i organizaciju koda.

Singleton Design Pattern je jedan od najjednostavnijih i najčešće korišćenih dizajn obrazaca. Glavna svrha
Singleton obrasca je da obezbedi da postoji samo jedna instanca određene klase u celom programu i da
omogući globalan pristup toj instanci.

Osnovne karakteristike Singleton obrasca su:

1. Jedinstvena instanca: Singleton garantuje da će postojati samo jedna instanca klase. To znači da se
više objekata ne može kreirati iz iste Singleton klase.
2. Globalan pristup: Singleton omogućava globalan pristup svojoj instanci, što znači da se ta instanca
može dohvatiti iz bilo kog dela programa.

Singleton se često koristi u situacijama kada je potrebno deliti iste resurse ili konfiguraciju između različitih
delova programa. Na primer, Singleton se može koristiti za pristup bazi podataka ili za deljenje globalnih
postavki aplikacije.

49. Šta su Design Patterns i čemu služe. Ukratko objasniti Memento Design Pattern.

Memento Design Pattern je dizajn obrazac koji se koristi za čuvanje i vraćanje unutrašnjeg stanja objekta
bez otkrivanja detalja o tom stanju. Ovaj obrazac omogućava da se objekat vrati u prethodno stanje ili da se
pregleda istorija promena stanja.

Osnovne komponente Memento obrasca uključuju:

1. Originator (Tvornica): To je objekat čije se stanje želi sačuvati. Originator je odgovoran za

kreiranje Memento objekata i postavljanje svojeg stanja na osnovu podataka iz Memento objekta.
 2. Memento (Čuvar): Memento je objekat koji čuva trenutno stanje Originatora. Memento obično ima
metode za dohvat i postavljanje stanja, ali je njegovo stanje privatno i ne može se direktno menja
izvan Originatora.
3. Caretaker (Čuvar): Caretaker je odgovoran za čuvanje Memento objekata i upravljanje njihovim
istorijom. Caretaker može čuvati više Memento objekata kako bi se omogućilo vraćanje u različite
tačke u vremenu.

Memento obrazac se često koristi u situacijama gde je potrebno omogućiti vraćanje ili undo funkcionalnosti,
kao i za čuvanje stanja aplikacije kako bi se omogućilo povratno stanje. Na primer, u grafičkim uređivačima
se često koristi Memento obrazac kako bi se omogućilo vraćanje prethodnih koraka prilikom uređivanja
slika.

Ukratko, Memento Design Pattern omogućava čuvanje i vraćanje stanja objekta na lak i bezbedan način,
čime se poboljšava fleksibilnost i održivost aplikacije.