# Sådan bruges Java final til klasser, metoder og variabler

Nøgleordet `final` bruges i Java til at oprette elementer, der ikke kan ændres. Du kan anvende denne modifikator på klasser, metoder og variabler. Den bruges især til at forhindre fejl og bevidst misbrug i koden.

## Hvad er Java `final`?

De fleste programmeringssprog tillader, at eksisterende kode ændres og udvides efter ønske. I Java er dette også muligt, men der er tilfælde, hvor det er afgørende, at et element **udpeges som uændeligt**. I Java kan du gøre dette ved hjælp af modifikatoren `final`. Denne modifikator bruges til at begrænse adgangen til en klasse, en metode eller en variabel. Når en variabel er erklæret som endelig, kan dens værdi ikke ændres. En final klasse kan ikke udvides, og en final metode kan ikke overskrives. Dette hjælper med at beskytte mod misbrug af den pågældende del af koden.

## Afsluttende undervisning

Hvis du bruger Java `final` til en klasse, kan den ikke længere udvides. Denne tilgang er meget almindelig og bruges i mange tilfælde til at forhindre **afledning af en underklasse**. Dette gælder for grundlæggende datatyper som `java.lang.Math` eller `java.lang.String`, der altid erklæres som endelige. Selv hvis du af andre årsager ønsker at forhindre, at underklasser af en hovedklasse afledes, er det bedst at bruge Java `final`. I det følgende eksempel opretter vi en endelig klasse og en anden klasse, der teoretisk set skal udvide den. Derefter kommer hovedklassen med hovedmetoden.

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

Det resultat, du får, bør se nogenlunde sådan ud:

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

## Endelige metoder

Hvis du markerer en metode som endelig, kan den ikke overskrives. Dette sikrer, at en metode i en underklasse ikke kan ændre sin tilsigtede adfærd. For at opnå dette skal du deklarere metoden med `final` -modifikatoren. Betragt for eksempel en klasse ved navn ‘Emperor’, der indeholder en endelig metode kaldet ‘myTitle’. En anden klasse, ‘King’, der udvider ‘Emperor’, forsøger at overskrive metoden ‘myTitle’. I hovedmetoden bruger vi en instans af ‘Prince’ til at få adgang til metoden. Koden ser således ud:

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

Hvis du nu anvender denne kode, vil du modtage en fejlmeddelelse:

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

## Endelige variabler

Java `final` bruges også til at oprette variabler med **værdier, der ikke kan ændres efterfølgende**. Dette er især vigtigt, hvis visse variabler skal forblive konstante i koden. I det følgende eksempel opretter vi variablen x, som har værdien 5. Derefter forsøger vi at indsætte denne variabel og tildele den en ny værdi. Koden ser således ud:

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

Når vi bruger Java-kommandoen `System.out.println` til at vise resultatet, får vi følgende fejlmeddelelse:

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

### Opret tomme endelige variabler

Variabler skal altid initialiseres i Java. Hvis du imidlertid deklarerer en tom endelig variabel, kan du initialisere den med en klassekonstruktør. Sådan ser koden ud:

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

Hvis du udfører denne kode, får du følgende sætning som output:

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


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-endelig/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-endelig/) for AI/LLM consumption.