# Kādi ir dažādie datu tipi Java?

Java piedāvā astoņus primitīvos datu tipus un daudzus sarežģītus datu tipus. Tie nosaka, kādas vērtības var tikt saglabātas un parādītas mainīgajā. Noteikti datu tipi tiek piešķirti visiem mainīgajiem Java.

## Kādi datu tipi ir Java?

Katrā programmēšanas valodā ir dažādi datu tipi, kas satur konkrētus objektus un definētas operācijas. Lai gan dažādu valodu piedāvātās datu tipu opcijas bieži vien ir līdzīgas, dažkārt pastāv arī būtiskas atšķirības. Piemēram, [salīdzinot Python un Java](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/python-pret-java/) un to datu tipus, var pamanīt gan līdzības, gan arī daudzas atšķirības, kas padara šīs valodas piemērotas dažāda veida uzdevumiem.

Java izmanto divu veidu datu tipus: **primitīvos un sarežģītos**. Sarežģītos datu tipus sauc arī par atsauces tipiem. Primitīvie un sarežģītie datu tipi atšķiras pēc to lieluma un nosaka, kādas vērtības var saglabāt mainīgajā. Kamēr primitīvie datu tipi var **saglabāt** tikai **vienkāršas vērtības**, atsauces tipus izmanto, lai **izveidotu sarežģītākas struktūras** un **organizētu un apstrādātu lielus datu apjomus**.

Ja vēlaties iemācīties programmēt, ir svarīgi ne tikai zināt dažādos datu tipus, bet arī to, kā katru no tiem izmantot pēc iespējas efektīvāk. Lai saprastu, kā vislabāk izmantot datu tipus, ir ne tikai jāizprot to funkcionalitāte, bet arī jāzina, cik daudz atmiņas tie izmanto (vai ietaupa).

## Kas ir primitīvie datu tipi Java?

[Java](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-primitivie-tipi/) ir kopumā astoņi dažādi [primitīvie datu tipi](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-primitivie-tipi/), kas satur stingri definētus vērtību diapazonus. Tos var iedalīt četrās kategorijās: **loģiskie datu tipi, integrālie datu tipi, peldošā punkta datu tipi un rakstzīmju datu tipi**. Tiem nav papildu īpašas funkcijas, un tos sauc arī par elementārajiem datu tipiem. Katram datu tipam ir fiksēts bitu skaits. Turpinājumā sīkāk apskatīsim primitīvos datu tipus. Java izmanto šādus primitīvos tipus:

- boolean
- bait
- īss
- int vai vesels skaitlis
- garš
- float
- double
- rakstzīme

### `boolean`

[Java boolea](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-booleanu-primitivais-datu-tips/) datu tips nav skaitliskais tips. Tas piedāvā tikai divas iespējamās vērtības: **true** un **false**. To var izmantot, lai noteiktu, vai nosacījums ir spēkā (true) vai nav (false). Tas ir loģisks datu tips, un tā noklusējuma vērtība ir `false`. Tas sastāv no 1 bita un tam ir šāda sintakse:

```java
boolean booleanVar;
```

### `byte`

`byte` ir integrāls datu tips, kas tiek attēlots kā divu papildinājuma vērtība ar izmēru 8 biti vai 1 baits. To parasti izmanto, lai ietaupītu atmiņu lielākās masīvās. Tā vērtību diapazons ir no -128 līdz 127, un tā noklusējuma vērtība ir 0. Šeit ir tā sintakse:

```java
byte byteVar;
```

### `short`

`short` ir arī viens no integrālajiem datu tipiem Java valodā un galvenokārt tiek izmantots, lai ietaupītu atmiņu lielākās masīvās. Divu papildinājuma vērtība ir 16 biti vai 2 baiti, un tās vērtību diapazons ir **no -32768 līdz 32767 ieskaitot**. Pēc noklusējuma tās vērtība ir 0. Tā tiek izmantota `short`:

```java
short shortVar
```

### `int` vai vesels skaitlis

`int` vai vesels skaitlis ir arī divu papildinājuma vērtība un integrāls datu tips ar izmēru 4 baiti vai 32 biti. Tā vērtību diapazons ietver veselos skaitļus **no -2147483648 līdz 2147483647**, un tā noklusējuma vērtība ir 0. Tā sintakse ir šāda:

```java
int intVar
```

### `long`

Lielākais integrālais datu tips ir `long`. Tas attiecas, pirmkārt, uz tā vērtību diapazonu, kas ir **no -9223372036854775808 līdz 9223372036854775807**, un, otrkārt, uz tā paša izmēru, kas ir 8 baiti jeb 64 biti. Tādējādi divu papildinājuma vērtība tiek izmantota, ja citi integrālie datu tipi nav pietiekami. Tomēr tai ir nepieciešams arī visvairāk atmiņas. Tās noklusējuma vērtība ir 0. Šī ir tās sintakse:

```java
lomg longVar
```

### `float`

`float` ir peldošā punkta datu tips, ko izmanto reālu skaitļu uzglabāšanai. Tā izmērs ir 32 biti, un tas atbilst IEEE 754 standartam, kas definē bināro un decimālo peldošā punkta skaitļu standarta attēlojumu datoros. Standarta vērtība `float` ir 0,0, un tās vērtību diapazonā var attēlot līdz **septiņām decimālzīmēm**. Salīdzinot ar double, `float` tomēr nav tik precīzs, tāpēc to nevajadzētu izmantot vērtībām, kur precīzija ir izšķiroša. Ja tas tā nav, varat izmantot `float`, lai ietaupītu vietu. `float` sintakse ir šāda:

```java
float floatVar;
```

### `double`

`double` ir aptuveni divreiz precīzāks nekā float un pilda līdzīgu funkciju. Tā izmērs ir 64 biti, un tas var attēlot **līdz 16 decimālzīmēm**. Tā noklusējuma vērtība arī ir 0,0. Ja jums ir nepieciešamas precīzākas vērtības, vienmēr izmantojiet `double`, lai gan arī šis datu tips nav tik precīzs. Ja vēlaties strādāt ar absolūti precīzām vērtībām, jums vajadzētu izmantot BigDecimal klasi. `double` sintakse ir šāda:

```java
double doubleVar;
```

### `char`

`char` ir rakstzīmju datu tips. Tas uzglabā rakstzīmes, pamatojoties uz Unicode rakstzīmju kopu, nodrošinot pārnesamību uz daudzām dažādām platformām. Katrai rakstzīmei nepieciešami 2 baiti atmiņas. Tās vērtību diapazons atbilst ASCII (American Standard Code for Information Interchange) un atrodas **starp ‘\\u0000’ (t.i., 0) un ‘\\uffff’ (atbilst 65535)**. Char noklusējuma vērtība ir ‘\\u0000’, un tā sintakse izskatās šādi:

```java
char charVar
```

## Kas ir sarežģīti datu tipi Java?

Otrais datu tipu veids Java ir atsauces tipi, ko sauc arī par sarežģītiem datu tipiem. Tos sauc par atsauces tipiem, jo tie **atsaucas uz objektiem**. Atšķirībā no primitīvajiem datu tipiem, tie parasti nav iepriekš definēti, bet tos nosaka programmētājs (izņēmums ir string). Tie var izmantot metodes un var būt arī ar vērtību 0 (tukša nozīmē). Kamēr primitīvie datu tipi sākas ar mazo burtu, atsauces tipi sākas ar lielo burtu. Šeit mēs apskatīsim svarīgākos atsauces tipus.

### Stīgas

`String` ir klase, ko var izmantot, lai attēlotu **rakstzīmju secību**, atšķirot šo sarežģīto datu tipu no primitīvā datu tipa `char`, kā arī citiem datu tipiem. String pastāv kā objekts `java.lang` klasē. String klases dažādās metodes ļauj pārbaudīt atsevišķas rakstzīmes stringā, salīdzināt stringus savā starpā, meklēt stringus un kopēt stringus. Stringi tiek identificēti ar pēdiņām. Šī atsauces tipa sintakse izskatās šādi:

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

Šeit ir piemērs, kā darbojas stīgas:

```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");
```

### Masīvi

Masīvi tiek izmantoti, lai **vienā mainīgajā** uzglabātu **vairākas vērtības**, nevis izveidotu atsevišķus mainīgos katrai atsevišķai vērtībai. Tie tiek izveidoti, izmantojot kvadrātiekavas. Uzglabātās vērtības tiek ievietotas izliektās iekavās un atdalītas ar komatiem. Šeit ir masīvu sintakse:

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

Ja vēlaties izveidot masīvu ar virknēm, to var izdarīt šādi:

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

Šeit ir parādīts, kā izveidot masīvu ar veseliem skaitļiem:

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

### Nodarbības

Java valodā klases ir datu tipi, kas **kalpo kā veidnes** objektu izveidei. Tās satur dažādus komponentus, tostarp klases nosaukumu, modifikatorus un ķēdes zīmēs ietvertu ķermeni. Šeit ir piemērs, kā izskatās klase Java valodā:

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

### Saskarnes

Java valodā interfeiss ir **abstrakts klases elements**. Tas darbojas kā interfeiss, caur kuru klase var piekļūt dažādām funkcijām. Tomēr, lai to izdarītu, vispirms ir jāievieš šīs funkcijas. Interfeisi satur tikai konstantes un abstraktas metodes. To sintakse izskatās šādi:

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

Lai parādītu, kā darbojas saskarnes, izmantosim vienkāršu piemēru:

```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();
	}
}
```

Atbilstošais Java komandas `System.out.println` izvades rezultāts izskatās šādi:

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

### Objekti

Java valodā objekti arī ir sarežģīts datu tips. Objekti ir **klašu instancēm,** kas var savstarpēji mijiedarboties, izmantojot metodes. Turpmākajā piemērā mēs izveidosim vairākus objektus Main klasē:

```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);
	}
}
```

Rezultāts izskatās šādi:

```java
10
10
```

### Enums

[Enums](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-enums/) ir īpaša klase, kas ļauj iekļaut **nemainīgas konstantes jūsu kodā**. Šīm mainīgajām tiek piešķirtas fiksētas vērtības, kuras nevar mainīt. Šis datu tips ir īpaši noderīgs, ja jums ir nepieciešamas mainīgās, kurām var būt tikai daži iespējamie stāvokļi. Enum sintakse izskatās šādi:

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


This is a markdown version of: [https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-datu-tipi/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-datu-tipi/) for AI/LLM consumption.