# Hvordan bruke Java final for klasser, metoder og variabler

Nøkkelordet `final` brukes i Java til å opprette elementer som ikke kan endres. Du kan bruke denne modifikatoren på klasser, metoder og variabler. Den brukes spesielt til å forhindre feil og bevisst misbruk i koden.

## Hva er Java `final`?

De fleste programmeringsspråk tillater at eksisterende kode kan endres og utvides etter ønske. I Java er dette også mulig, men det finnes tilfeller hvor det er avgjørende at et element blir **angitt som uforanderlig**. I Java kan du gjøre dette ved hjelp av modifikatoren `final`. Denne modifikatoren brukes til å begrense tilgangen til en klasse, en metode eller en variabel. Når en variabel er erklært som endelig, kan verdien ikke endres. En final klasse kan ikke utvides, og en final metode kan ikke overstyres. Dette bidrar til å beskytte mot misbruk av den delen av koden.

## Siste timer

Hvis du bruker Java `final` for en klasse, kan den ikke lenger utvides. Denne tilnærmingen er svært vanlig, og brukes i mange tilfeller for å forhindre **avledning av en underklasse**. Dette gjelder grunnleggende datatyper som `java.lang.Math` eller `java.lang.String`, som alltid erklæres som endelige. Selv om du av andre grunner ønsker å forhindre at underklasser av en hovedklasse avledes, er det best å bruke Java `final`. I det følgende eksemplet skal vi opprette en endelig klasse og en andre klasse som teoretisk sett skal utvide den. Deretter 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();
	}
}
```

Resultatet du får, bør se omtrent slik ut:

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

## Endelige metoder

Hvis du merker en metode som final, kan den ikke overskrives. Dette sikrer at en metode i en underklasse ikke kan endre sin tiltenkte atferd. For å oppnå dette, erklær metoden med Java `final` -modifikatoren. Ta for eksempel en klasse med navnet «Emperor» som inneholder en final-metode kalt «myTitle». En annen klasse, «King», som utvider «Emperor», forsøker å overskrive metoden «myTitle». I hovedmetoden bruker vi en instans av «Prince» for å få tilgang til metoden. Koden ser slik ut:

```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 nå bruker denne koden, vil du få en feilmelding:

```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` brukes også til å opprette variabler med **verdier som ikke kan endres senere**. Dette er spesielt viktig hvis visse variabler skal forbli konstante i koden. I det følgende eksemplet skal vi opprette variabelen x, som har verdien 5. Deretter skal vi prøve å sette inn denne variabelen og tildele den en ny verdi. Koden ser slik ut:

```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 bruker Java-kommandoen `System.out.println` for å vise resultatet, får vi følgende feilmelding:

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

### Opprett tomme endelige variabler

Variabler må alltid initialiseres i Java. Hvis du imidlertid deklarerer en tom endelig variabel, kan du initialisere den med en klassekonstruktør. Slik ser koden ut:

```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 kjører denne koden, vil du få følgende setning som utdata:

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


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