Uči se Java sa mnom: savladaj osnovne tipove podataka u Javi za 10 minuta
"Java je statički tipiziran programski jezik, što znači da sve promenljive moraju biti deklarisane pre upotrebe, odnosno mora se unapred navesti tip i ime promenljive." rekao sam Sanmej posle gutljaja mlečnog čaja sa ukrenom vanile.
Tipovi podataka u Javi se dele u 2 kategorije:
- Osnovni tipovi podataka.
Osnovni tipovi podataka su temelj za rad sa podacima u Java jeziku i obuhvataju boolean, char, bajt, short, int, long, float i double — ukupno 8 tipova.
- Referentni tipovi podataka.
Svi tipovi osim osnovnih su tzv. referentni tipovi. Najčešći su nizovi (da, nizovi su referentni tip, o tome će biti reči kasnije), class (odnosno klase) i interfejsi (pokazuju na objekte klasa koje implementiraju interfejs).
Evo misaone mape da steknete utisak.
Promenljive se mogu podeliti na lokalne promenljive, promenljive članove i statičke promenljive.
Kada je promenljiva lokalna, mora se prvo inicijalizovati, u protivnom kompajler neće dozvoliti njenu upotrebu. Uzmimo int kao primer, pogledajte sliku ispod.
Kada je promenljiva član ili statička promenljiva, ne mora se inicijalizovati — imaće podrazumevanu vrednost. Za int, pogledajte kod:
/**
* @author Erge
*/
public class LocalVar {
private int a;
static int b;
public static void main(String[] args) {
LocalVar lv = new LocalVar();
System.out.println(lv.a);
System.out.println(b);
}
}Pogledajmo izlaz:
0
0Vidite, podrazumevana vrednost za int kao promenljivu član ili statičku promenljivu je 0. Različiti osnovni tipovi podataka imaju različite podrazumevane vrednosti i zauzimaju različitu količinu memorije — pogledajte tabelu.
| Tip podataka | Podrazumevana vrednost | Veličina |
|---|---|---|
| boolean | false | nedefinisano |
| char | '\u0000' | 2 bajta |
| bajt | 0 | 1 bajt |
| short | 0 | 2 bajta |
| int | 0 | 4 bajta |
| long | 0L | 8 bajtova |
| float | 0.0f | 4 bajta |
| double | 0.0 | 8 bajtova |
01,Bit i bajt
Sanmej bi mogla da pita: "Šta su uopšte bit i bajt?"
Čuli ste za Bitcoin? Čuli ste za ByteDance? Ta imena naravno nisu slučajna — zaista su povezana sa bitom i bajtom.
1)bit (bita)
Bita kao najosnovnija jedinica skladištenja u informacionim tehnologijama je veoma mala, ali čuveni Bitcoin je po njoj dobio ime; njen skraćeni zapis je malo slovo "b".
Svi znaju da računar čuva podatke u binarnom obliku. Jedna binarna cifra je 1 bit, što znači da bita može biti ili 0 ili 1.
2)Byte (bajt)
Uobičajeno, jedan engleski znak zauzima jedan bajt, a jedan kineski znak dva bajta. Odnos između bajta i bite je: 1 bajt = 8 bita.
Sledeća jedinica nagore je KB, što nije 1000 bajtova — pošto računar razume samo binarni sistem, to je 2 na deseti stepen, odnosno 1024 bajta.
(Sada je jasna veza između 1024 i programera, zar ne? U šali.)
02,Osnovni tipovi podataka
Dalje ćemo detaljnije razmotriti 8 osnovnih tipova podataka.
1)boolean
boolean (logički tip) služi isključivo za čuvanje dve vrednosti: true i false, odnosno tačno i netačno, i obično se koristi za proveru uslova. Primer koda:
boolean hasMoney = true;
boolean hasGirlFriend = false;Prema specifikaciji Java jezika, boolean tip ima samo dve vrednosti, true i false, ali na nivou jezik Java ne određuje eksplicitno veličinu boolean tipa.
Na osnovu mog istraživanja, postoje dva tumačenja.
Hajde prvo da vidimo prvo tumačenje.
Za boolean tip koji se koristi samostalno, JVM ne pruža namenski bajtkod instrukciju, već koristi int-ove instrukcije poput istore; pošto int zauzima 4 bajta, u tom slučaju boolean takođe zauzima 4 bajta.
Za boolean tip koji se koristi kao niz, JVM će ga tretirati po bajt instrukcijama (bastore); pošto bajt tip zauzima 1 bajt, u tom slučaju boolean takođe zauzima 1 bajt.
Drugo tumačenje: tačna veličina koju boolean zauzima je nedefinisana i zavisi od konkretne implementacije JVM-a.
boolean: The boolean data type has only two possible values: true and false. Use this data type for simple flags that track true/false conditions. This data type represents one bit of information, but its "size" isn't something that's precisely defined.
Pomoću alata JOL može se ispisati memorijski raspored objekta i prikazati stvarna veličina koju boolean zauzima kada se koristi samostalno odnosno kao niz u memoriji.
public class BooleanSizeExample {
public static void main(String[] args) {
boolean singleBoolean = true;
boolean[] booleanArray = new boolean[10];
// Analiza memorijskog zauzeća, može se koristiti alat treće strane poput JOL (Java Object Layout)
System.out.println("Size of single boolean: " + org.openjdk.jol.info.ClassLayout.parseInstance(singleBoolean).toPrintable());
System.out.println("Size of boolean array: " + org.openjdk.jol.info.ClassLayout.parseInstance(booleanArray).toPrintable());
}
}Rezultat izvršavanja je sledeći (64-bitni operativni sistem, JDK 8):
Size of single boolean: java.lang.Boolean object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 01 00 00 00 (00000001 00000000 00000000 00000000) (1)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) dd 20 00 f8 (11011101 00100000 00000000 11111000) (-134209315)
12 1 boolean Boolean.value true
13 3 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total
Size of boolean array: [Z object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 01 00 00 00 (00000001 00000000 00000000 00000000) (1)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 05 00 00 f8 (00000101 00000000 00000000 11111000) (-134217723)
12 4 (object header) 0a 00 00 00 (00001010 00000000 00000000 00000000) (10)
16 10 boolean [Z.<elements> N/A
26 6 (loss due to the next object alignment)
Instance size: 32 bytes
Space losses: 0 bytes internal + 6 bytes external = 6 bytes totalZa pojedinačnu boolean promenljivu:
①,Zaglavlje objekta (Object Header) zauzima 12 bajtova:
- OFFSET 0 - 4: deo zaglavlja objekta, sadrži polje za označavanje (Mark Word), koristi se za čuvanje heš koda objekta, GC stanja itd.
- OFFSET 4 - 8: drugi deo zaglavlja objekta, obično pokazivač na metapodake klase (Class Pointer).
- OFFSET 8 - 12: poslednji deo zaglavlja objekta, sadrži stanje brave ili druge informacije.
②,Stvarna vrednost boolean zauzima 1 bajt, odnosno OFFSET 12 - 13.
③,Da bi se ispunio zahtev za poravnanje na 8 bajtova (podrazumevani način poravnanja objekata u HotSpot JVM), dodato je 3 bajta popunjavanja. OFFSET 13 - 16.
Dakle, iako boolean vrednost sama po sebi zahteva samo 1 bajt, zbog zaglavlja objekta i zahteva za poravnanjem, jedan boolean u memoriji zauzima 16 bajtova.
Za boolean niz:
①,Zaglavlje objekta (Object Header) zauzima 12 bajtova:
- OFFSET 0 - 4: deo zaglavlja objekta, sadrži polje za označavanje (Mark Word).
- OFFSET 4 - 8: drugi deo zaglavlja objekta, sadrži pokazivač na metapodake klase (Class Pointer).
- OFFSET 8 - 12: poslednji deo zaglavlja objekta, obično sadrži informaciju o dužini niza.
②,Dužina niza zauzima 4 bajta, ovde je 10, OFFSET 12 - 16.
③,Stvarni elementi boolean niza, gde svaka boolean vrednost zauzima 1 bajt, ukupno 10 bajtova, OFFSET 16 - 26.
④,Da bi se ispunio zahtev za poravnanje na 8 bajtova, dodato je 6 bajtova popunjavanja, OFFSET 26 - 32.
Dakle, svaki element boolean niza zauzima 1 bajt; uz zaglavlje objekta, popunjavanje za poravnanje i dužinu niza, boolean niz sa 10 elemenata zauzima 32 bajta.
2)bajt
Jedan bajt može predstaviti 2^8 = 256 različitih vrednosti. Pošto je bajt tip sa znakom, njegova vrednost može biti negativna ili pozitivna, a opseg vrednosti je od -128 do 127 (uključujući -128 i 127).
Pri mrežnom prenosu i čitanju/pisanju velikih datoteka, bajt se često koristi kao način prenosa podataka radi uštede prostora. Primer koda:
byte b; // deklariše promenljivu tipa byte
b = 10; // dodeljuje vrednost 10 promenljivoj b
byte c = -100; // deklariše i inicijalizuje promenljivu tipa byte c, sa vrednošću -1003)short
Opseg short je od -32.768 do 32.767 (uključujući 32.767). Primer koda:
short s; // deklariše promenljivu tipa short
s = 1000; // dodeljuje vrednost 1000 promenljivoj s
short t = -2000; // deklariše i inicijalizuje promenljivu tipa short t, sa vrednošću -2000U praksi se short ređe koristi; za cele brojeve int je sasvim dovoljan.
3)int
Opseg int je od -2.147.483.648 (-2 ^ 31) do 2.147.483.647 (2 ^ 31 -1) (uključivo). Ako nema posebnih zahteva, za cele brojeve koristite int. Primer koda:
int i; // deklariše promenljivu tipa int
i = 1000000; // dodeljuje vrednost 1000000 promenljivoj i
int j = -2000000; // deklariše i inicijalizuje promenljivu tipa int j, sa vrednošću -2000000Zašto je opseg 32-bitnog celog broja sa znakom od -2^31 do 2^31 - 1?
Zato što se jedan bit koristi za znak (pozitivno ili negativno), a preostalih 31 bit za vrednost, što znači da je opseg od -2.147.483.648 (to jest -2^31) do 2.147.483.647 (to jest 2^31 - 1).
U binarnom sistemu, svaki bit može predstaviti dva stanja, obično 0 i 1. Za 32-bitni pozitivni binarni broj, izuzev znakovnog bita, svaki bit s desna na levo predstavlja redom 2^0, 2^1, 2^2, ..., 2^30; taj binarni broj preveden u decimalni iznosi 2^0 + 2^1 + 2^2 + ... + 2^30, odnosno 2.147.483.647.
5)long
Opseg long je od -9.223.372.036.854.775.808 (-2^63) do 9.223.372.036.854.775.807 (2^63 -1) (uključivo). Ako int nije dovoljan, koristite long. Primer koda:
long l; // deklariše promenljivu tipa long
l = 100000000000L; // dodeljuje vrednost 100000000000L promenljivoj l (obavezno dodajte sufiks L)
long m = -20000000000L; // deklariše i inicijalizuje promenljivu tipa long m, sa vrednošću -20000000000LDa bi se razlikovao od int, promenljiva tipa long mora pri deklaraciji da na kraju ima veliko slovo "L". Mala slovo "l" se ne koristi jer se lako može pomešati sa cifrom "1".
6)float
float je broj sa pokretnim zarezom jednostruke preciznosti (broj značajnih cifara jednostruke preciznosti je oko 6 do 7), zauzima 32 bita (4 bajta), prati IEEE 754 (standard za binarnu aritmetiku brojeva sa pokretnim zarezom), a opseg vrednosti je od 1.4E-45 do 3.4E+38. float nije pogodan za precizne vrednosti, poput novčanih iznosa. Primer koda:
float f; // deklariše promenljivu tipa float
f = 3.14159f; // dodeljuje vrednost 3.14159f promenljivoj f (obavezno dodajte sufiks f)
float g = -2.71828f; // deklariše i inicijalizuje promenljivu tipa float g, sa vrednošću -2.71828fDa bi se razlikovao od double, promenljiva tipa float mora pri deklaraciji da na kraju ima malo slovo "f". Nije potrebno koristiti veliko "F" jer se malo "f" lako prepoznaje.
7)double
double je broj sa pokretnim zarezom dvostruke preciznosti (broj značajnih cifara dvostruke preciznosti je oko 15 do 17), zauzima 64 bita (8 bajtova), takođe prati IEEE 754 standard, a opseg vrednosti je približno ±4.9E-324 do ±1.7976931348623157E308. double takođe nije pogodan za precizne vrednosti, poput novčanih iznosa.
Primer koda:
double myDouble = 3.141592653589793;U finansijskim izračunavanjima ili scenarijima gde je potrebno precizno računanje sa decimalama, možete koristiti BigDecimal klasu da izbegnete greške zaokruživanja kod brojeva sa pokretnim zarezom. BigDecimal može predstaviti broj sa pokretnim zarezom proizvoljne veličine i potpuno tačne preciznosti.
U praksi, ako iznos nije posebno veliki (tačan na 0,01, odnosno jedan cent), generalno se preporučuje množenje sa 100 i obrada kao celobrojna vrednost.
8)char
char služi za predstavljanje Unicode znakova, zauzima 16 bita (2 bajta) memorijskog prostora, a opseg vrednosti je od 0 do 65.535.
Primer koda:
char letterA = 'A'; // obuhvata se engleskim jednostrukim navodnicima.Napomena: znakovni literal treba da bude obuhvaćen jednostrukim navodnicima (''), a ne dvostrukim (""), jer dvostruki navodnici označavaju stringovni literal.
03,Jednostruka i dvostruka preciznost
Jednostruka preciznost (single-precision) i dvostruka preciznost (double-precision) označavaju dva načina predstavljanja brojeva sa pokretnim zarezom različite preciznosti.
Jednostruka preciznost ima sledeći format: 1 bit znak, 8 bitova eksponent, 23 bitova mantise.
Brojevi sa pokretnim zarezom jednostruke preciznosti obično zauzimaju 32 bita (4 bajta) memorijskog prostora. Opseg vrednosti je približno ±1.4E-45 do ±3.4028235E38, sa preciznošću od oko 6 do 9 značajnih cifara.
Dvostruka preciznost ima sledeći format: 1 bit znak, 11 bitova eksponent, 52 bita mantise.
Brojevi sa pokretnim zarezom dvostruke preciznosti obično zauzimaju 64 bita (8 bajtova) memorijskog prostora, opseg vrednosti je približno ±4.9E-324 do ±1.7976931348623157E308, sa preciznošću od oko 15 do 17 značajnih cifara.
Preciznost izračunavanja zavisi od broja decimala (mantise). Što je više decimala, to se može predstaviti veći broj, pa je time i preciznost izračunavanja veća.
Broj se sastoji od nekoliko cifara, pri čemu one koje utiču na preciznost merenja nazivamo značajnim ciframa, odnosno značajnim ciframa mesta. Značajne cifare su one koje se u naučnim izračunavanjima koriste za predstavljanje preciznosti broja sa pokretnim zarezom. Uopšteno, to su sve cifre u broju sa pokretnim zarezom zapisanom u decimalnom obliku, računajući od prve cifre različite od nule. Na primer, brojevi 1.24 i 0.00124 imaju po 3 značajne cifre.
Evo nekoliko osnovnih pravila za određivanje značajnih cifara:
- Cifre različite od nule su uvek značajne.
- Nula između dve cifre različite od nule je značajna.
- Za decimalne brojeve, nule pre prve cifre različite od nule s leve strane nisu značajne.
- Za cele brojeve, nule nakon prve cifre različite od nule s desne strane nisu značajne.
Evo nekoliko primera koji pokazuju kako se određuju značajne cifre:
- 1234: 4 značajne cifre (sve cifre su različite od nule)
- 1002: 4 značajne cifre (nule su između cifara različitih od nule)
- 0.00234: 3 značajne cifre (prve dve nule s leve strane nisu značajne)
- 1200: 2 značajne cifre (dve nule s desne strane nisu značajne)
04,Međusobno pretvaranje int i char tipova
Između int i char postoji specifičnost — mogu se međusobno pretvarati, što ćete često sretati u kasnijem učenju.
- Celobrojni tip int se može pretvoriti u znakovni tip char pomoću eksplicitne konverzije tipova.
int value_int = 65;
char value_char = (char) value_int;
System.out.println(value_char);Ispisuje A (čija ASCII vrednost se može predstaviti brojem 65).
- Može se koristiti metod
Character.forDigit()za pretvaranje celobrojnog tipa int u znakovni tip char; parametar radix je baza, 10 za decimalni sistem, 16 za heksadecimalni.
int radix = 10;
int value_int = 6;
char value_char = Character.forDigit(value_int , radix);
System.out.println(value_char );Character je omotački tip za char. O njemu će biti reči kasnije.
- Može se koristiti metod
toString()omotačkog tipa Integer za int, u kombinaciji sa metodomcharAt()klase String, za pretvaranje u char.
int value_int = 1;
char value_char = Integer.toString(value_int).charAt(0);
System.out.println(value_char );- Pretvaranje char u int
Naravno, za jednostavno pretvaranje char u int, dovoljna je obična dodela.
int a = 'a';To radi jer dolazi do automatske konverzije tipova, koja će biti detaljno objašnjena kasnije.
Međutim, ako je znak sam po sebi cifra, ovaj pristup neće raditi.
int a = '1';U ovom slučaju vrednost promenljive a je 49, a ne 1, jer je ASCII kod znaka '1' jednak 49.
Kako onda pretvoriti znak '1' u broj 1?
Može se koristiti metod Character.getNumericValue().
int a = Character.getNumericValue('1');Tako će vrednost promenljive a biti 1.
Pored toga, može se koristiti i metod Character.digit().
int a = Character.digit('1', 10);I u ovom slučaju vrednost promenljive a je 1.
Pošto je interna implementacija oba metoda vrlo slična, možete sami proučiti izvorni kod.
Postoji još jedan intuitivniji način — metoda - '0'.
int a = '1' - '0';Tako će vrednost promenljive a takođe biti 1. To je zato što u ASCII i Unicode kodiranju (Java koristi Unicode) znakovi za cifre '0' do '9' idu uzastopno, i njihove kodne vrednosti rastu redom.
Kodna vrednost znaka '0' je 48, znaka '1' je 49, i tako redom, kodna vrednost znaka '9' je 57.
Kada se od kodne vrednosti znaka oduzme kodna vrednost znaka '0' (to jest 48), rezultat je brojna vrednost koju taj znak predstavlja. Na primer, za znak '5' kodna vrednost je 53. Računamo 53 - 48 i dobijamo 5, što je brojna vrednost koju predstavlja znak '5'.
05,Tipovi omotača
Tipovi omotača (Wrapper Types) su posebna vrsta tipova u Javi koja služi za pretvaranje osnovnih tipova podataka (kao što su int, float, char itd.) u odgovarajuće objektne tipove.
Java pruža sledeće tipove omotača, koji su u jednoznačnoj vezi sa osnovnim tipovima podataka:
- Byte (odgovara bajt)
- Short (odgovara short)
- Integer (odgovara int)
- Long (odgovara long)
- Float (odgovara float)
- Double (odgovara double)
- Character (odgovara char)
- Boolean (odgovara boolean)
Tipovi omotača omogućavaju nam da koristimo razne korisne metode osnovnih tipova podataka i kompatibilni su sa scenarijima koji zahtevaju objektne tipove. Na primer, možemo koristiti metod parseInt klase Integer za pretvaranje stringa u ceo broj, ili metod isDigit klase Character za proveru da li je znak cifra, kao i gore pomenuti metod Character.forDigit().
Evo jednostavnog primera koji pokazuje kako se koriste tipovi omotača:
// Korišćenje tipa omotača Integer
Integer integerValue = new Integer(42);
System.out.println("Celobrojna vrednost: " + integerValue);
// Pretvaranje stringa u ceo broj
String numberString = "123";
int parsedNumber = Integer.parseInt(numberString);
System.out.println("Celobrojna vrednost: " + parsedNumber);
// Korišćenje tipa omotača Character
Character charValue = new Character('A');
System.out.println("Znak: " + charValue);
// Provera da li je znak cifra
char testChar = '9';
if (Character.isDigit(testChar)) {
System.out.println("Znak je cifra.");
}U gornjem primeru kreirali smo objekat tipa Integer integerValue i dodelili mu vrednost 42. Zatim smo ispisali njegovu vrednost na konzolu.
Imamo string numberString koji sadrži broj. Koristimo metod Integer.parseInt() da ga pretvorimo u ceo broj parsedNumber. Zatim ispisujemo pretvorenu vrednost na konzolu.
Na primer, parseInt() služi za pretvaranje stringa u ceo broj — to je veoma često korišćen metod, posebno kada se "brojevni string" pretvara u ceo broj.
String text = "123";
int number = Integer.parseInt(text);
System.out.println(number);Možemo ukratko pogledati izvorni kod metoda parseInt():
public static int parseInt(String s, int radix) throws NumberFormatException {
// Ako je string prazan ili baza nije u važećem opsegu, baca NumberFormatException
if (s == null || radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
throw new NumberFormatException();
}
int result = 0; // promenljiva za čuvanje rezultata raščlanjivanja
boolean negative = false; // označava da li je broj negativan
int i = 0, len = s.length(); // i je indeks znaka, len je dužina stringa
int limit = -Integer.MAX_VALUE; // gornja granica za proveru prekoračenja
if (len > 0) {
char firstChar = s.charAt(0); // uzima prvi znak stringa
if (firstChar == '-') { // ako je znak za negativno
negative = true; // postavlja oznaku negativnog broja
limit = Integer.MIN_VALUE; // podešava gornju granicu prekoračenja na minimalnu vrednost Integera
i++;
} else if (firstChar == '+') { // ako je znak za pozitivno
i++; // samo preskače, bez dodatne obrade
}
int multmin = limit / radix; // izračunava graničnu vrednost za proveru prekoračenja
while (i < len) {
// pretvara znak u odgovarajuću brojevnu vrednost
int digit = Character.digit(s.charAt(i++), radix);
if (digit < 0 || result < multmin || result * radix < limit + digit) {
// ako znak nije važeća cifra ili rezultat prelazi opseg, baca NumberFormatException
throw new NumberFormatException();
}
// akumulira rezultat
result = result * radix - digit;
}
} else {
// ako je string prazan, baca NumberFormatException
throw new NumberFormatException();
}
// na osnovu znaka vraća konačan rezultat
return negative ? result : -result;
}Ukratko objašnjenje:
Provera prazne vrednosti: prvo se proverava da li je ulazni string
null; ako jeste, baca seNumberFormatException.Obrada znaka: proverava se prvi znak stringa radi određivanja znaka broja (pozitivan ili negativan). Ako string počinje znakom "-", broj je negativan; ako počinje znakom "+" ili cifrom, broj je pozitivan.
Pretvaranje cifara: prolazi se kroz svaki znak u stringu i pretvara u odgovarajuću cifru. To se postiže oduzimanjem ASCII vrednosti znaka '0' od datog znaka.
Izračunavanje rezultata: izračunava se konačna brojevna vrednost. To se radi množenjem svake cifre njenom težinom pozicije (stepen 10) i dodavanjem na rezultat.
Provera prekoračenja: tokom celog procesa pretvaranja, kod proverava postoji li rizik od prekoračenja. Ako se otkrije prekoračenje, biće bačen
NumberFormatException.Vraćanje rezultata: na osnovu znaka broja vraća se konačan rezultat.
Ovaj izvorni kod je od velike pomoći za kasnije rešavanje osmog problema na LeetCode-u, "String to Integer (atoi)". Rešenje sam stavio u "Ergeove beleške za LeetCode" na tehnološkoj platformi — može poslužiti kao referenca.
Imamo znakovnu promenljivu testChar kojoj je dodeljen znak '9'. Koristimo metod Character.isDigit() da proverimo da li je testChar cifra. Ako jeste, ispisujemo poruku na konzolu.
Počevši od Jave 5, mehanizam automatskog boksovanja (Autoboxing) i odboksovanja (Unboxing) omogućava nam automatsku konverziju između osnovnih tipova podataka i tipova omotača, bez potrebe za eksplicitnim pozivanjem konstruktora ili metoda konverzije (biće detaljno objašnjeno u linku).
Integer integerValue = 42; // automatsko boksovanje, ekvivalentno sa new Integer(42)
int primitiveValue = integerValue; // automatsko odboksovanje, ekvivalentno sa integerValue.intValue()06,Referentni tipovi podataka
Osnovni tipovi podataka imaju podrazumevane vrednosti kada su u ulozi promenljive člana ili statičke promenljive; isto važi i za referentne tipove podataka (nakon što savladate nizove, stringove i objektno orijentisano programiranje ovo će biti jasnije; za sada ćemo proći ukratko).
String je najtipičniji referentni tip podataka, pa ćemo ga uzeti kao primer; pogledajte sledeći kod:
/**
* @author Erge
*/
public class LocalRef {
private String a;
static String b;
public static void main(String[] args) {
LocalRef lv = new LocalRef();
System.out.println(lv.a);
System.out.println(b);
}
}Izlaz je sledeći:
null
nullnull je u Javi veoma specifična pojava; u vašem programerskom životu sretaćete ga često, posebno u pratnji dosadne "izuzetke null pokazivača", poznatog kao NullPointerException.
Dakle, podrazumevana vrednost referentnih tipova podataka je null, uključujući nizove i interfejse.
Zanima li vas zašto su nizovi i interfejsi takođe referentni tipovi podataka?
Hajde prvo da pogledamo nizove:
int [] arrays = {1,2,3};
System.out.println(arrays);arrays je niz tipa int, zar ne? Rezultat ispisa je sledeći:
[I@2d209079[I označava da je niz tipa int, a nakon znaka @ sledi heksadecimalni hashCode — ovakav ispis je previše "nehuman", prosečan čovek ga ne razume! Zašto se prikazuje ovako? Pogledajte metod toString() klase java.lang.Object i biće vam jasno.
Iako niz nije eksplicitno definisan kao klasa, on je zaista objekat i nasleđuje sve metode od pretka Object. Zašto onda nizovi nemaju posebno definisanu klasu za svoje predstavljanje, poput klase String za stringove?
Jedno razumno objašnjenje je da ga Java krije. Ako zaista postoji neki Array.java, možemo zamisliti kako bi izgledao — morao bi da definiše kontejner za čuvanje elemenata niza, baš kao klasa String.
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
}Niz definisan unutar niza? Nema potrebe!
Sada da pogledamo interfejse:
List<String> list = new ArrayList<>();
System.out.println(list);List je veoma tipičan interfejs:
public interface List<E> extends Collection<E> {}A ArrayList je jedna implementacija List interfejsa:
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{}Za referentnu promenljivu interfejsnog tipa ne možete direktno uraditi new:
Možete samo da uradite new objekta klase koja ga implementira — dakle interfejs je, naravno, referentni tip podataka.
Pogledajmo najveću razliku između osnovnih i referentnih tipova podataka.
Osnovni tipovi podataka:
- Ime promenljive pokazuje na konkretnu vrednost.
- Osnovni tipovi podataka čuvaju se na steku.
Referentni tipovi podataka:
- Ime promenljive pokazuje na memorijsku adresu gde je sačuvan objekat, i to na steku.
- Objekat na koji ukazuje memorijska adresa čuva se na hipu.
07,Hip i stek
Dosad, Sanmej verovoatno ponovo pita: "Šta je hip, a šta stek?"
Hip je hip (heap), stek je stek (stack). Ako vidite izraz "hip-stek", nemojte sumnjati u sebe — to je greška u prevodu; hip-stek je samo stek. Lično baš ne volim taj izraz "hip-stek" jer često zbunjuje početnike.
Hip je prostor u memoriji koji se rezerviše tokom izvršavanja programa (može se shvatiti kao dinamički proces); važno: ne tokom kompajliranja. Zato se objekti u Javi čuvaju baš ovde, a prednost je sledeća:
Kada nam je potreban objekat, dovoljno je napisati jedan red koda pomoću ključne reči new; kada se taj red izvrši, automatski se dodeljuje prostor u "hip" regionu memorije — što je vrlo fleksibilno.
Stek može da se poveže direktno sa procesorom (CPU, odnosno mozgom), pa je brži za pristup. Pošto je pristup brži, treba ga dobro iskoristiti! Java zato smešta reference na objekte na stek. Zašto? Zato što se reference često koriste?
Ne, nego zato što Java prilikom kompajliranja programa mora jasno da zna životni vek onoga što je smešteno na steku, inače ne može da oslobodi staru memoriju da bi otvorio novi memorijski prostor za čuvanje referenci — prostor je ograničen, prethodni talas mora da potopi sledeći na plaži.
Sada je jasnije, zar ne?
Ako i dalje nije jasno, pogledajte ovaj video, vrlo je dobro objašnjeno: Šta je hip? Šta je stek? Koje su razlike i veze između njih?
Prikažimo to grafički — sa leve strane je stek, sa desne hip.
Evo još nekoliko dodatnih znanja — ako razumete, nastavite da usvajate; ako ne, pređite na sledeći odeljak i vratite se kasnije, nema problema. Tako je učenje — može se preskakati i može se ponavljati.
Navedimo primer.
String a = new String("Chenmo Wang Er")Ovaj kod će prvo kreirati u hipu stringovni objekat "Chenmo Wang Er", a zatim smeštati referencu a na taj objekat na stek. Ovde je takođe uključen bazen konstanti stringova, o čemu će biti reči kasnije.
Za sledeći kod, koji sadrži i promenljive osnovnog tipa i promenljive referentnog tipa, kako hip i stek čuvaju te vrednosti?
public void test()
{
int i = 4;
int y = 2;
Object o1 = new Object();
}Nacrtaću to grafički.
Trebalo bi da je sada jasno, zar ne?
"Dobro, Sanmej, toliko o tipovima podataka u Javi za sada. Da li ti je već jasno?" rekao sam Sanmej, okrećući ukočeni vrat.
08,Rezime
Ovaj članak je detaljno razmotrio tipove podataka u Javi, uključujući bit i bajt, osnovne tipove podataka, jednostruku i dvostruku preciznost, međusobno pretvaranje int i char, tipove omotača, referentne tipove podataka i memorijski model hipa i steka. Čitanjem ovog članka stekli ste sveobuhvatno razumevanje koncepata i načina upotrebe tipova podataka u Javi, što predstavlja čvrst temelj za programiranje u Javi.