# Como usar Java final em classes, métodos e variáveis

A palavra-chave final em Java é usada para criar elementos que não podem ser alterados posteriormente. Esse modificador pode ser usado em classes, métodos e variáveis, principalmente para evitar erros e utilizações inadequadas de códigos.

## O que é Java final?

A maioria das [linguagens de programação](https://www.ionos.com/digitalguide/websites/web-development/web-programming-languages/ "Linguagens de programação web") oferecem a possibilidade de alterar e ampliar códigos que já existem. Isso também é possível em Java, mas, em alguns casos, pode ser importante que um elemento seja **criado para ser inalterável**. O modificador que permite criar esse tipo de elementos em Java é o *final*. Ele pode ser usado para restringir o acesso a uma classe, um método ou uma variável. Com ele, o valor de uma variável final não poderá mais ser alterado, não será possível ampliar uma classe final e um método final não poderá mais ser implementado. Isso ajuda a evitar que o código seja utilizado de formas indesejadas.

## Classes finais

Use o Java final para uma classe sempre que você quiser impedir que a classe seja ampliada. Isso é feito com frequência, pois, em muitos casos, pode ser importante evitar a **derivação de uma subclasse**. Isso é válido principalmente para tipos de dados básicos, como `java.lang.Math` ou `java.lang.String`, que sempre são declarados como final. Mesmo se você tiver outros motivos para evitar que subclasses sejam derivadas de uma classe, o Java final é a melhor forma de fazer isso. O exemplo abaixo esclarece como criar uma classe final e uma segunda classe que tenta ampliá-la. Em seguida, há uma classe `main` com o método `main`.

```java
final class ClasseFinal {
	public void exemplodemetodo() {
		System.out.println("Este é um método dentro da classe final");
	}
}
class OutraClasse extends ClasseFinal {
	public void exemplodemetodo() {
		System.out.println("O método agora também está na outra classe.");
	}
}
public class Main {
	public static void main(String[] args) {
		OutraClasse nossaOutraClasse = new OutraClasse();
		nossaOutraClasse.exemplodemetodo();
	}
}
```

Ao tentar executar o código, receberemos a seguinte mensagem:

```java
Main.java:6: error: cannot inherit from final ClasseFinal
class OutraClasse extends ClasseFinal
       ^
1 error
```

## Métodos finais

Se um método for identificado como final, ele **não poderá ser substituído**. Isso evita principalmente que um método possa receber outro significado em uma classe subordinada. Para evitar isso, crie um método final com o modificador Java final. No exemplo abaixo, isso é feito ao criar uma classe chamada “Imperador” que contém um método chamado “meuTitulo”. A classe seguinte, chamada “Rei” amplia a classe “Imperador” e tenta substituir o método “meuTitulo”. Para o método `main`, vamos usar “Principe” como outra forma de tentar acessar o método. No código, o exemplo fica assim:

```java
public class Imperador {
	public final void meuTitulo() {
		System.out.println("Eu sou o imperador.");
	}
}
public class Rei extends Imperador {
	public final void meuTitulo() {
		System.out.println("Eu sou o rei.");
	}
}
public class Principe {
	public static void main(String[] args) {
		Rei meuRei = new Rei();
		Rei.meuTitulo();
	}
}
```

Ao tentar usar o código, a seguinte mensagem de erro é emitida:

```java
Main.java:9: error meuTitulo() in Rei cannot override meuTitulo() in Imperador public final void meuTitulo() {
		^
overriden method is final
```

## Variáveis finais

O Java final também é usado para criar variáveis cujo **valor não pode ser alterado posteriormente**. Isso é importante principalmente quando determinadas variáveis devem permanecer sempre constantes em um código. No exemplo a seguir, é criada uma variável x que contém o valor 5. A seguir, tentamos chamar essa variável e atribuir um novo valor a ela. Veja abaixo como fica o código:

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

Se usarmos o [comando Java](https://www.ionos.com/digitalguide/websites/web-development/java-commands/ "Comandos em Java") `System.out.println` para ver o resultado, a seguinte mensagem de erro é emitida:

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

### Variáveis finais vazias

A princípio, todas as variáveis devem ser inicializadas em Java. Mas, se você declarar uma variável final vazia, poderá inicializar a variável com um construtor de classe. No código, isso pode ser feito da seguinte forma:

```java
public class Exemplo {
	final String exemplodetexto;
	Exemplo() {
		exemplodetexto = "Sua mensagem aqui.";
	}
	public static void main(String[] args) {
		Exemplo novoObjeto = new Exemplo();
		System.out.println(novoObjeto.exemplodetexto);
	}
}
```

Ao ser executado, esse código retorna a seguinte frase:

```java
Sua mensagem aqui.
```


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-final/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-final/) for AI/LLM consumption.