# Hvordan bruke Java-variabler

Java-variabler er beholdere som kan lagre forskjellige [Java-datatyper](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-datatyper/). De inkluderer lokale variabler, instansvariabler og statiske variabler. Selv om størrelsen på Java-variabler ikke kan endres i etterkant, kan du endre innholdet i dem etter at du har opprettet dem.

## Hva er Java-variabler?

Alle programmeringsspråk har variabler som brukes til å arbeide med koden i et program. Variabler er **beholdere som lagrer data av en bestemt datatype** (og kun data av den typen). I Java kan variabler inneholde [Javas primitive datatyper](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-primitiver/) som hele tall, flytende tall, sannhetsverdier og individuelle siffer. De kan også lagre komplekse datatyper som [Java-strenger](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-strenger/). Variabler i Java har en spesifikk, klart definert størrelse som ikke kan endres i etterkant. Innholdet i en variabel kan imidlertid endres senere. I denne veiledningen introduserer vi de forskjellige variabeltypene og viser hvordan du oppretter variabler for forskjellige datatyper.

## Hvordan deklarere og initialisere `var` i Java

Det første du må vite er hvordan du deklarerer og initialiserer Java-variabler. Denne prosessen er den samme for alle typer variabler. For **å deklarere en variabel** trenger du **to parametere**. Den første er datatypen du vil lagre i variabelen. Den andre er navnet på variabelen.

Når du deretter **initialiserer variabelen**, er det **tre ingredienser**. Du trenger ikke bare datatypen og navnet på variabelen som ovenfor, men også en verdi for den. Å initialisere en variabel innebærer å tildele en verdi til en tidligere tom variabel.

Slik ser syntaksen ut:

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

## Hva er de tre variabeltypene i Java?

Det finnes tre typer variabler i Java: lokale variabler, instansvariabler og statiske variabler.

### Lokale variabler

Lokale variabler i Java deklareres i kroppen av en metode, konstruktør eller blokk. Variabelen kan da bare brukes innenfor den metoden. Slik ser det ut i praksis:

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

Resultatet vil se slik ut:

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

### Instansvariabler

Instansvariabler opprettes **inne i en klasse, men utenfor en metode, konstruktør eller blokk**. De oppstår når du oppretter et objekt med nøkkelordet «new». I motsetning til lokale variabler har instansvariabler standardverdier. For tall er standardverdien 0 eller 0,0. For boolske verdier er den false. For objektreferanser er den null.

I det følgende eksemplet kan du se hvordan instansvariabler brukes i Java. I koden skal vi opprette en gruppe mennesker som ønsker å bidra til en bursdagsgave, og liste opp hva hver person har bidratt med.

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

Her er resultatet for denne koden:

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

### Statiske variabler

Mens de to andre Java-variabeltypene ikke kan deklareres statisk, kan statiske variabler det. De deklareres **utenfor en metode, konstruktør eller blokk** og tilhører dermed klassen og ikke en instans. De brukes av alle instansene i en klasse. Statiske variabler tildeles minne når klassen lastes inn i minnet. Her er et eksempel i kode:

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

Her er resultatet:

```java
Participant: Peter
```

## Hvordan opprette variabler med forskjellige datatyper

Prosessen med å opprette Java-variabler er ganske lik for alle datatyper. Vi viser deg noen eksempler på de vanligste datatypene og forklarer forskjellene mellom dem.

### boolsk

En [boolsk variabel](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/javas-primitive-datatype-boolean/) kan bare inneholde sannhetsverdiene **sant eller usant**. Den deklareres som følger:

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

Her er resultatet:

```java
true
```

### int

int er den mest brukte datatypen for **heltall**. Du kan deklarere en Java-variabel for en int slik:

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

Her er resultatet:

```java
10
```

### flyte

float brukes til **desimaltall**. Slik kan du deklarere en float-variabel i Java:

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

Her er resultatet:

```java
-17.03
```

### karakter

char inneholder **et enkelt tegn** som er angitt med enkle anførselstegn. Slik ser det ut i koden:

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

Her er resultatet:

```java
S
```

### Streng

I tillegg til de primitive datatypene vi så på ovenfor, kan Java-variabler også inneholde **komplette strenger**. Strenger skal skrives inn i doble anførselstegn:

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

Her er resultatet:

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


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-variabler/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-variabler/) for AI/LLM consumption.