Millised on Java erinevad and­me­tüü­bid?

Java pakub kaheksat pri­mi­tiiv­set and­me­tüüpi ja mitmeid keerukaid and­me­tüüpe. Need määravad, milliseid väärtusi saab muutujas sal­ves­tada ja kuvada. Teatud and­me­tüü­bid on Java-s määratud kõikidele muu­tu­ja­tele.

Millised and­me­tüü­bid on olemas Java-s?

Igas prog­ram­mee­ri­mis­kee­les on erinevad and­me­tüü­bid, mis si­sal­da­vad konk­reet­seid objekte ja mää­rat­le­tud ope­rat­sioone. Kuigi erinevate keelte pakutavad and­me­tüü­pide valikud on sageli sarnased, on mõnikord ka olulisi erinevusi. Näiteks kui võrrelda Pythonit ja Javat ning nende and­me­tüüpe, märkad nende sarnasusi, aga ka arvukaid erinevusi, mis muudavad need keeled sobivaks erinevat tüüpi üles­an­nete jaoks.

Java kasutab kahte erinevat and­me­tüüpi: pri­mi­tiiv­sed ja komp­leks­sed. Komp­lek­seid and­me­tüüpe ni­me­ta­takse ka vii­te­tüü­pi­deks. Pri­mi­tiiv­sed ja komp­leks­sed and­me­tüü­bid erinevad oma suuruse poolest ja määravad, milliseid väärtusi saab muutujas sal­ves­tada. Pri­mi­tiiv­sed and­me­tüü­bid või­mal­da­vad sal­ves­tada ainult lihtsaid väärtusi, vii­te­tüüpe ka­su­ta­takse aga kee­ru­li­se­mate struk­tuu­ride loomiseks ning suurte and­me­hul­kade or­ga­ni­see­ri­miseks ja tööt­le­miseks.

Kui soovite õppida prog­ram­mee­rima, on oluline mitte ainult teada erinevaid and­me­tüüpe, vaid ka seda, kuidas neist kõigist mak­si­maal­selt kasu saada. And­me­tüü­pide parima ka­su­ta­mise mõistmine ei ole ainult nende funkt­sio­naal­suse mõistmise küsimus, vaid ka see, kui palju mälu nad kasutavad (või säästavad).

Mis on Java pri­mi­tiiv­sed and­me­tüü­bid?

Java-s on kokku kaheksa erinevat pri­mi­tiiv­set and­me­tüüpi, mis si­sal­da­vad kindlalt mää­rat­le­tud väärtuste vahemikke. Need võib jagada nelja ka­te­goo­riasse: loo­gi­li­sed and­me­tüü­bid, täis­ar­vu­li­sed and­me­tüü­bid, uju­ko­ma­ar­vu­li­sed and­me­tüü­bid ja mär­gis­tüü­bid. Neil pole li­sa­või­ma­lusi ja neid ni­me­ta­takse ka ele­men­taar­se­teks and­me­tüü­pi­deks. Igal and­me­tüü­bil on kindel bittide arv. Allpool vaatame pri­mi­tiiv­seid and­me­tüüpe lähemalt. Java kasutab järgmisi pri­mi­tiiv­seid tüüpe:

• boolean
• bait
• lühike
• int või täisarv
• pikk
• float
• double
• märk

boolean

Java boole’i andmetüüp ei ole numb­ri­line tüüp. See pakub ainult kahte või­ma­likku väärtust: true ja false. Seda saab kasutada tingimuse kehtivuse (true) või keh­ti­ma­tuse (false) kind­laks­mää­ra­miseks. See on loogiline andmetüüp ja selle vaikimisi väärtus on false. See koosneb 1 bitist ja selle süntaks on järgmine:

boolean booleanVar;

byte

byte on in­teg­raalne andmetüüp, mida esi­ta­takse kahe komp­le­men­taarväär­tu­sena suurusega 8 bitti või 1 bait. Seda ka­su­ta­takse ta­va­li­selt suuremate mas­sii­vide puhul mälu sääst­miseks. Selle väärtuste vahemik on -128 kuni 127 ja selle vaikimisi väärtus on 0. Siin on selle süntaks:

byte byteVar;

short

short on ka üks Java in­teg­raal­tüüpi and­me­tüü­pi­dest ja seda ka­su­ta­takse peamiselt suuremate mas­sii­vide puhul mälu sääst­miseks. Kahe täiend­väär­tus ise on 16-bitine ehk 2-baidine ja selle väärtuste vahemik ulatub -32768-st kuni 32767-ni (kaasa arvatud). Vaikimisi on selle väärtus 0. Niimoodi ka­su­ta­takse short:

short shortVar

int või täisarv

int või täisarv on samuti kahe komp­le­men­taarväär­tus ja in­teg­raalne andmetüüp suurusega 4 baiti või 32 bitti. Selle väärtuste vahemik hõlmab täisarve vahemikus -2147483648 kuni 2147483647 ja selle vaikimisi väärtus on 0. Selle süntaks on järgmine:

int intVar

long

Suurim in­teg­raalne andmetüüp on long. See kehtib esiteks selle väärtuste vahemiku kohta, mis on vahemikus -9223372036854775808 kuni 9223372036854775807, ja teiseks selle enda suuruse kohta, mis on 8 baiti või 64 bitti. Kui teised täis­ar­vu­tüü­bid ei ole piisavad, ka­su­ta­takse seetõttu ka­he­komp­le­men­taarväär­tust. See nõuab aga ka kõige rohkem mälu. Selle vaikimisi väärtus on 0. Selle süntaks on järgmine:

lomg longVar

float

float on uju­ko­ma­ar­vu­line andmetüüp, mida ka­su­ta­takse reaal­ar­vude sal­ves­ta­miseks. Selle suurus on 32 bitti ja see vastab IEEE 754 stan­dar­dile, mis määratleb arvutites ka­su­ta­ta­vate binaar- ja küm­nendu­ju­ko­ma­ar­vude stan­dardse esi­tus­viisi. Stan­dard­väär­tus float on 0,0 ja selle väärtuste vahemikus saab esitada kuni seitse küm­nend­kohta. Võrreldes double-tüübiga ei ole float siiski nii täpne ja seetõttu ei tohiks seda kasutada väärtuste puhul, kus täpsus on otsustava täht­su­sega. Kui see aga nii ei ole, võite float kasutada ruumi sääst­miseks. float süntaks on järgmine:

float floatVar;

double

double on umbes kaks korda täpsem kui float ja täidab sarnast eesmärki. Selle suurus on 64 bitti ja see võib esindada kuni 16 küm­nend­kohta. Selle vaikimisi väärtus on samuti 0,0. Kui vajate täpsemaid väärtusi, peaksite alati kasutama double, kuigi ka see andmetüüp ei ole nii täpne. Kui soovite töötada ab­so­luut­selt täpsete väär­tus­tega, peaksite kasutama pigem Big­Deci­mal-klassi. double süntaks on järgmine:

double doubleVar;

char

char on mär­gis­tüüp. See salvestab märgid Unicode’i mär­gis­ti­kul põ­hi­ne­valt, või­mal­da­des üle­kan­ta­vust paljudele eri­ne­va­tele plat­vormi­dele. Iga märk vajab 2 baiti mälu. Selle väärtuste vahemik vastab ASCII-le (American Standard Code for In­for­ma­tion In­te­rc­hange) ja asub vahemikus ‘\u0000’ (st 0) ja ‘\uffff’ (vastab 65535). Char’i vaikimisi väärtus on ‘\u0000’ ja selle süntaks on järgmine:

char charVar

Mis on Java kee­ru­li­sed and­me­tüü­bid?

Teine and­me­tüü­pide liik Java-s on vii­te­tüü­bid, mida ni­me­ta­takse ka kee­ru­ka­teks and­me­tüü­pi­deks. Neid ni­me­ta­takse vii­te­tüü­pi­deks, kuna need viitavad ob­jek­ti­dele. Erinevalt pri­mi­tiiv­se­test and­me­tüü­pi­dest ei ole need ta­va­li­selt eel­de­fi­nee­ri­tud, vaid määrab need prog­ram­mee­rija (erandiks on string). Need võivad kasutada meetodeid ja neil võib olla ka väärtus 0 (tühja tä­hen­duses). Kui pri­mi­tiiv­sed and­me­tüü­bid algavad väikese tähega, siis vii­te­tüü­bid algavad suure tähega. Siin vaatame lähemalt kõige olu­li­se­maid vii­te­tüüpe.

Keeled

String on klass, mida saab kasutada märkide jada esin­da­miseks, eristades seda keerukat and­me­tüüpi pri­mi­tiiv­sest and­me­tüü­bist char ja teistest and­me­tüü­pi­dest. String ek­sis­tee­rib objektina klassis java.lang. String-klassi erinevad meetodid või­mal­da­vad teil uurida stringi üksikuid märke, võrrelda stringe omavahel, otsida stringe ja kopeerida stringe. Stringid on tä­his­ta­tud ju­tu­mär­ki­dega. Selle vii­te­tüübi süntaks on järgmine:

<string_type> <string_variable> = "<string_sequence>";

Siin on näide stringide toi­mi­mi­sest:

// How to create a string without a new operator
String a = "This is your new string";
/ / How to create a string with a new operator
String a1 = new string ("This is your new string");

Massiivid

Massiive ka­su­ta­takse mitme väärtuse sal­ves­ta­miseks ühe muutuja sees, selle asemel et luua iga väärtuse jaoks eraldi muutuja. Need luuakse nurk­sul­gude abil. Sal­ves­ta­tud väärtused pai­gu­ta­takse lok­ki­sul­gu­desse ja eral­da­takse komadega. Siin on mas­sii­vide süntaks:

dataType[] arrayName = {value1, value2, value3,…};

Kui soovite luua strin­gi­dest koosneva massiivi, võite seda teha järg­mi­selt:

String[] colors = {"blue", "red", "yellow", "purple"};

Siin on näide, kuidas luua täis­ar­vu­dest koosnev massiiv:

int[] figures = {5, 10, 15, 20};

Klassid

Java-keeles on klassid and­me­tüü­bid, mis toimivad objektide loomise mallina. Need si­sal­da­vad mit­me­su­gu­seid kom­po­nente, seal­hul­gas klassi nime, mo­di­fi­kaa­to­reid ja kaa­rek­lam­meri­tega ümb­rit­se­tud keha. Siin on näide, kuidas klass Java-keeles välja näeb:

public class Main {
	int a = 10;
}

Liidesed

Java-keeles on liides abst­raktne klass. See toimib liidesena, mille kaudu klass saab juur­de­pääsu eri­ne­va­tele funkt­sioo­ni­dele. Selleks peab ta aga need esmalt rakendama. Liidesed si­sal­da­vad ainult kons­tan­deid ja abst­rakt­seid meetodeid. Nende süntaks on järgmine:

interface {
	abstract methods
}

Siin toome lihtsa näite, et näidata, kuidas liidesed töötavad:

interface Pizza {
	public void ingredientsList();
	public void preparation();
}
class Mushroom implements Pizza {
	public void ingredientsList() {
		System.out.println("mushrooms, tomato sauce, oregano, mozzarella");
}
public void preparation() {
	System.out.println("The pizza will be ready in 15 minutes.");
}
}
class Main {
	public static void main(String[] args) {
		Mushroom myMushroom = new Mushroom();
		myMushroom.ingredientsList();
		myMushroom.preparation();
	}
}

Java-käsu System.out.println vastav väljund näeb välja järgmine:

mushrooms, tomato sauce, oregano, mozzarella
The pizza will be ready in 15 minutes.

Objektid

Java-keeles on objektid samuti kee­ru­li­sed and­me­tüü­bid. Objektid on klasside ins­tant­sid, mis saavad omavahel suhelda meetodite abil. Järgmises näites loome Main-klassis mitu objekti:

public class Main {
	int a = 10;
public static void main(String[] args) {
	Main myObj1 = new Main();
	Main myObj2 = new Main();
	System.out.println(myObj1.a);
	System.out.println(myObj2.a);
	}
}

Väljund näeb välja järgmine:

10
10

Enumid

Enumid on spet­siaalne klass, mis võimaldab lisada koodi muu­tu­ma­tuid konstante. Nendele muu­tu­ja­tele on määratud kindlad väärtused, mida ei saa muuta. See andmetüüp on eriti kasulik, kui vajate muutujaid, millel on vaid mõned või­ma­li­kud seisundid. Enumi süntaks on järgmine:

enum NameOfTheClass {
	VALUE1,
	VALUE2,
	VALUE3
}