# Sådan bruges Java-variabler

Java-variabler er containere, der kan gemme forskellige [Java-datatyper](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-datatyper/). De omfatter lokale variabler, instansvariabler og statiske variabler. Selvom størrelsen på Java-variabler ikke kan ændres efterfølgende, kan du ændre deres indhold, efter du har oprettet dem.

## Hvad er Java-variabler?

Alle programmeringssprog har variabler, der bruges til at arbejde med koden i et program. Variabler er **containere, der gemmer data af en bestemt datatype** (og kun data af den type). I Java kan variabler indeholde [Javas primitive datatyper](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-primitiver/) som hele tal, flydende tal, sandhedsværdier og individuelle cifre. De kan også gemme komplekse datatyper som [Java-strenge](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-strenge/). Variabler i Java har en specifik, klart defineret størrelse, der ikke kan ændres efterfølgende. Indholdet af en variabel kan dog ændres senere. I denne vejledning introducerer vi de forskellige variabletyper og viser, hvordan man opretter variabler til forskellige datatyper.

## Sådan deklareres og initialiseres `var` i Java

Det første, du skal vide, er, hvordan man deklarerer og initialiserer Java-variabler. Denne proces er den samme for alle typer variabler. For **at deklarere en variabel** skal du bruge **to parametre**. Den første er den datatype, du vil gemme i variablen. Den anden er navnet på variablen.

Når du derefter **initialiserer variablen**, er der **3 ingredienser**. Du skal ikke kun bruge datatypen og navnet på variablen som ovenfor, men også en værdi for den. Initialisering af en variabel svarer til at tildele en værdi til en tidligere tom variabel.

Sådan ser syntaksen ud:

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

## Hvad er de tre variabletyper i Java?

Der er tre typer variabler i Java: lokale variabler, instansvariabler og statiske variabler.

### Lokale variabler

Lokale variabler i Java deklareres i kroppen af en metode, konstruktør eller blok. Variablen kan derefter kun bruges inden for den pågældende metode. Sådan ser det ud 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 således ud:

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

### Instansvariabler

Instansvariabler oprettes **inden for en klasse, men uden for en metode, konstruktør eller blok**. De opstår, når du opretter et objekt med nøgleordet ‘new’. I modsætning til lokale variabler har instansvariabler standardværdier. For tal er standardværdien 0 eller 0,0. For booleske værdier er den false. For objektreferencer er den null.

I det følgende eksempel kan du se, hvordan instansvariabler bruges i Java. I koden opretter vi en gruppe af personer, der ønsker at bidrage til en fødselsdagsgave, og viser, hvad hver person har bidraget 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 kode:

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

### Statiske variabler

Mens de to andre Java-variabeltyper ikke kan deklareres statisk, kan statiske variabler det. De deklareres **uden for en metode, konstruktør eller blok** og tilhører dermed klassen og ikke en instans. De bruges af alle instanser i en klasse. Statiske variabler tildeles hukommelse, når klassen indlæses i hukommelsen. 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
```

## Sådan oprettes variabler med forskellige datatyper

Processen med at oprette Java-variabler er ret ens på tværs af datatyper. Vi viser dig nogle eksempler på de mest almindelige datatyper og forklarer forskellene mellem dem.

### boolean

En [boolsk variabel](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/javas-primitive-datatype-boolean/) kan kun indeholde sandhedsværdierne **sand eller falsk**. 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 almindeligt anvendte datatype til **heltal**. Du kan deklarere en Java-variabel for en int på følgende måde:

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

Her er resultatet:

```java
10
```

### flyde

float bruges til **decimaltal**. Sådan deklarerer du 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
```

### char

char indeholder **et enkelt tegn**, der er angivet i enkelt anførselstegn. Sådan ser det ud 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

Ud over de primitive datatyper, vi har set på ovenfor, kan Java-variabler også indeholde **komplette strenge**. Strenge skal indtastes i dobbelte 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/da-dk/digitalguide/websteder/webudvikling/java-variabler/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-variabler/) for AI/LLM consumption.