# Java final: como utilizar o modificador para classes, métodos e variáveis

O modificador final é utilizado em Java para criar elementos que não podem ser modificados posteriormente. Pode aplicar este modificador a classes, métodos e variáveis. É utilizado principalmente para evitar erros e utilizações indevidas intencionais dentro do código.

## O que é Java final?

A maioria das linguagens de programação oferece a possibilidade de modificar e ampliar o código existente de acordo com as necessidades. Embora, em princípio, isso também seja possível em Java, às vezes pode ser importante que um elemento seja armazenado como **imutável.** O modificador correspondente é denominado final em Java. Pode ser utilizado para restringir o acesso a uma classe, um método ou uma variável. Com ele, o valor de uma variável final já não pode ser alterado, as extensões para uma classe final não são possíveis e um método final não pode ser suspenso. Desta forma, evita-se o uso indevido da secção de código correspondente.

## Aulas finais

Se utilizar o modificador final do Java para uma classe, esta já não poderá ser estendida. Esta abordagem é muito comum, pois em muitos casos pode ser útil para evitar a **derivação de uma subclasse**. Isto aplica-se particularmente a tipos de dados básicos como `java.lang.Math` ou `java.lang.String`, que são sempre declarados como finais. Mesmo que queira evitar que subclasses sejam derivadas de uma classe principal por outras razões, o modificador final é a melhor maneira. No exemplo a seguir, criamos uma classe final e uma segunda classe que, teoricamente, deveria estendê-la. A classe principal com o método main vem em terceiro lugar:

```java
final class ClaseFinal { 
public void metodoejemplo() { 
System.out.println("Este es un método dentro de la clase final."); 
} 
} 
class OtraClase extends ClaseFinal { 
public void metodoejemplo() { 
System.out.println("Este método está en la otra clase."); 
} 
} 
public class Main { 
public static void main(String[] args) { 
OtraClase NuestraOtraClase = new OtraClase(); 
NuestraOtraClase.metodoejemplo(); 
} 
}
```

O resultado deve ser algo assim:

```java
Main.java:6: error: cannot inherit from final ClaseFinal 
class OtraClase extends ClaseFinal 
    ^ 
1 error
```

## Métodos finais

Se marcar um método como final, ele **não poderá ser sobrescrito**. Entre outras coisas, isso evita que um método de uma classe subordinada receba um significado diferente. Se quiser evitar isso, crie um método final com o modificador final do Java. Por exemplo, criamos uma classe chamada «Imperador» que contém um método final chamado «meuTítulo». A classe seguinte, «Rei», estende «Imperador» e tenta sobrescrever o método «meuTítulo». Para o método principal, usamos «Príncipe» e tentamos aceder ao método. O código ficaria assim:

```java
public class Emperador { 
public final void miTitulo() { 
System.out.println("Soy el emperador."); 
} 
} 
public class Rey extends Emperador { 
public final void miTitulo() { 
System.out.println("Soy el rey."); 
} 
} 
public class Principe { 
public static void main(String[] args) { 
Rey miTitulo = new Rey(); 
Rey.miTitulo(); 
} 
}
```

Se aplicar este código, receberá uma mensagem de erro:

```java
Main.java:9: error miTitulo() in Rey cannot override miTitulo() in Emperador public final void miTitulo() { 
^ 
overriden method is final
```

## Variáveis finais

O modificador final também é usado para criar variáveis de forma que **o** seu **valor não possa ser modificado posteriormente**. Isso é muito importante se determinadas variáveis devem permanecer sempre constantes dentro do código. No exemplo a seguir, criamos uma variável x que tem o valor 5. Em seguida, tentamos incorporar essa variável e atribuir-lhe um novo valor. O código ficará assim:

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

Se agora utilizarmos o comando Java `System.out.println` para mostrar o resultado, receberemos a seguinte mensagem de erro:

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

### Criar variáveis finais vazias

Em Java, as variáveis devem sempre ser inicializadas. No entanto, se declarar uma variável final vazia, pode inicializá-la com um construtor de classe. No código, ficará assim:

```java
public class Ejemplo { 
final String textodeejemplo; 
Ejemplo() { 
textodeejemplo = "Este es tu mensaje."; 
} 
public static void main(String[] args) { 
Ejemplo nuevoObjeto = new Ejemplo(); 
System.out.println(nuevoObjeto.textodeejemplo); 
} 
}
```

Se executar este código, receberá a seguinte sentença como resultado:

```java
Este es tu mensaje.
```


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