# Kā lietot Java mainīgos

Java mainīgie ir konteineri, kuros var uzglabāt dažādus [Java datu tipus](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-datu-tipi/). Tie ietver lokālos mainīgos, instancē mainīgos un statiskos mainīgos. Lai gan Java mainīgo izmēru pēc to izveides nevar mainīt, to saturu var mainīt pēc to izveides.

## Kas ir Java mainīgie?

Katrā programmēšanas valodā ir mainīgie, kas tiek izmantoti, lai strādātu ar programmas kodu. Mainīgie ir **konteineri, kuros tiek uzglabāti konkrēta datu tipa dati** (un tikai šā tipa dati). Java valodā mainīgie var saturēt [Java primitīvos datu tipus](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-primitivie-tipi/), piemēram, veselos skaitļus, peldošā punkta skaitļus, patiesības vērtības un atsevišķus ciparus. Tie var uzglabāt arī sarežģītus datu tipus, piemēram, [Java virknes](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-virknes/). Mainīgajiem Java valodā ir konkrēts, skaidri definēts izmērs, ko pēc tam nevar mainīt. Tomēr mainīgā saturu var mainīt vēlāk. Šajā apmācībā iepazīstinām ar dažādiem mainīgo tipiem un parādām, kā izveidot mainīgos dažādiem datu tipiem.

## Kā deklarēt un inicializēt `var` Java valodā

Pirmā lieta, kas jums jāzina, ir, kā deklarēt un inicializēt Java mainīgos. Šis process ir vienāds visiem mainīgo tipiem. Lai **deklarētu mainīgo**, jums ir nepieciešami **divi parametri**. Pirmais ir datu tips, kuru jūs vēlaties saglabāt mainīgajā. Otrais ir mainīgā nosaukums.

Kad jūs pēc tam **inicializējat mainīgo**, ir **3 sastāvdaļas**. Jums būs nepieciešams ne tikai datu tips un mainīgā nosaukums, kā minēts iepriekš, bet arī tā vērtība. Mainīgā inicializēšana nozīmē vērtības piešķiršanu iepriekš tukšam mainīgajam.

Šeit ir redzams, kā izskatās sintakse:

```java
Datatype Name = Value;
```

## Kādi ir trīs mainīgo tipi Java?

Java ir trīs veidu mainīgie: lokālie mainīgie, instancē mainīgie un statiskie mainīgie.

### Vietējās mainīgās

Vietējās mainīgās Java valodā tiek deklarētas metodes, konstruktora vai bloka ķermenī. Mainīgā var tikt izmantota tikai šajā metodē. Šeit ir redzams, kā tas izskatās praksē:

```java
public class Main {
	public static void main(String[] args) {
		int var = 5;
		System.out.println("The local variable is: " + var);
	}
}
```

Rezultāts izskatīsies šādi:

```java
The local variable is: 5
```

### Instances mainīgie

Instances mainīgie tiek izveidoti **klasē, bet ārpus metodes, konstruktora vai bloka**. Tie rodas, kad izveidojat objektu ar atslēgvārdu “new”. Atšķirībā no lokālajiem mainīgajiem, instances mainīgajiem ir standarta vērtības. Skaitļiem standarta vērtība ir 0 vai 0,0. Boole’a mainīgajiem tā ir false. Objekta atsaucēm tā ir null.

Šajā piemērā var redzēt, kā Java tiek izmantotas instancu mainīgās. Kodā mēs izveidosim grupu cilvēku, kuri vēlas piedalīties dzimšanas dienas dāvanas iegādē, un uzskaitīsim, ko katrs no viņiem ir ieguldījis.

```java
public class Gift  {
	public String name;
	private double contribution;
	public Gift (String person) {
		name = person;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getContribution() {
		return contribution;
	}
	public void setContribution(double participantContribution) {	
		contribution = participantContribution;
	}
	public static void main(String[] args) {
		Gift participant = new Gift ("Peter");
		participant.setContribution(10);
		System.out.println("Name: " + participant.getName());
		System.out.println("Contribution = " + participant.getContribution());
		Gift participant2 = new Gift ("Maria");
		participant2.setContribution(15);
		System.out.println("Name: " + participant2.getName());
		System.out.println("Contribution  = " + participant2.getContribution());
	}
}
```

Šeit ir šī koda izvade:

```java
Name: Peter
Contribution = 10.0
Name: Maria
Contribution = 15.0
```

### Statiskās mainīgās

Lai gan pārējie divi Java mainīgo tipu veidi nevar tikt deklarēti statiski, statiskie mainīgie var. Tie tiek deklarēti **ārpus metodes, konstruktora vai bloka** un tādējādi pieder klasei, nevis instancēm. Tos izmanto visas klases instances. Statiskajiem mainīgajiem tiek piešķirta atmiņa, kad klase tiek ielādēta atmiņā. Šeit ir piemērs kodā:

```java
public class Gift {
	public static String participant = "Peter";
	public static void main(String[] args) {
		System.out.println("Participant: " + Gift.participant);
	}
}
```

Šeit ir rezultāts:

```java
Participant: Peter
```

## Kā izveidot mainīgos ar dažādiem datu tipiem

Java mainīgo izveides process ir diezgan līdzīgs visiem datu tipiem. Mēs parādīsim jums dažus piemērus visbiežāk sastopamajiem datu tipiem un izskaidrosim to atšķirības.

### boolean

[Boole’a](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-booleanu-primitivais-datu-tips/) vērtība var saturēt tikai patiesības vērtības **true vai false**. Tā tiek deklarēta šādi:

```java
public class Main {
	public static void main(String[] args) {
		boolean pizzaTastesGood = true;
		System.out.println(pizzaTastesGood);
	}
}
```

Šeit ir rezultāts:

```java
true
```

### int

int ir visbiežāk izmantotais datu tips **veseliem skaitļiem**. Java var var deklarēt int šādi:

```java
public class Main {
	public static void main(String[] args) {
		int x = 10;
		System.out.println(x);
	}
}
```

Šeit ir rezultāts:

```java
10
```

### peldēt

float tiek izmantots **decimāliem skaitļiem**. Šeit ir parādīts, kā Java valodā var deklarēt float mainīgo:

```java
public class Main {
	public static void main(String[] args) {
		float x = -17.03f;
		System.out.println(x);
	}
}
```

Šeit ir rezultāts:

```java
-17.03
```

### rakstzīme

char satur **vienu rakstzīmi**, kas ir iezīmēta ar vienkāršajiem pēdiņiem. Šeit ir redzams, kā tas izskatās kodā:

```java
public class Main {
	public static void main(String[] args) {
		char x = 'S';
		System.out.println(x);
	}
}
```

Šeit ir rezultāts:

```java
S
```

### Stīga

Papildus iepriekš apskatītajiem primitīvajiem datu tipiem Java mainīgie var saturēt arī **pilnīgas virknes**. Virknes jāievada dubultās pēdiņās:

```java
public class Main {
	public static void main(String[] args) {
		String example = "This is a string in Java.";
		System.out.println(example);
	}
}
```

Šeit ir rezultāts:

```java
This is a string in Java.
```


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