Objekti su složeni tip podataka u JavaScriptu koji nam omogućavaju da grupišemo povezane podatke i funkcionalnosti na jednom mestu. Možemo ih zamisliti kao "kontejnere" koji drže zajedno povezane promenljive i funkcije.
Svojstva objekta su zapravo promenljive (koje smo učili ranije) koje su "vezane" za objekat. Kao što smo ranije kreirali promenljive:
let ime = "Marko";
let godine = 20;
Sada ih možemo grupisati u objekat:
let student = {
ime: "Marko", // ovo je isto što i promenljiva ime
godine: 20 // ovo je isto što i promenljiva godine
};
Svojstva objekta su kao "etiketirane promenljive" - one pripadaju objektu i pristupamo im kroz objekat (student.ime umesto samo ime).
Metode su zapravo funkcije (koje smo učili ranije) koje su "vezane" za objekat. Poređenje:
// Samostalna funkcija
function pozdravi(ime) {
console.log("Zdravo, " + ime);
}
// Ista funkcija kao metoda objekta
let osoba = {
ime: "Marko",
pozdravi: function() {
console.log("Zdravo, " + this.ime);
}
};
Metode koriste this ključnu reč da pristupe drugim svojstvima objekta - this predstavlja "ovaj objekat u kojem se nalazim".
// 1. Objekt literal notacija
let student = {
ime: "Marko",
prezime: "Marković",
godine: 20,
prosek: 8.5
};
/* Objašnjenje:
- Objekat se kreira pomoću vitičastih zagrada {}
- Svojstva su u formatu ključ: vrednost
- Svojstva su razdvojena zarezima
- Ključevi su stringovi (navodnici nisu potrebni ako je validni identifikator)
*/
// 2. Kreiranje praznog objekta
let prazan = {};
// Dva načina pristupa svojstvima
console.log(student.ime); // Dot notacija
console.log(student["prezime"]); // Bracket notacija
/* Kada koristiti koju notaciju:
- Dot notacija (.): Kada je naziv svojstva poznat i validan identifikator
- Bracket notacija ([]):
- Kada naziv svojstva sadrži specijalne karaktere
- Kada je naziv svojstva dinamički (promenljiva)
*/
// Primer dinamičkog pristupa
let svojstvo = "godine";
console.log(student[svojstvo]); // 20
let student = {
ime: "Marko",
prezime: "Marković",
pozdrav: function() {
console.log("Zdravo, ja sam " + this.ime);
},
// Skraćena sintaksa za metode (ES6+)
predstaviSe() {
return `${this.ime} ${this.prezime}`;
}
};
/* Objašnjenje:
- Metode su funkcije koje pripadaju objektu
- this ključna reč se odnosi na trenutni objekat
- Možemo koristiti standardnu ili skraćenu sintaksu
*/
Klase predstavljaju "šablone" ili "nacrte" za kreiranje objekata. Možemo ih zamisliti kao fabrički kalup koji definiše kako će izgledati svaki proizvedeni objekat.
Zamislite da pravite kolače:
// Klasa (RECEPT)
class Auto {
constructor(marka, model, godina) {
this.marka = marka;
this.model = model;
this.godina = godina;
}
}
// Objekti (STVARNI AUTOMOBILI napravljeni po receptu)
let auto1 = new Auto("Toyota", "Corolla", 2020); // jedan primerak
let auto2 = new Auto("Honda", "Civic", 2021); // drugi primerak
let auto3 = new Auto("VW", "Golf", 2019); // treći primerak
/* Objašnjenje:
1. Klasa Auto je kao tehnički nacrt/recept
2. Svaki auto (auto1, auto2, auto3) je konkretan primerak napravljen po tom nacrtu
3. Svi imaju ista svojstva (marka, model, godina) ali sa različitim vrednostima
*/
Constructor je posebna metoda koja se poziva kada kreiramo novi objekat. To je kao "uputstvo za sastavljanje":
class Student {
constructor(ime, prezime) {
// Ovo je kao lista koraka za pravljenje novog studenta
this.ime = ime; // Korak 1: dodeli ime
this.prezime = prezime; // Korak 2: dodeli prezime
this.ocene = []; // Korak 3: pripremi prazan niz za ocene
}
}
### 2.1 Definisanje klase
```javascript
class Student {
// Konstruktor - izvršava se pri kreiranju novog objekta
constructor(ime, prezime, godine) {
this.ime = ime;
this.prezime = prezime;
this.godine = godine;
this.ocene = [];
}
// Metode klase
dodajOcenu(ocena) {
this.ocene.push(ocena);
}
izracunajProsek() {
if (this.ocene.length === 0) return 0;
let suma = this.ocene.reduce((a, b) => a + b, 0);
return suma / this.ocene.length;
}
predstaviSe() {
return `${this.ime} ${this.prezime}, ${this.godine} godina`;
}
}
/* Objašnjenje komponenti:
1. constructor: Posebna metoda koja se poziva pri kreiranju objekta
2. this: Referenca na trenutnu instancu objekta
3. Metode se definišu direktno u klasi
*/
// Kreiranje novih instanci
let student1 = new Student("Ana", "Anić", 20);
let student2 = new Student("Petar", "Petrović", 21);
// Korišćenje metoda
student1.dodajOcenu(8);
student1.dodajOcenu(9);
student1.dodajOcenu(10);
console.log(student1.predstaviSe());
console.log("Prosek:", student1.izracunajProsek());
/* Tok izvršavanja pri kreiranju instance:
1. new operator kreira novi prazan objekat
2. Poziva se constructor metoda
3. This se vezuje za novi objekat
4. Konstruktor inicijalizuje svojstva
5. Vraća se novi objekat
*/
Nasleđivanje je mehanizam koji nam omogućava da kreiramo nove klase bazirane na postojećim klasama. Možemo ga zamisliti kao "prenošenje osobina sa roditelja na decu".
Zamislite porodično stablo:
U programiranju:
// Roditeljska klasa
class Zaposleni {
constructor(ime, prezime, plata) {
this.ime = ime;
this.prezime = prezime;
this.plata = plata;
}
godisnjaPlata() {
return this.plata * 12;
}
}
// Klasa naslednik
class Menadzer extends Zaposleni {
constructor(ime, prezime, plata, bonus) {
super(ime, prezime, plata); // Pozivamo konstruktor roditelja
this.bonus = bonus; // Dodajemo novo svojstvo
}
// Redefinišemo metodu da uključi bonus
godisnjaPlata() {
return super.godisnjaPlata() + this.bonus;
}
}
/* Objašnjenje nasleđivanja:
1. Menadzer nasleđuje SVA svojstva i metode od Zaposlenog
2. super() poziva konstruktor roditelja da inicijalizuje nasleđena svojstva
3. Menadzer dodaje svoje posebno svojstvo (bonus)
4. Menadzer menja nasleđenu metodu godisnjaPlata()
5. super.godisnjaPlata() poziva originalnu metodu roditelja
*/
// Praktičan primer:
let radnik = new Zaposleni("Marko", "Marković", 50000);
let menadzer = new Menadzer("Ana", "Anić", 70000, 100000);
console.log(radnik.godisnjaPlata()); // 600,000
console.log(menadzer.godisnjaPlata()); // 940,000
/* Analogija sa stvarnim svetom:
- Zaposleni je kao "osnovno zanimanje"
- Menadzer je "specijalizovano zanimanje" koje:
- Ima sve što i osnovni zaposleni (ime, prezime, plata)
- Dodaje svoje posebnosti (bonus)
- Drugačije računa neke stvari (godišnja plata sa bonusom)
*/
class Osoba {
constructor(ime, prezime) {
this.ime = ime;
this.prezime = prezime;
}
predstaviSe() {
return `${this.ime} ${this.prezime}`;
}
}
class Student extends Osoba {
constructor(ime, prezime, indeks) {
// Poziv roditeljskog konstruktora
super(ime, prezime);
this.indeks = indeks;
}
// Override roditeljske metode
predstaviSe() {
return `Student ${super.predstaviSe()}, indeks: ${this.indeks}`;
}
}
/* Objašnjenje:
1. extends označava nasleđivanje
2. super() poziva konstruktor roditeljske klase
3. Možemo redefinisati (override) metode roditeljske klase
4. super.metodaRoditelja() poziva originalnu implementaciju
*/
class BankovniRacun {
constructor() {
this._stanje = 0; // Konvencija: _ označava "private"
}
// Getter
get stanje() {
return this._stanje;
}
// Setter
set stanje(iznos) {
if (iznos < 0) {
throw new Error("Stanje ne može biti negativno");
}
this._stanje = iznos;
}
}
let racun = new BankovniRacun();
racun.stanje = 1000; // Poziva setter
console.log(racun.stanje); // Poziva getter
/* Objašnjenje:
- get i set definišu svojstva sa specijalnim ponašanjem
- Izgledaju kao svojstva ali su zapravo metode
- Omogućavaju validaciju pri postavljanju vrednosti
- Mogu izračunavati vrednosti pri čitanju
*/
class ProizvodKorpe {
constructor(naziv, cena, kolicina) {
this.naziv = naziv;
this.cena = cena;
this.kolicina = kolicina;
}
ukupnaCena() {
return this.cena * this.kolicina;
}
}
class Korpa {
constructor() {
this.proizvodi = [];
}
dodajProizvod(proizvod) {
this.proizvodi.push(proizvod);
}
ukloniProizvod(naziv) {
this.proizvodi = this.proizvodi.filter(p => p.naziv !== naziv);
}
ukupanIznos() {
return this.proizvodi.reduce((total, p) => total + p.ukupnaCena(), 0);
}
}
// Primer korišćenja
let korpa = new Korpa();
korpa.dodajProizvod(new ProizvodKorpe("Laptop", 1200, 1));
korpa.dodajProizvod(new ProizvodKorpe("Miš", 25, 2));
console.log("Ukupno za plaćanje:", korpa.ukupanIznos());
Napravite klasu Knjiga sa svojstvima:
Kreirajte klasu Biblioteka koja:
Implementirajte klasu Automobil:
Napravite sistem za praćenje zaposlenih:
Zaposleni sa osnovnim informacijamaMenadzer koja nasleđuje ZaposleniKompanija koja upravlja zaposlenima