# Kako uporabljati spremenljivke Java

Java spremenljivke so kontejnerji, ki lahko shranjujejo različne [tipe podatkov Java](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/tipi-podatkov-v-javi/). Vključujejo lokalne spremenljivke, spremenljivke instance in statične spremenljivke. Čeprav velikosti Java spremenljivk ni mogoče spremeniti naknadno, lahko njihovo vsebino spremenite po njihovi ustvaritvi.

## Kaj so spremenljivke Java?

Vsak programski jezik ima spremenljivke, ki se uporabljajo za delo s kodo v programu. Spremenljivke so **posode, ki shranjujejo podatke določenega podatkovnega tipa** (in samo podatke tega tipa). V Javi lahko spremenljivke vsebujejo [primitivne podatkovne tipe Jave](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-primitivni-tipi/), kot so cela števila, števila s plavajočo vejico, resnične vrednosti in posamezne številke. Shranjujejo lahko tudi kompleksne podatkovne tipe, kot so [nizi Jave](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-nizi/). Spremenljivke v Javi imajo določeno, jasno opredeljeno velikost, ki je naknadno ni mogoče spremeniti. Vsebino spremenljivke pa je mogoče spremeniti naknadno. V tem vadniku predstavljamo različne tipe spremenljivk in pokažemo, kako ustvariti spremenljivke za različne podatkovne tipe.

## Kako deklarirati in inicializirati `var` v Javi

Najprej morate vedeti, kako deklarirati in inicializirati spremenljivke v Javi. Ta postopek je enak za vse vrste spremenljivk. Za **deklaracijo spremenljivke** potrebujete **dva parametra**. Prvi je podatkovni tip, ki ga želite shraniti v spremenljivki. Drugi je ime spremenljivke.

Ko nato **inicializirate spremenljivko**, so potrebni **trije elementi**. Potrebujete ne le podatkovni tip in ime spremenljivke, kot je navedeno zgoraj, ampak tudi vrednost zanjo. Inicializacija spremenljivke pomeni dodelitev vrednosti prej prazni spremenljivki.

Tako izgleda sintaksa:

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

## Kateri so trije tipi spremenljivk v Javi?

V Javi obstajajo tri vrste spremenljivk: lokalne spremenljivke, spremenljivke instance in statične spremenljivke.

### Lokalne spremenljivke

Lokalne spremenljivke v Javi se deklarirajo v telesu metode, konstruktorja ali bloka. Spremenljivka se nato lahko uporablja samo znotraj te metode. Tako to izgleda v praksi:

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

Izhod bo izgledal takole:

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

### Instance spremenljivke

Instance spremenljivke se ustvarijo **znotraj razreda, vendar zunaj metode, konstruktorja ali bloka**. Nastanejo, ko ustvarite objekt s ključno besedo »new«. Za razliko od lokalnih spremenljivk imajo instance spremenljivke standardne vrednosti. Za številke je standardna vrednost 0 ali 0,0. Za logične spremenljivke je to false. Za referenčne spremenljivke je to null.

V naslednjem primeru lahko vidite, kako se v Javi uporabljajo spremenljivke instance. V kodi bomo ustvarili skupino ljudi, ki želijo prispevati k rojstnodnevnemu darilu, in navedli, kaj je prispeval vsak posameznik.

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

Tukaj je izhod za ta kod:

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

### Statične spremenljivke

Medtem ko drugih dveh tipov spremenljivk v Javi ni mogoče deklarirati statično, statične spremenljivke pa je mogoče. Deklarirane so **zunaj metode, konstruktorja ali bloka** in tako pripadajo razredu in ne instanci. Uporabljajo jih vse instance v razredu. Statične spremenljivke dobijo dodeljen pomnilnik, ko se razred naloži v pomnilnik. Tukaj je primer v kodi:

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

Tukaj je izhod:

```java
Participant: Peter
```

## Kako ustvariti spremenljivke z različnimi tipi podatkov

Postopek ustvarjanja spremenljivk v Javi je za vse podatkovne tipe precej podoben. Pokazali vam bomo nekaj primerov za najpogostejše podatkovne tipe in pojasnili njihove razlike.

### boolean

[Boolean](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/primitivni-podatkovni-tip-boolean-v-javi/) lahko vsebuje samo resnične vrednosti **true ali false**. Deklariran je na naslednji način:

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

Tukaj je izhod:

```java
true
```

### int

int je najpogosteje uporabljen podatkovni tip za **cela števila**. Java var za int lahko deklarirate takole:

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

Tukaj je izhod:

```java
10
```

### plavati

float se uporablja za **decimalna števila**. Tako lahko v Javi deklariraš spremenljivko float:

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

Tukaj je izhod:

```java
-17.03
```

### char

char vsebuje **en znak**, ki je zapisan v enojnih narekovajih. Tako to izgleda v kodi:

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

Tukaj je izhod:

```java
S
```

### Niz

Poleg primitivnih podatkovnih tipov, ki smo jih obravnavali zgoraj, lahko spremenljivke v Javi vsebujejo tudi **celotne nize**. Nize je treba vnesti v dvojnih narekovajih:

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

Tukaj je izhod:

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


This is a markdown version of: [https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-spremenljivke/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-spremenljivke/) for AI/LLM consumption.