# Hoe Java-variabelen te gebruiken

Java-variabelen zijn containers waarin verschillende [Java-gegevenstypen](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-gegevenstypen/) kunnen worden opgeslagen. Ze omvatten lokale variabelen, instantievariabelen en statische variabelen. Hoewel de grootte van Java-variabelen achteraf niet kan worden gewijzigd, kunt u hun inhoud wel wijzigen nadat u ze hebt aangemaakt.

## Wat zijn Java-variabelen?

Elke programmeertaal heeft variabelen die worden gebruikt om met de code in een programma te werken. Variabelen zijn **containers die gegevens van een specifiek gegevenstype** (en alleen gegevens van dat type) **opslaan**. In Java kunnen variabelen [primitieve gegevenstypen van Java](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-primitieven/) bevatten, zoals gehele getallen, drijvende-kommagetallen, waarheidswaarden en afzonderlijke cijfers. Ze kunnen ook complexe gegevenstypen opslaan, zoals [Java-strings](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-strings/). Variabelen in Java hebben een specifieke, duidelijk gedefinieerde grootte die achteraf niet kan worden gewijzigd. De inhoud van een variabele kan echter later worden gewijzigd. In deze tutorial introduceren we de verschillende variabele typen en laten we zien hoe je variabelen voor verschillende gegevenstypen kunt maken.

## Hoe `var` declareren en initialiseren in Java

Het eerste wat u moet weten, is hoe u Java-variabelen declareert en initialiseert. Dit proces is hetzelfde voor alle soorten variabelen. Om **een variabele te declareren**, hebt u **twee parameters** nodig. De eerste is het gegevenstype dat u in de variabele wilt opslaan. De tweede is de naam van de variabele.

Wanneer je vervolgens **de variabele initialiseert**, zijn er **drie ingrediënten**. Je hebt niet alleen het gegevenstype en de naam van de variabele nodig, zoals hierboven, maar ook een waarde ervoor. Het initialiseren van een variabele komt neer op het toekennen van een waarde aan een voorheen lege variabele.

Dit is hoe de syntaxis eruitziet:

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

## Wat zijn de drie variabele typen in Java?

Er zijn drie soorten variabelen in Java: lokale variabelen, instantievariabelen en statische variabelen.

### Lokale variabelen

Lokale variabelen in Java worden gedeclareerd in de body van een methode, constructor of blok. De variabele kan dan alleen binnen die methode worden gebruikt. Zo ziet dat er in de praktijk uit:

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

De uitvoer ziet er als volgt uit:

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

### Instance variabelen

Instance variabelen worden aangemaakt **binnen een klasse, maar buiten een methode, constructor of blok**. Ze ontstaan wanneer je een object aanmaakt met het sleutelwoord ‘new’. In tegenstelling tot lokale variabelen hebben instance variabelen standaardwaarden. Voor getallen is de standaardwaarde 0 of 0,0. Voor Booleans is dat false. Voor objectreferenties is dat null.

In het volgende voorbeeld ziet u hoe instantievariabelen in Java worden gebruikt. In de code maken we een groep mensen aan die willen bijdragen aan een verjaardagscadeau en geven we weer wat elke persoon heeft bijgedragen.

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

Dit is de uitvoer voor deze code:

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

### Statische variabelen

Terwijl de andere twee Java-variabeletypen niet statisch kunnen worden gedeclareerd, kunnen statische variabelen dat wel. Ze worden **buiten een methode, constructor of blok** gedeclareerd en behoren dus tot de klasse en niet tot een instantie. Ze worden gebruikt door alle instanties in een klasse. Statische variabelen krijgen geheugen toegewezen wanneer de klasse in het geheugen wordt geladen. Hier is een voorbeeld in code:

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

Dit is de uitvoer:

```java
Participant: Peter
```

## Hoe variabelen met verschillende gegevenstypen aanmaken

Het proces voor het maken van Java-variabelen is voor alle gegevenstypen vrijwel hetzelfde. We laten u enkele voorbeelden zien voor de meest voorkomende gegevenstypen en leggen de verschillen uit.

### booleaanse waarde

Een [Booleaanse waarde](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/javas-booleaanse-primitieve-gegevenstype/) kan alleen de waarheidswaarden **‘waar’ of ‘onwaar’** bevatten. Deze wordt als volgt gedeclareerd:

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

Dit is de uitvoer:

```java
true
```

### int

int is het meest gebruikte gegevenstype voor **gehele getallen**. Je kunt een Java-variabele voor een int als volgt declareren:

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

Dit is de uitvoer:

```java
10
```

### drijver

float wordt gebruikt voor **decimale getallen**. Hier volgt hoe u een float-variabele in Java kunt declareren:

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

Dit is de uitvoer:

```java
-17.03
```

### char

char bevat **één teken** dat tussen enkele aanhalingstekens staat. Zo ziet dat er in code uit:

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

Dit is de uitvoer:

```java
S
```

### Touw

Naast de primitieve datatypes die we hierboven hebben bekeken, kunnen Java-variabelen ook **volledige strings** bevatten. Strings moeten tussen dubbele aanhalingstekens worden geplaatst:

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

Dit is de uitvoer:

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


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-variabelen/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-variabelen/) for AI/LLM consumption.