# Millised on Java erinevad andmetüübid?

Java pakub kaheksat primitiivset andmetüüpi ja mitmeid keerukaid andmetüüpe. Need määravad, milliseid väärtusi saab muutujas salvestada ja kuvada. Teatud andmetüübid on Java-s määratud kõikidele muutujatele.

## Millised andmetüübid on olemas Java-s?

Igas programmeerimiskeeles on erinevad andmetüübid, mis sisaldavad konkreetseid objekte ja määratletud operatsioone. Kuigi erinevate keelte pakutavad andmetüüpide valikud on sageli sarnased, on mõnikord ka olulisi erinevusi. Näiteks kui [võrrelda Pythonit ja Javat](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/python-vs-java/) ning nende andmetüüpe, märkad nende sarnasusi, aga ka arvukaid erinevusi, mis muudavad need keeled sobivaks erinevat tüüpi ülesannete jaoks.

Java kasutab kahte erinevat andmetüüpi: **primitiivsed ja komplekssed**. Komplekseid andmetüüpe nimetatakse ka viitetüüpideks. Primitiivsed ja komplekssed andmetüübid erinevad oma suuruse poolest ja määravad, milliseid väärtusi saab muutujas salvestada. Primitiivsed andmetüübid võimaldavad **salvestada** ainult **lihtsaid väärtusi**, viitetüüpe kasutatakse aga **keerulisemate struktuuride loomiseks** ning **suurte andmehulkade organiseerimiseks ja töötlemiseks**.

Kui soovite õppida programmeerima, on oluline mitte ainult teada erinevaid andmetüüpe, vaid ka seda, kuidas neist kõigist maksimaalselt kasu saada. Andmetüüpide parima kasutamise mõistmine ei ole ainult nende funktsionaalsuse mõistmise küsimus, vaid ka see, kui palju mälu nad kasutavad (või säästavad).

## Mis on Java primitiivsed andmetüübid?

[Java-s](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-primitiivsed-tueuebid/) on kokku kaheksa erinevat [primitiivset andmetüüpi](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-primitiivsed-tueuebid/), mis sisaldavad kindlalt määratletud väärtuste vahemikke. Need võib jagada nelja kategooriasse: **loogilised andmetüübid, täisarvulised andmetüübid, ujukomaarvulised andmetüübid ja märgistüübid**. Neil pole lisavõimalusi ja neid nimetatakse ka elementaarseteks andmetüüpideks. Igal andmetüübil on kindel bittide arv. Allpool vaatame primitiivseid andmetüüpe lähemalt. Java kasutab järgmisi primitiivseid tüüpe:

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

### `boolean`

[Java boole’i](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-boolei-primitiivne-andmetueuep/) andmetüüp ei ole numbriline tüüp. See pakub ainult kahte võimalikku väärtust: **true** ja **false**. Seda saab kasutada tingimuse kehtivuse (true) või kehtimatuse (false) kindlaksmääramiseks. See on loogiline andmetüüp ja selle vaikimisi väärtus on `false`. See koosneb 1 bitist ja selle süntaks on järgmine:

```java
boolean booleanVar;
```

### `byte`

`byte` on integraalne andmetüüp, mida esitatakse kahe komplementaarväärtusena suurusega 8 bitti või 1 bait. Seda kasutatakse tavaliselt suuremate massiivide puhul mälu säästmiseks. Selle väärtuste vahemik on -128 kuni 127 ja selle vaikimisi väärtus on 0. Siin on selle süntaks:

```java
byte byteVar;
```

### `short`

`short` on ka üks Java integraaltüüpi andmetüüpidest ja seda kasutatakse peamiselt suuremate massiivide puhul mälu säästmiseks. Kahe täiendväärtus 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 kasutatakse `short`:

```java
short shortVar
```

### `int` või täisarv

`int` või täisarv on samuti kahe komplementaarväärtus ja integraalne 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:

```java
int intVar
```

### `long`

Suurim integraalne 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äisarvutüübid ei ole piisavad, kasutatakse seetõttu kahekomplementaarväärtust. See nõuab aga ka kõige rohkem mälu. Selle vaikimisi väärtus on 0. Selle süntaks on järgmine:

```java
lomg longVar
```

### `float`

`float` on ujukomaarvuline andmetüüp, mida kasutatakse reaalarvude salvestamiseks. Selle suurus on 32 bitti ja see vastab IEEE 754 standardile, mis määratleb arvutites kasutatavate binaar- ja kümnendujukomaarvude standardse esitusviisi. Standardväärtus `float` on 0,0 ja selle väärtuste vahemikus saab esitada kuni **seitse kümnendkohta**. 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ähtsusega. Kui see aga nii ei ole, võite `float` kasutada ruumi säästmiseks. `float` süntaks on järgmine:

```java
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ümnendkohta**. 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 absoluutselt täpsete väärtustega, peaksite kasutama pigem BigDecimal-klassi. `double` süntaks on järgmine:

```java
double doubleVar;
```

### `char`

`char` on märgistüüp. See salvestab märgid Unicode’i märgistikul põhinevalt, võimaldades ülekantavust paljudele erinevatele platvormidele. Iga märk vajab 2 baiti mälu. Selle väärtuste vahemik vastab ASCII-le (American Standard Code for Information Interchange) ja asub **vahemikus ‘\\u0000’ (st 0) ja ‘\\uffff’ (vastab 65535)**. Char’i vaikimisi väärtus on ‘\\u0000’ ja selle süntaks on järgmine:

```java
char charVar
```

## Mis on Java keerulised andmetüübid?

Teine andmetüüpide liik Java-s on viitetüübid, mida nimetatakse ka keerukateks andmetüüpideks. Neid nimetatakse viitetüüpideks, kuna need **viitavad objektidele**. Erinevalt primitiivsetest andmetüüpidest ei ole need tavaliselt eeldefineeritud, vaid määrab need programmeerija (erandiks on string). Need võivad kasutada meetodeid ja neil võib olla ka väärtus 0 (tühja tähenduses). Kui primitiivsed andmetüübid algavad väikese tähega, siis viitetüübid algavad suure tähega. Siin vaatame lähemalt kõige olulisemaid viitetüüpe.

### Keeled

`String` on klass, mida saab kasutada **märkide jada** esindamiseks, eristades seda keerukat andmetüüpi primitiivsest andmetüübist `char` ja teistest andmetüüpidest. String eksisteerib objektina klassis `java.lang`. String-klassi erinevad meetodid võimaldavad teil uurida stringi üksikuid märke, võrrelda stringe omavahel, otsida stringe ja kopeerida stringe. Stringid on tähistatud jutumärkidega. Selle viitetüübi süntaks on järgmine:

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

Siin on näide stringide toimimisest:

```java
// 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 kasutatakse **mitme väärtuse** salvestamiseks **ühe muutuja sees**, selle asemel et luua iga väärtuse jaoks eraldi muutuja. Need luuakse nurksulgude abil. Salvestatud väärtused paigutatakse lokkisulgudesse ja eraldatakse komadega. Siin on massiivide süntaks:

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

Kui soovite luua stringidest koosneva massiivi, võite seda teha järgmiselt:

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

Siin on näide, kuidas luua täisarvudest koosnev massiiv:

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

### Klassid

Java-keeles on klassid andmetüübid, mis **toimivad** objektide loomise **mallina**. Need sisaldavad mitmesuguseid komponente, sealhulgas klassi nime, modifikaatoreid ja kaareklammeritega ümbritsetud keha. Siin on näide, kuidas klass Java-keeles välja näeb:

```java
public class Main {
	int a = 10;
}
```

### Liidesed

Java-keeles on liides **abstraktne klass**. See toimib liidesena, mille kaudu klass saab juurdepääsu erinevatele funktsioonidele. Selleks peab ta aga need esmalt rakendama. Liidesed sisaldavad ainult konstandeid ja abstraktseid meetodeid. Nende süntaks on järgmine:

```java
interface {
	abstract methods
}
```

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

```java
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:

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

### Objektid

Java-keeles on objektid samuti keerulised andmetüübid. Objektid on **klasside instantsid**, mis saavad omavahel suhelda meetodite abil. Järgmises näites loome Main-klassis mitu objekti:

```java
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:

```java
10
10
```

### Enumid

[Enumid](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-loendid/) on spetsiaalne klass, mis võimaldab lisada **koodi muutumatuid konstante**. Nendele muutujatele 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õimalikud seisundid. Enumi süntaks on järgmine:

```java
enum NameOfTheClass {
	VALUE1,
	VALUE2,
	VALUE3
}
```


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-andmetueuebid/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-andmetueuebid/) for AI/LLM consumption.