Visoka škola elektrotehnike i računarstva strukovnih studija

Objektno orijentisano projektovanje

Paketi, standardne klase,

omotači prostih tipova, nabrojivi tipovi

2017
Objektno orijentisano projektovanje

Sadržaj

Paketi ....................................................................................................................................................... 3
Ugrađene klase ........................................................................................................................................ 5
Klasa String .......................................................................................................................................... 6
Klasa StringBuffer ................................................................................................................................ 8
Klasa Random .................................................................................................................................... 10
Klasa Math ......................................................................................................................................... 11
Klasa System ...................................................................................................................................... 13
Klasa Scanner..................................................................................................................................... 13
Omotači prostih tipova.......................................................................................................................... 14
Klasa Character .................................................................................................................................. 14
Klasa Boolean .................................................................................................................................... 15
Omotači numeričkih tipova ............................................................................................................... 15
Automatsko pakovanje i raspakivanje............................................................................................... 15
Nabrojivi tipovi ...................................................................................................................................... 16
Literatura: .............................................................................................................................................. 18

2
Objektno orijentisano projektovanje

Paketi
Paketi u Javi služe da se klase organizuju u grupe i da se razreši konflikt oko
imenovanja klasa. Paketi su po svojoj strukturi vrlo slični folderima:

 paketi na istom hijerahijskom nivou moraju da imaju različita imena;

 unutar svakog paketa mogu da se definišu potpaketi;
 klase unutar jednog paketa moraju da imaju jedinstveno ime;
 različiti paketi mogu da imaju klase sa istim imenom;
 da bi se obratili klasi iz drugog paketa ili potpaketa, eksplicitno mora da se navede
njena „putanja“-puno kvalifikovano ime;
 članovi paketa su međusobno direktno vidljivi.

Definisanje paketa se izvršava tako što se kao prva naredba Javine izvorne datoteke
stavi službena reč package iz koje treba da sledi naziv paketa:

package imePaketa;.

Slika 1: Paketi i potpaketi

U jednom paketu može biti definisan proizvoljan broj klasa i sve one bi po pravilu
trebale da budu u posebnom fajlu ali u okviru jednog foldera (koji se isto zove kao i paket).
Ukoliko treba da se definiše potpaket, tada on mora da se nađe (organizuje) u podfolderu
(koji nosi isto ime kao i potpaket) (slika 1). Na taj način može da se ide proizvoljno u dubinu
sa sa definicijom podnivoa paketa.

I klase i paketi su metode za enkapsuliranje, omeđavanje imenskog prostora i oblasti

važenja promenljivih i metoda. Paketi su skladište klasa i drugih podređenih paketa. Klase su
skladište podataka i koda (metoda). Zbog međusobnih odnosa klasa i paketa, Java za klase
članove predviđa četiri kategorije vidljivosti:

3
Objektno orijentisano projektovanje

 potklase u istom paketu,

 klase iz istog paketa koje nisu potklase,
 potklase u drugim paketima,
 klase iz drugih paketa koje nisu potklase.

U Javi postoje tri specifikatora pristupa: private, public i protected i one

obezbeđuju različite varijante pristupanja ovim kategorijama. U suštini, postoji i četvrti a to
je kada se ne naznači specifikator, to je podrazumevani nivo pristupa. Sve kombinacije su
prikazane u tabeli 1.

Tabela 1: Pristup članovima klase

podrazumevani
private protected public
pristup
Ista klasa da da da da
Potklasa istog paketa ne da da da
klase istog paketa koje nisu
ne da da da
potklase
potklasa iz drugog paketa ne ne da da
klase iz drugih paketa koje
ne ne ne da
nisu potklase

Tabela 1 može da se uprosti na sledeći način:

 onome što je označeno kao public može se pristupiti direktno iz bilo koje tačke
programa,
 ono što je označeno kao private nevidljivo je izvan svoje klase,
 kada za član nije naznačen specifikator pristupa onda je član vidljiv i za klase i za
potklase istog paketa -to je podrazumevani nivo pristupa,
 ako je član označen kao protected onda će biti vidljiv i izvan svog paketa ali samo
direktnim potklasama.

Sama klasa može da ima samo dva nivoa pristupa: podrazumevani (kada se ne
naglasi) i public. Ako ima podrazumevani onda može da je dostupna samo u okviru istog
paketa, a ako ima public onda može da joj pristupi bilo ko.

Da bi se obratili nekoj klasi mora da se navede eksplicitno „putanja“ do nje navodeći

nazive svih paketa odnosno potpaketa u kojima je ona sadržana gde se ta imena međusobno
razdvojena tačkom. Na primer na slici 1 može da se vidi da se klasa Potklasa nalazi u
paketu javaaplikacija11 koji je potpaket paketa javaaplikacija1. Kreiranje
objekta tipa Potklasa se realizuje na sledeći način:

javaaplikacija1.javaaplikacija11.Potklasa pdk;
pdk=new javaaplikacija1.javaaplikacija11.Potklasa();

4
Objektno orijentisano projektovanje

Bilo bi nepraktično kada bi se ovaj način koristio svaki put kada je potrebno da se
upotrebi klasa. Zbog toga je uvedena mogućnost da se klasa uveze. I više, može da se uveze i
ceo paket. Da bi se uvezla klasa ili paket koristi se službena reč import:

import paket1[[.paket2]...].imeklase|*;

Ukoliko umesto imena klase stoji * onda će biti uvezen ceo paket. Na primer:

 Sa
import java.util.Date
uvozi se klasa Date koja se nalazi u potpaketu util paketa java. Nakon toga,
klasa Date može da se koristi samo navođenjem njenog imena
Date datum=new Date();
 Sa
Import java.io.*;
Uvozi se kompletan paket java.io i sve klase definisane u tom paketu mogu da
se koriste samo navođenjem njenog imena.

Situacija kada se uvezu dva različita paketa u okviru kojih postoji klase sa istim
imenom se razrešava navođenjem punog imena klase mada se prevodilac neće buniti sve
dok se ne pozove takva klasa.

Ukoliko se ne definiše da klasa pripada paketu ona se postavlja u neimenovani

podrazumevani paket i toj klasi onda može da se pristupa sa bilo koje tačke samo
navođenjem njenog imena.

Ugrađene klase
Biblioteka klasa je kolekcija klasa koje mogu da se koriste prilikom razvoja programa.
Standardna Javina biblioteka klasa je deo Javinog razvojnog okruženja. Sve standardne
Javine klase čuvaju se u jednom od više imenovanih potpaketa (u neimenovanom
podrazumevanom paketu ih nema) paketa java. Klase su grupisane po funkciji mada
postoje i preklapanje nekih paketa. Klase koje se najčešće koriste (String, Scanner, ArrayList,
Math,...) treba da se znaju po imenu a one koje se ređe koriste treba da se znati kako da se
lociraju (u kom paketu da se traže). Prilikom rada sa ugrađenom klasom treba znati njen
interfejs (imena i opisi javnih polja, konstruktora i metoda, tipovi povratnih vrednosti i
parametara konstruktora i metoda) ali ne i implementaciju. Interfejs svih klasa u nekoj
biblioteci klasa čini API (Application Programming Interface).

Osnovne funkcije samog jezika čuvaju se u paketu java.lang koji prevodilac

automatski uvozi u sve programe pa ne mora eksplicitno da se navodi. Još neki od ugrađenih
paketa su:

5
Objektno orijentisano projektovanje

 java.util – uslužne funkcije

 java.io – ulazno izlazne operacije
 java.awt – grafika i grafički korisnički interfejs
 java.swing – dodatne grafičke mogućnosti
 java.net – komunikacija na mreži
 ...

Klasa String

Klasa String se nalazi u paketu java.lang. S obzirom da se stringovi često koriste

za stvaranje String objekta nije neohodno koristiti operator new. Dovoljno je znakovni niz
dodeliti objektu tipa String:

String recenica=“Ovo je jedan niz znakova“;

Ovo je sintaksa koja važi samo za stringove .Treba naglasiti da svaki literal između znaka
navoda predstavlja objekat tipa String. Elementi stringa su tipa char – svaki karakter
oivičen apostrofima. Kada se jednom napravi objekat klase String on više ne može da se
menja. Međutim, to ne predstavlja nikakvo ograničenje jer i dalje, na tako napravljeni
objekat, mogu da se primene sve operacije namenjene znakovnim nizovima samo što,
ukoliko dođe do bilo kakve promene, stvara se novi objekat tipa String koji sadrži tu
promenu.

Klasa String opremljena je sa nekoliko konstruktora. Na slici 2 dat je primer pozivanja

različitih konstruktora.

1: package klasastring;
2: public class KlasaString {
3: public static void main(String[] args) {
4: String string="Java";
5: String string1=new String();
6: System.out.println("Prvi string: "+string1);
7: System.out.println("--------------------------------------");
8: String string2=new String(string);
9: System.out.println("Drugi string: "+string2);
10: System.out.println("--------------------------------------");
11: char niz[]={'K','l','a','s','a',' ','S','t','r','i','n','g'};
12: String string3=new String(niz);
13: System.out.println("Treci string: "+string3);
14: System.out.println("--------------------------------------");
15: String string4=new String(niz,4,5);
16: System.out.println("Četvrti string: "+string4);
17: System.out.println("--------------------------------------");
18: byte ascii[]={65,66,67,68,69};
19: String string5=new String(ascii);
20: System.out.println("Četvrti string: "+string5);
21: }
22: }

6
Objektno orijentisano projektovanje

run:
Prvi string:
--------------------------------------
Drugi string: Java
--------------------------------------
Treci string: Klasa String
--------------------------------------
Četvrti string: a Str
--------------------------------------
Četvrti string: ABCDE
--------------------------------------
BUILD SUCCESSFUL (total time: 1 second)
Slika 2: Primer upotrebe konstruktora u klasi String

U redu 4: napravljen je objekat string bez upotrebe operatora new. U redu 5:

napravljen je jedan prazan string zato i na izlazu nema sadržaja posle teksta. Stringovi
string2 i string3 napravljeni su preko objekta tipa Strig odnosno preko niza char
(redovi 8: i 12:). String string4 napravljen je od niza niz ali tako da se ne uzima ceo niz
već se kroz argumente konstruktora navodi indeks od koga počinju da se uzimaju znakovi i
koliko znakova. Indeksiranje u nizu počinje od nule tako da indeks 4 označava peti član niza
(red 15:). Konačno u redu 18: prikazana je mogućnost formiranja objekta String uz pomoć
numeričkog repereznta karaktera veličine byte (ASCII kod).

Neke od metoda ponuđenih u klasi String su prikazane kroz primer koji se nalazi na
slici 3.

1: package klasastring;
2: public class KlasaString {
3: public static void main(String[] args) {
4: String s1="Volim",s2="PROGRAMIRAM",s3=" ";
5: String recenica=s1+s3+"da"+s3+s2+'.';
6: String konverzija="Sada je "+1+2.0+" sati";
7: System.out.println(recenica);
8: System.out.println(konverzija);
9: System.out.println("--------------------------------------")
10: System.out.println(recenica.toLowerCase());
11: System.out.println(recenica.length());
12: System.out.println(recenica.substring(9));
13: System.out.println(recenica.substring(5,8));
14: System.out.println("--------------------------------------");
15: String pomstring="Volim da ";
16: String velikaslova=pomstring.concat("programiram.").toUpperCase();
17: System.out.println(velikaslova);
18: System.out.println("--------------------------------------");
19: if(velikaslova.equals(recenica)) System.out.println("Stringovi "+recenica+ " i "+velikaslova+"
20: su isti.");
21: else System.out.println("Stringovi "+recenica+ " i "+velikaslova+" nisu isti.");
22: if(velikaslova.equalsIgnoreCase(recenica)) System.out.println("Stringovi "+recenica+ " i " +
23: velikaslova +" su isti.");
24: else System.out.println("Stringovi "+recenica+ " i "+velikaslova+" nisu isti.");
25: System.out.println("--------------------------------------");

7
Objektno orijentisano projektovanje

26: System.out.println("Indeksi podstringa i karaktera");

27: System.out.println(recenica.indexOf("PROGRAMIRAM"));
28: System.out.println(recenica.indexOf('A'));
29: System.out.println("--------------------------------------");
30: System.out.println(recenica.replace(' ', '_'));
31: System.out.println("--------------------------------------");
32: }
33: }
run:
Volim da PROGRAMIRAM.
Sada je 12.0 sati
--------------------------------------
volim da programiram.
21
PROGRAMIRAM.
da
--------------------------------------
VOLIM DA PROGRAMIRAM.
--------------------------------------
Stringovi Volim da PROGRAMIRAM. i VOLIM DA PROGRAMIRAM. nisu isti.
Stringovi Volim da PROGRAMIRAM. i VOLIM DA PROGRAMIRAM. su isti.
--------------------------------------
Indeksi podstringa i karaktera
9
14
--------------------------------------
Volim_da_PROGRAMIRAM.
--------------------------------------
BUILD SUCCESSFUL (total time: 1 second)
Slika 3: Kompletan kod programa KlasaString.java i rezultat izvršenja

Još jedna od specifičnosti klase String je upotreba operatora ’+ ’ za nadovezivanje

stringova mada postoji i metoda koja to isto radi. Može se primetiti da se vrši automatska
konverzija nekih osnovnih tipova u String tip (redovi 5: i 6:). Za poređenje sadržaja dva
objekta tipa String mogu da se koriste nekoliko metoda definisanih u klasi String.
Ukoliko se dva objekta upoređuju pomoću operatora == tada se u stvari upoređuju reference
(adrese objekata) a ne sadržaji stringova.

Kada tokom nadovezivanja Java konvertuje podatke u odgovarajuće znakovne nizove

ona to čini pozivajući jednu od preklopljenih verzija metode za konverziju valueOf() koja je
definisana u klasi String. Metode valueOf() preklapa sve proste tipove podataka kao i za tip
Object s tim što tada metoda valueOf() poziva metodu toString() za objekat.

Klasa StringBuffer

Klasa StringBuffer dopunjuje klasu String i takođe se nalazi u paketu

java.lang. Za razliku od klase String kod koje su objekti fiksne dužine, objekti klase
BufferString su promenljive dužine. Na bilo koje mesto unutar objekta može se dodati

8
Objektno orijentisano projektovanje

znak ili niz znakova i objekat će se automatski proširiti. Konstruktori klase StringBuffer
su sledećeg oblika:

 StringBuffer()
 StringBuffer(int veličina)
 StringBuffer(String niz)
 StringBuffer (CharSequence znakovi)

Podrazumevani konstrukor (bez argumenta) unapred rezerviše mesto za neki

određeni broj znakova (16). Druga verzija rezerviše onoliko prostora koliko se specificira
argumentom. Treći konstruktor prihvata string kojim se zadaje početni sadržaj objekta ali se
prostor ne rezerviše „na meru“ već malo više (za 16 više). Četvrti konstruktor pravi objekat
koji sadrži sekvencu znakova znakovi.

Na slici 4 prikazan je primer programa koji koristi klasu StringBuffer.

1: package klasastringbuffer;
2: public class KlasaStringBuffer {
3: public static void main(String[] args) {
4: StringBuffer string=new StringBuffer();
5: System.out.println("String napravljen pomoću konstruktora StringBuffer() je:");
6: System.out.println(string);
7: System.out.println("Njegova dužina je:"+string.length());
8: System.out.println("Njegov kapacitet je:"+string.capacity());
9: System.out.println("-------------------------------------");
10: StringBuffer string1=new StringBuffer("Zdravo");
11: System.out.println("String napravljen pomoću konstruktora StringBuffer(String niz) je:");
12: System.out.println(string1);
13: System.out.println("Njegova dužina je:"+string1.length());
14: System.out.println("Njegov kapacitet je:"+string1.capacity());
15: System.out.println("-------------------------------------");
16: char niz[]={'A','n','a','l','i','z','a',' ','m','r','e','ž','a'};
17: String pom=new String(niz);
18: StringBuffer string2=new StringBuffer(pom.subSequence(5, 11));
19: System.out.println("String napravljen pomoću konstruktora StringBuffer(CharSequence
20: znakovi) je:");
21: System.out.println(string2);
22: System.out.println("Njegova dužina je:"+string2.length());
23: System.out.println("Njegov kapacitet je:"+string2.capacity());
24: System.out.println("-------------------------------------");
25: string2.append("ža");
26: System.out.println(string2);
27: string2.insert(2, "Računarska");
28: System.out.println(string2);
29: string2.delete(0, 2);
30: System.out.println(string2);
31: string2.replace(0,10,"Društvena");
32: System.out.println(string2);
33: string2.reverse();
34: System.out.println(string2);
35: }

9
Objektno orijentisano projektovanje

36: }
run:
String napravljen pomoću konstruktora StringBuffer() je:

Njegova dužina je:0

Njegov kapacitet je:16
-------------------------------------
String napravljen pomoću konstruktora StringBuffer(String niz) je:
Zdravo
Njegova dužina je:6
Njegov kapacitet je:22
-------------------------------------
String napravljen pomoću konstruktora StringBuffer(CharSequence znakovi) je:
za mre
Njegova dužina je:6
Njegov kapacitet je:22
-------------------------------------
za mreža
zaRačunarska mreža
Računarska mreža
Društvena mreža
ažerm anevtšurD
BUILD SUCCESSFUL (total time: 1 second)
Slika 4: Kompletan kod programa KlasaStringBuffer.java i rezultat izvršenja

Metode koje su korišćene služe za prikazivanje dužine stringa (redovi 7:, 13: i 22:),
kapacitet stringa (veličina rezervisanog prostora za string) (redovi 8:, 14: i 23:), dopisivanje
sadržaja na kraj stringa (red 25:), umetanje sadržaja u string (red 27:), izbacivanje dela
sadržaja iz stringa (red 29:), zamena dela sadržaja drugim nizom znakova (red 31:) i
izokretanje redosleda znakova u stringu (red 33:).

Klasa Random

Klasa Random se nalazi u paketu java.util. Obezbeđuje metode za generisanje

pseudoslučajnih brojeva.

Ova klasa ima dva konstruktora:

 Random()
 Random(long seme)

U prvom slučaju generator brojeva kao seme uzima tekuće vreme a u drugom slučaju
korisnik sam zadaje klicu. Metode klase Random date su u tabeli 2 a program sa nekim
primerima upotrebe klase Random dat je na slici 5.

Tabela 2: Interfejs klase random

Metoda Opis
boolean nextBoolean() vraća sledeću logičku slučajnu vrednost
voide nextBytes(byte niz[]) ispunjava niz slučajno generisanim vrednostima

10
Objektno orijentisano projektovanje

Metoda Opis
double nextDouble() vraća sledeći slučajan broj tipa double
float nextFloat() vraća sledeći slučajan broj tipa float
double nextGaussian() vraća sledeči normalno raspodeljeni slučajni broj
int nextInt() vraća sledeći slučajan broj tipa int
int nextInt(int n) vraća sledeći slučajan broj tipa int u intervalu od 0 do n-1
long nextLong() vraća sledeći slučajan broj tipa long
void setSeed(long novoseme) zadaje novo seme

1: package slucajnibrojevi;
2: import java.util.Random;
3: public class SlucajniBrojevi {
4: public static void main(String[] args) {
5: Random slucajan=new Random();
6: boolean slbool=slucajan.nextBoolean();
7: System.out.println("Slucajni boolean: "+slbool);
8: int slucajniint=slucajan.nextInt();
9: System.out.println("Slucajni int: "+slucajniint);
10: slucajniint=slucajan.nextInt(20)+1;
11: System.out.println("Slucajni int u intervalu od 1 do 20: "+slucajniint);
12: double sldouble=slucajan.nextDouble();
13: System.out.println("Slucajni double: "+sldouble);
14: byte niz[]=new byte [10];
15: slucajan.nextBytes(niz);
16: for(byte x:niz) System.out.print (x+" ");
17: System.out.println();
18: }
19: }
run:
Slucajni boolean: true
Slucajni int: -497401823
Slucajni int u intervalu od 1 do 20: 17
Slucajni double: 0.6639042337907692
26 65 -66 -16 -125 -74 56 117 -32 -67
BUILD SUCCESSFUL (total time: 1 second)
Slika 5: Program SlucajniBrojevi.java i rezultat izvršenja

Klasa Math

Klasa Math se nalazi u paketu java.lang i sadrži funkcije za rad sa brojevima u

pokretnom zarezu koji se koriste u geometriji i trigonometriji kao i više metoda opšte
namene. Ona definiše i dve konstante tipa Double: Ojlerovu konstantu (e) – E i Ludolfov
broj (pi)-PI. Sve metode u klasi Math su statičke.

U tabeli 3 dat je spisak javnih metoda iz klase Math.

metoda opis
static double sin(double arg) vraća sinus ugla arg zadatog u radijanima
static double cos(double arg) vraća kosinus ugla arg zadatog u radijanima

11
Objektno orijentisano projektovanje
metoda
static double tan(double arg)
static double asin(double arg)
static double acos(double arg)
static double atan(double arg)
static double atan2(double x,double y)
static double sinh(double arg)
static double cosh(double arg)
static double tanh(double arg)
static double cbrt(double arg)
static double exp(double arg)
static double log(double arg)
static double log10(double arg)
static double log1p(double arg)
static double pow (double y, double x)
static double sqrt (double arg)
static int abs (int arg)
static long abs (long arg)
static float abs (int arg)
static double abs (double arg)
static double ceil (double arg)
static double floor (double arg)
static int max(int x, int y)
static long max(long x, long y)
static float max(float x, float y)
static double max(double x, double y)
static int min(int x, int y)
static long min(long x, long y)
static float min(float x, float y)
static double min(double x, double y)
static double rint(double arg)
static int round(float arg)
static long round(float arg)
static float ulp(float arg)
static double ulp(double arg)
static double IEEEremainder(double x,
double y)
static double random()
static double toRadians(double arg)
static double toDegrees(double arg)
static float signum(float arg)
static double signum(double arg)
opis
vraća tangens ugla arg zadatog u radijanima
vraća ugao u radijanima čiji je sinus arg
vraća ugao u radijanima čiji je kosinus arg
vraća ugao u radijanima čiji je tangens arg
vraća ugao u radijanima čiji je tangens x/y
vraća hiperbolički sinus ugla arg
vraća hiperbolički kosinus ugla arg
vraća hiperbolički tangens ugla arg
vraća kubni koren od arg
vraća e na stepen arg
vraća prirodni logaritam od arg
vraća dekadni logaritam od arg
vraća prirodni logaritam od arg+1
vraća y podignut na stepen x
vraća kvadratni koren broja arg
vraća apsolutnu vrednost broja arg (tipa int)
vraća apsolutnu vrednost broja arg (tipa long)
vraća apsolutnu vrednost broja arg (tipa float)
vraća apsolutnu vrednost broja arg (tipa double)
vraćanajveći ceo broj jednak ili veći od arg
vraćanajmanjii ceo broj jednak ili manji od arg
vraća veći od brojeva x i y (tipa int)
vraća veći od brojeva x i y (tipa long)
vraća veći od brojeva x i y (tipa float)
vraća veći od brojeva x i y (tipa double)
vraća manji od brojeva x i y (tipa int)
vraća manji od brojeva x i y (tipa long)
vraća manji od brojeva x i y (tipa float)
vraća manji od brojeva x i y (tipa double)
vraća ceo broj najbliži broju arg
vraća broj tipa int koji predstavlja arg zaokružen
naviše do najbližeg celog broja
vraća broj tipa long koji predstavlja arg
zaokružen naviše do najbližeg celog broja
vraća ulp od arg (tipa float)
vraća ulp od arg (tipa double)
vraća ostatak deljenja x sa y
vraća pseudoslučajan broj između 0 i 1
konvertuje arg iz stepena u radijane
konvertuje arg iz radijana u stepene
funkcija signum (znak) za argument tipa float
funkcija signum (znak) za argument tipa double
12
Objektno orijentisano projektovanje

metoda opis
vraća dužinu hipotenuze trougla sa katetama
static hypot(double stranica1, stranica 2)
stranica1 i stranica2

Klasa System

Klasa System sadrži skup statičkih metoda i promenljivih. Standardni ulazni i izlazni
tok kao i tok za greške iz Javinog izvršnog sistema čuvaju se u promenljivima in, out i err.

Klasa Scanner

Klasa Scanner čita formatiran ulaz i pretvara ga u binarni oblik. Ova klasa može da
se koristi između ostalog i za čitanje ulaza sa konzole i to će u ovom trenutku biti fokus.
Podatak koji stigne preko tastature može da se dodeli određenoj promenljivoj.

Uopšte uzev, objekat tipa Scanner čita leksleme iz izvora zadatog u trenutku
njegovog pravljenja (u slučaju tastature, radi se o standardnom ulazu koji je označen sa
System.in). Lekslema je svaka znakovna struktura koja ima neko značenje odnosno
odgovara nekom regularnom izlazu koji definiše format podataka. Što se tiče klase
Scanner, lekslema je deo ulaza ograničen skupom graničnika koji podrazumevano čini
razmak. Međutim, metodom useDelimiter() graničnik može i da se menja.

Prilikom upotrebe klase Scanner treba se pridržati sledeće procedure:

1. Pozivom jedne od hasNextX metoda klase, utvrđuje se da li je tip X ulaza

dostupan.
2. Ukpoliko je dostupan, učitava se sa odgovarajućom metodom nextX.
3. Koraci 1 i 2 se ponavljaju sve dok se ne iscrpu podaci sa ulaza.

Između ostalog, X može biti neki od sledećih tipova: String, boolean, integer, byte,
long, short, double, float. Interesantna je i metoda hasNext() koja ispituje da li
uopšte ima podatka na ulazu, bez obzira na tip.

Primer upotrebe klase Scanner prikazan je na slici 6. Program računa srednju

vrednost brojeva koji se unose preko tastature. Kraj unosa brojeva je kada preko tastature
stigne reč „kraj“.

1: package klasascanner;
2: import java.util.Scanner;
3: public class KlasaScanner {
4: public static void main(String[] args) {
5: Scanner konzola=new Scanner(System.in);
6: int brojac=0; double zbir=0;
7: System.out.println("Unesite niz brojeva (za kraj upisati \"kraj\"" );
8: System.out.println("Brojeve razdvajati kosom crtom (/)" );
9: konzola.useDelimiter("/");

13
Objektno orijentisano projektovanje

10: while(konzola.hasNext())
11: {if(konzola.hasNextDouble()){zbir+=konzola.nextDouble();++brojac;}
12: else {String kraj=konzola.next();
13: if(kraj.equalsIgnoreCase("kraj")) break;
14: else
15: {System.out.println("Pogrešan format podataka");return;}
16: }
17: }
18: System.out.println("Srednja vrednost unetih brojeva iznosi "+zbir/brojac);
19: }
20: }
run:
Unesite niz brojeva (za kraj upisati "kraj")
Brojeve razdvajati kosom crtom (/)
15/16.2/-11.3/0.8/-4.7/kraj/
Srednja vrednost unetih brojeva iznosi 3.2
BUILD SUCCESSFUL (total time: 26 seconds)

run:
Unesite niz brojeva (za kraj upisati "kraj")
Brojeve razdvajati kosom crtom (/)
12/15/16/end/
Pogrešan format podataka
BUILD SUCCESSFUL (total time: 14 seconds)
Unesite niz brojeva (za kraj upisati "kraj")
Brojeve razdvajati kosom crtom (/)
1
2
6/
Pogrešan format podataka
BUILD SUCCESSFUL (total time: 10 seconds)
Slika 6: Program KlasaScanner.java i rezultat izvršenja za različite kolekcija ulaza

Omotači prostih tipova

Već je rečeno da Java jezik za svaki prosti tip obezbeđuje objekat koji čini klasno
okruženje tipa, takozvane omotače tipova. Omotači tipova su klase: Double, Float,
Long, Integer, Short, Byte, Character i Boolean. Ove klase imaju raznovrsne
metode koje omogućavaju potpunu integraciju prostih tipova u Javinu hijerarhiju objekata.
Ovde će samo ukratko biti opisano pakovanje i raspakivanje.

Klasa Character

Klasa Character je omotač tipa char. Njen konstruktor je:

Character (char ch)

gde je ch znak koji će biti omotan. Da bi se dobio znak sadržan u objektu tipa Character
treba pozvati metodu charValue() koja će da vrati enkapsuliran znak.

14
Objektno orijentisano projektovanje

Klasa Boolean

Klasa Boolean je omotač tipa boolean. Postoje dva konstruktora:

 Boolean (boolean logičkavrednost)

 Boolean(String logičkiniz)

U prvom slučaju logička vrednost mora biti true ili false. U drugom slučaju
ukoliko je argument koji se prosleđuje znakovni niz „true“ ili „TRUE“ vrednost objekta koji
se stvara će biti true u svim ostalim slučajevima biće false.

Da bi se dobila vrednost koja je sadržana u objektu tipa Boolean treba pozvati

metodu booleanValue().

Omotači numeričkih tipova

Sve klase koje omotavaju numeričke tipove, a to su Double, Float, Long,

Integer, Short i Byte nasleđuju apstraktnu klasu Number. Klasa Number ima
apstraktne metode koje vraćaju vrednosti objekta u svim numeričkim formatima:

 byte byteValue()
 double doubleValue()
 float floatValue()
 int intValue()
 long longValue()
 short shortValue()

Svi omotači numeričkih tipova definišu konstruktore koji omogućavaju pravljenje

objekta od broja datog tipa ili njegovog znakovnog ekvivalenta (broj predstavljen stringom).
Na primer za klasu Integer konstruktori su:

 Integer (int broj)

 Integer (String znakovniniz)

Svi omotači tipova redefinišu i metodu toString() koja vraća vrednost objekta u
ekvivalentni znakovni niz. To, na primer, omogućava da se ispiše numerička vrednost
metodom println() a da ne mora pre toga da se konvertuje u njegov prosti tip.

Automatsko pakovanje i raspakivanje

Od verzije J2SE 5 Javi je dodata mogućnost automatskog pakovanja i raspakivanja kad

god je to potrebno. Automatsko pakovanje znači da ne mora ručno da se konstruiše objekat
već je dovoljno da se vrednost dodeli referenci omotača tipa (bez upotrebe operatora new).

15
Objektno orijentisano projektovanje

Da bi se objekat raspakovao dovoljno je referencu na njega dodeliti promenljivoj

odgovarajućeg tipa, više nije potrebno da se pozivaju metode tipValue().

Automatsko raspakivanje omogućava i mešanje različitih tipova numeričkih objekata

unutar istog izraza. Nakon raspakivanja vrednosti, primenjuje se standardna konverzija
prostih tipova.

Zahvaljujući automatskom raspakivanju, za upravljanje naredbom switch može se

koristiti i celobrojni numerički objekat. Takođe logički objekat može da se koristi kao uslov u
if naredbi ili u ciklusima.

Primer automatskog pakovanja i raspakivanja osnovnih tipovamože se videti u kodu

prikazanom na slici 7.

1: package automatskopakovanjeiraspakivanje;
2: public class AutomatskoPakovanjeIRaspakivanje {
3: public static void main(String[] args) {
4: Integer obj=100;
5: String string1=obj.toString();
6: Double broj= new Double(string1);
7: float fl=12.12f;
8: Float of=fl;
9: double zbir=obj+broj+fl+of;
10: System.out.println(zbir);
11: String string2="TAcno";
12: Boolean tacno=new Boolean(string2);
13: if(tacno) System.out.println("Tacno ");
14: else System.out.println("Netacno ");
15: }
16: }
run:
224.23999977111816
Netacno
BUILD SUCCESSFUL (total time: 1 second)
Slika 7: Primer automatskog pakovanja i raspakivanja osnovnih tipova

Nabrojivi tipovi
Java dozvoljava definisanje nabrojivog tipa koji se onda može koristiti za deklarisanje
promenljivih. Deklaracija nabrojivog tipa mora da obuhvati sve moguće vrednosti
promenljive tog tipa koje bira korisnik. Na primer, sledeća deklaracija stvara nabrojivi tip:

enum BojaKarata {PIK, KARO, HERC, TREF}

Nabrojivi tipovi čuvaju tip-ne može se dodeliti vrednost drugačija od one navedene u
deklaraciji. Svaka vrednost nabrojivog tipa uskladištebna je kao kao celobrojni podatak koga
zovemo rednim brojem, pozicijom ili indeksom. Tako prva navedena vrednost nabrojivog
tipa ima numeričku vrednost 0, druga ima 1 i tako dalje. Međutim, nije moguće dodeliti

16
Objektno orijentisano projektovanje

numeričku vrednost promenljivoj nabrojivog tipa čak i u slučaju ako se ona poklapa sa
indeksom te stavke. Identifikatori nabrojivog tipa (u gor navedenom primeru PIK, KARO,
HERC, TREF) zovu se konstante nabrojivog tipa. Svaka od njih je implicitno deklarisana kao
javan i statičan član klase BojaKarata

Deklaracija nabrojivog tipa predstavlja poseban tip klasnog tipa i svaka promenljiva
tog tipa je objekat. To znači da nabrojiv tip može imati konstruktore, metode i promenljive
instanci.

Na slici 8 prikazana je upotreba nabrojivog tipa i metode koje vraćaju naziv

identifikatora pridruženog objektu nabrojivog tipa (name()) odnosno redni broj (ordinal()).

1: public class NabrojiviTip {

2: enum BojaKarata {PIK, KARO, HERC,TREF};
3: public static void main(String[] args) {
4: BojaKarata karta=BojaKarata.TREF;
5: System.out.println(karta);
6: String string=karta.toString();
7: System.out.println(string);
8: System.out.println(karta.name());
9: System.out.println(karta.ordinal());
10: BojaKarata pom=BojaKarata.HERC;
11: switch(pom)
12: {
13: case PIK: System.out.println(pom.name()+" je LIST");break;
14: case KARO: System.out.println(pom.name()+ " je DIJAMANT");break;
15: case HERC: System.out.println(pom.name()+ " je SRCE");break;
16: case TREF: System.out.println(pom.name()+ " je DETELINA");break;
17: default:break;
18: }
19: }
20: }
run:
TREF
TREF
TREF
3
HERC je SRCE
BUILD SUCCESSFUL (total time: 0 seconds)
Slika 8: Primer upotrebe nabrojivog tipa

Zadatak1
Proučiti i ostale metode iz klase StringBuffer, naročito one koje se odnose na
umetanje/brisanje/pretragu znakova u stringu i pronalaženje sekvence znakova u datom
stringu. Da li se radi o posebnim metodama ili preklopljenim?

Zadatak 2
Proučiti sledeće standardne klase: Date, Calendar, GregorianCalendar, TimeZone.

17
Objektno orijentisano projektovanje

Zadatak 3
Pronaći koja je klasa zadužena za formatiran izlaz.

Literatura:
1. Herbert Schildt, Java™ J2SE™ 5 Kompletan priručnik, Mikroknjiga, 2006.
2. Rogers Cadenhead, Laura Lemay, Java™ 6 naučite za 21 dan, Kompjuter
biblioteka,2009.

18