OOP in Java and usage of constructor

Usage of `constructor` in Java

Hajde da napravimo igricu FOOTBALL!

OOP je baziran na objektima, kao što nam se u samom nazivu to sugeriše : Objektno Orjentisano Programiranje.

Ako znamo da su nam klase sadžajni opis objekata sa njegovim atributima (klasne varijable) i ponašanjima (funkcije/metode), onda zaključujemo da su nam klase srce OOP.

Hajde da to pokažemo kroz realni primjer...

Možemo imati neograničen broj klasa. Klasa opisuje atribute i ponašanja srodnih objekata (objekti mogu biti ljudi, životinje, brojevi, mašine, podaci i sl.). Dakle, da ne bismo pisali za svaki objekat code ponaosob, grupišemo sve naše objekte u srodne i za sve njih napišemo klasu, a u klasi varijable i funkcije koje odražavaju njihove vrijednosti i ponašanje pod različitim zadatim ili mogućim uslovima.

Ako pišemo program za školu, potencijalne klase nam mogu biti: nastavnici, predmeti, učenici. Opet sve zavisi šta nam je cilj programa.

Hajde da se vratimo na početak i pokušamo napraviti program za Football game!

Neka naš program ima sljedeće klase:
- Football - naša glavna klasa sa pokretačkim driverom (main metoda)
- GUI - klasa kojom definišemo grafički user interfejs, ono što vidimo: stadion, navijači, transparenti, teten, semafor, itd.
- Team - klasa kojom ćemo definisati naše timove. Na terenu imamo 2 tima. Osnovni atributi tima su: ime, boja dresa, trener i igrači. Da ne bismo pisali kod za svaki tim ponaosob, a srodni su jer imaju iste atribute (sa različitim vrijednostima naravno) stvorićemo jednu klasu Team.
- Player - klasa kojom definišemo svakog igrača u timu: njegovo ime, broj na dresu, pozicija u timu, itd. Vidiš, svaki igrač ima iste atribute (ime, broj, pozicija,..) i zamisli da pišemo kod za 22 igrača plus rezervni igrači?! Zato ćemo stvoriti klasu Player sa navedenim atributima gdje ćemo svakom igraču kao objektu klase Player dodijeliti različite vrijednosti igračkih atributa.

Naš klase bi izgledale otprilike ovako:

Football class:

public class Football {
public static void main(String[] args) {
    setTeams();
    setGUI();   
    play();  
}

static void setTeams(){
    // some codes...
    /* ne zaboravi da imamo 2 tima: 
        Team team1;
        Team team2;
    */
}

static void setGUI(){
    // some codes...
}

static void play(){
    // some codes...
}
}

GUI class:

class GUI{
GUI stadion;
GUI navijaci;

// some codes...to set all GraphicUserInterface

}

Team class:

class Team{
String nazivTima;
String bojaDresa;
String selektor;
Player[] team=new Player[11]; // team kao niz(array) od 11 igraca

Team imeEkipe(String _imeEkipe){
    nazivTima=_imeEkipe;
    return this;
}

Team bojaDresa(String boja) {
    bojaDresa = boja;
    return this;
}       

Team coach(String _selektor){
    selektor=_selektor;
    return this;
}

Team setPlayers(List players){
    // add players...
    /* Ovdje smo kao argument stavili List players, odnosno unaprijed datu listu svih igraca sa njihovim atributima (imena, brojevi dresa, pozicije), pa cemo nas code unutar ove metode prilagoditi tome.
    
    Medjutim, u igrici, gdje imamo pravi GUI, ove podatke bi unosio korisnik za svakog igraca ponaosob. Zamisli na pocetku igrice, ponudjeno ti je da kreiras tim, i nudi ti jednog po jednog igraca da im odredis sve pomenute atribute. Pa ti kliknes na zeljenu boju kose, pa visinu, pa brzinu, pa broj dresa, u tekstualno polje uneses ime ili ti ponudi nekog poznatog igraca (FIFAgame), itd...
        Kada zavrsis i code pokupi sve tvoje zeljene postavke za igraca on ga kreira sa zadatim atributima. I sve tako dok ne sastavis cijeli tim.
    
    */
    return this;
}

}

Player class:

class Player{
String ime;
int brojDresa;
String pozicija;

Player ime(String _ime){
    ime=_ime;
    return this;
}

Player broj(int _broj){
    brojDresa=_broj;
    return this;
}

Player pozicija(String _pozicija){
    pozicija=_pozicija;
    return this;
}

}

Napisali smo naš program: classe su tu, funkcije...i šta sad? Idemo kreirati naše timove u funkciji setTeams().

Hajde da prvo definišemo naše liste igrača za oba tima:

static void setTeams(){    
    List players1 = List.of("Handanovic",1,"golman","Vidic",2,"odbrana","Modric",5,"vezni","Dzeko",10,"napad");
    List players2 = List.of("Bufon",1,"golman","Kompani",2,"odbrana","Iniesta",8,"vezni","Mbape",10,"napad");
    
    // Team team1=...
    // Team team2=...
    }

Pogledajmo classu Team. Ekipa nam ima sljedeće atribute: naziv tima, boja dresa, trener, igrači (prosljeđujemo našu listu kao argument).

Recimo da nam je naziv team1 "Balkan", boja dresa bijela, trener je Ćiro Blažević, a igrači lista players1.

Kako pozvati / koristiti funkcije klase Team? Kako oživjeti classu Team? Imamo classu Team, imamo sve funkcije u toj klasi koje nam trebaju za definisanje naše ekipe, ali...ako ih ne možemo koristiti - čemu onda sve?

E ovdje na scenu stupa constructor!!!

Dakle, laički rečeno, constructor je specijalna metoda pomoću koje odgovarajućoj klasi udahnjujemo ŽIVOT! Bez konstruktora, kao što vidiš, naša classa je samo skup sintakse, brojeva i slova.

Nema drugog načina da se pristupi classi, njenim atributima (varijablama) i metodama osim putem constructora. Zato, čak i onda kada nismo napisali constructor, compiler ga sam definiše. U protivnom, naše classe bi bile "mrtve", beskorisne.

Dakle, naše postavljanje ekipe "Balkan" bi izgledalo ovako:


    Team team1=new Team() // pozivamo konstruktor classe Team, dajemo nasoj klasi zivot
        .imeEkipe("Balkan")
        .bojaDresa("bijela")
        .coach("Ciro")
        .setPlayers(players1);

Nadam se da si shvatio svrhu constructora. Bez obzira da li je constructor sa parametrima ili ne, default ili ga mi definišemo...svrha mu je ista -> oživjeti klasu! To je razlog zašto constructor mora imati isto ime kao i klasa kojoj pripada.

Evo kako bi nas programcic izgledao (klikni na "Try the code"):

Football class:

import java.util.List;
public class Football {
public static void main(String[] args) {
    setTeams();
    setGUI();   
    play();  
}

static void setTeams(){
    List players1 = List.of("Handanovic",1,"golman","Vidic",2,"odbrana","Modric",5,"vezni","Dzeko",10,"napad");
    List players2 = List.of("Bufon",1,"golman","Kompani",2,"odbrana","Iniesta",8,"vezni","Mbape",10,"napad");
    team1=new Team()
        .imeEkipe("Balkan")
        .bojaDresa("bijela")
        .coach("Ciro")
        .setPlayers(players1);
    
    team2=new Team()
        .imeEkipe("Evropa")
        .bojaDresa("plava")
        .coach("Anceloti")
        .setPlayers(players2);
}

static void setGUI(){
    // some codes...
}

static void play(){
    // some codes...
}
}

Try the code

BUILD PATTERN

Kada smo već kod našeg programčića, pogledaj još jednom kako smo izgradili nas objekat classe Team (nas team1):


    Team team1=new Team()
        .imeEkipe("Balkan")
        .bojaDresa("bijela")
        .coach("Ciro")
        .setPlayers(players1);

i pogledaj našu klasu Team, odnosno kako naše funkcije (imeEkipe, bojaDresa, coach, setPlayers) izgledaju:

Team class:

class Team{
String nazivTima;
String bojaDresa;
String selektor;
Player[] team=new Player[11]; // team kao niz(array) od 11 igraca

Team imeEkipe(String _imeEkipe){
    nazivTima=_imeEkipe;
    return this;
}

Team bojaDresa(String boja) {
    bojaDresa = boja;
    return this;
}       

Team coach(String _selektor){
    selektor=_selektor;
    return this;
}

Team setPlayers(List players){
    // some code (add players to team)
    return this;
}
}

Složićeš se da smo gornje funkcije mogli zanemariti, a naš team kreirati kroz parametarizovan constructor:

Team class:

class Team{
String nazivTima;
String bojaDresa;
String selektor;
Player[] team=new Player[11]; // team kao niz(array) od 11 igraca

// constructor:
Team (String _imeEkipe, String boja, String _selektor,List players){
    nazivTima=_imeEkipe;
    bojaDresa = boja;
    selektor=_selektor;
    // add players to team array
}
}

U čemu je razlika?

Naš prvi način građenja objekta, kroz funkcije a ne kroz constructor, se zove BUILD PATTERN. Koristi se u slučaju kada imamo mnogo argumenata/parametara gdje može doći do komplikacija ako se ide preko constructora (naš zadatak COSTUMERS), ili kada svi naši srodni objekti nemaju u startu definisane iste atribute (neke atribute možemo naknadno definisati, ili čak i izmjeniti vrijednost nekih ranije definisanih atributa).

Kako funkcionise BUILD PATTERN?

Kao što smo apsolvirali, da bismo kreirali objekat neke klase, potrebno je to uraditi preko constructora sa ključnom riječi new.Tada smo našom objektu dodijelili neku adresu:


    Team team1=new Team();

Naša adresa takođe sadrži sve varijable/atribute classe Team, a u našem primjeru njihove vrijednosti u ovom trenutku su default vrijednosti (null, 0 i sl.).

Hajde sada da definišemo vrijednost varijable "naziv tima" koji je u ovom momentu null :


    Team team1=new Team()
        .imeEkipe("Balkan");

Šta se desilo? Pogledajmo funkciju imeEkipe() u classi Team:


    Team imeEkipe(String _imeEkipe){
    nazivTima=_imeEkipe;
    return this;
}

Naš objekat "team1" je pozvao funkciju "imeEkipe()" i proslijedio joj String varijednost "Balkan" kao naziv ekipe. Tu vrijednost, funkcija "imeEkipe()" je dodijelila klasnoj varijabli "nazivTima" (atributu trenutnog "current" objekta) i vratila "current" objekat našem objektu "team1", tj.vratio se sam sebi. Sada se naziv tima "Balkan" odnosi na objekat "team1", odnosno ovaj atribut pripada "team1".

Ukratko, promjena sadržaja se desila na adresi objekta "team1".

Tako da bi BUILD PATTERN bio rješenje za naš "problem" COSTUMERS -> link

Srećno! :)

#Class, Constructor, Builder