# Hoe Java final te gebruiken voor klassen, methoden en variabelen

Het sleutelwoord `final` wordt in Java gebruikt om elementen te creëren die niet kunnen worden gewijzigd. Je kunt deze modifier toepassen op klassen, methoden en variabelen. Het wordt met name gebruikt om fouten en opzettelijk misbruik binnen de code te voorkomen.

## Wat is Java `final`?

In de meeste programmeertalen kan bestaande code naar wens worden gewijzigd en uitgebreid. In Java is dit ook mogelijk, maar er zijn gevallen waarin het cruciaal is dat een element **als onveranderlijk** wordt **aangemerkt**. In Java kunt u dit doen met behulp van de `final`. Deze modificator wordt gebruikt om de toegang tot een klasse, een methode of een variabele te beperken. Zodra een variabele als definitief is aangemerkt, kan de waarde ervan niet meer worden gewijzigd. Een final-klasse kan niet worden uitgebreid en een final-methode kan niet worden overschreven. Dit helpt om misbruik van dat deel van de code te voorkomen.

## Laatste lessen

Als u Java `final` voor een klasse gebruikt, kan deze niet meer worden uitgebreid. Deze aanpak is heel gebruikelijk en wordt in veel gevallen gebruikt om het **afleiden van een subklasse** te voorkomen. Dit geldt voor basisgegevenstypen zoals `java.lang.Math` of `java.lang.String`, die altijd als definitief worden gedeclareerd. Zelfs als u om andere redenen wilt voorkomen dat subklassen van een hoofdklasse worden afgeleid, is het gebruik van Java `final` de beste manier. In het volgende voorbeeld maken we een definitieve klasse en een tweede klasse die deze in theorie zou moeten uitbreiden. Daarna komt de hoofdklasse met de hoofdmethode.

```java
final class FinalClass {
	public void exampleMethod() {
		System.out.println("This is a method within the final class.");
	}
}
class AdditionalClass extends FinalClass {
	public void exampleMethod() {
		System.out.println("The method is now also available in the additional class.");
	}
}
public class Main {
	public static void main(String[] args) {
		AdditionalClass ourAdditionalClass = new AdditionalClass();
		ourAdditionalClass.exampleMethod();
	}
}
```

De uitvoer die u ontvangt, zou er ongeveer zo uit moeten zien:

```java
Main.java:6: error: cannot inherit from final FinalClass
class AdditionalClass extends FinalClass
       ^
1 error
```

## Definitieve methoden

Als u een methode als definitief markeert, kan deze niet worden overschreven. Dit zorgt ervoor dat een methode in een subklasse het beoogde gedrag niet kan wijzigen. Om dit te bereiken, declareert u de methode met de `final`. Neem bijvoorbeeld een klasse met de naam ‘Emperor’ die een definitieve methode met de naam ‘myTitle’ bevat. Een andere klasse, ‘King’, die ‘Emperor’ uitbreidt, probeert de methode ‘myTitle’ te overschrijven. In de hoofdmethode gebruiken we een instantie van ‘Prince’ om toegang te krijgen tot de methode. De code ziet er als volgt uit:

```java
public class Emperor {
	public final void myTitle() {
		System.out.println("I am the emperor.");
	}
}
public class King extends Emperor {
	public final void myTitle() {
		System.out.println("I am the king.");
	}
}
public class Prince {
	public static void main(String[] args) {
		King myTitle = new King();
		King.myTitle();
	}
}
```

Als u deze code nu toepast, krijgt u een foutmelding:

```java
Main.java:9: error myTitle() in King cannot override myTitle() in Emperor public final void myTitle() {
		^
overridden method is final
```

## Eindvariabelen

Java `final` wordt ook gebruikt om variabelen te maken met **waarden die achteraf niet meer kunnen worden gewijzigd**. Dit is vooral belangrijk als bepaalde variabelen constant moeten blijven binnen de code. In het volgende voorbeeld maken we de variabele x aan, die de waarde 5 heeft. Vervolgens proberen we deze variabele in te voegen en er een nieuwe waarde aan toe te kennen. De code ziet er als volgt uit:

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

Wanneer we het Java-commando `System.out.println` gebruiken om het resultaat weer te geven, krijgen we de volgende foutmelding:

```java
Main.java:6: error: cannot assign a value to final variable x
	newValue.x = 10;
		     ^
1 error
```

### Maak lege eindvariabelen aan

Variabelen moeten altijd worden geïnitialiseerd in Java. Als u echter een lege definitieve variabele declareert, kunt u deze initialiseren met een klasseconstructor. Dit is hoe de code eruitziet:

```java
public class Example {
	final String exampleText;
	Example() {
		exampleText = "Here is your message.";
	}
	public static void main(String[] args) {
		Example newObject = new Example();
		System.out.println(newObject.exampleText);
	}
}
```

Als je deze code uitvoert, krijg je de volgende zin als uitvoer:

```java
Here is your message.
```


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