Java final: cómo utilizar el mo­di­fi­ca­dor para clases, métodos y variables

El mo­di­fi­ca­dor final se utiliza en Java para crear elementos que no pueden mo­di­fi­car­se po­s­te­rio­r­me­n­te. Puedes aplicar este mo­di­fi­ca­dor a clases, métodos y variables. Se utiliza sobre todo para evitar errores y usos indebidos in­te­n­cio­na­dos dentro del código.

¿Qué es Java final?

La mayoría de lenguajes de pro­gra­ma­ción ofrecen la po­si­bi­li­dad de modificar y ampliar el código existente en función de las ne­ce­si­da­des. Aunque en principio esto también es posible en Java, a veces puede ser im­po­r­ta­n­te que un elemento se almacene como in­ca­m­bia­ble. El mo­di­fi­ca­dor co­rre­s­po­n­die­n­te se denomina final en Java. Puede uti­li­zar­se para re­s­tri­n­gir el acceso a una clase, un método o una variable. Con él, el valor de una variable final ya no se puede cambiar, las ex­te­n­sio­nes para una clase final no son posibles y un método final no se puede so­bre­s­cri­bir. De este modo se evita el uso indebido de la sección de código co­rre­s­po­n­die­n­te.

Clases finales

Si utilizas el mo­di­fi­ca­dor final de Java para una clase, ésta ya no podrá ser extendida. Este enfoque es muy común, ya que en muchos casos puede ser útil para evitar la de­ri­va­ción de una subclase. Esto se aplica en pa­r­ti­cu­lar a los tipos de datos básicos como java.lang.Math o java.lang.String, que siempre se declaran como final. Incluso si quieres evitar que se deriven subclases de una clase principal por otras razones, el mo­di­fi­ca­dor final es la mejor manera. En el siguiente ejemplo, creamos una clase final y una segunda clase que teó­ri­ca­me­n­te debería ex­te­n­de­r­la. La clase principal con el método main sigue en tercer lugar:

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

El resultado debe ser algo así:

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

Métodos finales

Si marcas un método como final, éste no podrá so­bree­s­cri­bi­r­se. Entre otras cosas, esto evita que se le dé un si­g­ni­fi­ca­do diferente a un método de una clase su­bo­r­di­na­da. Si quieres evitar esto, crea un método final con el mo­di­fi­ca­dor final de Java. Por ejemplo, creamos una clase llamada “Emperador” que contiene un método final llamado “miTitulo”. La siguiente clase, “Rey”, extiende “Emperador” e intenta so­bre­s­cri­bir el método “miTitulo”. Para el método main, uti­li­za­mos “Principe” e in­te­n­ta­mos acceder al método. El código se vería así:

class Emperador {
	public final void miTitulo() {
		System.out.println("Soy el emperador.");
	}
}
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();
		miTitulo.miTitulo();
	}
}

Si aplicas este código, recibirás un mensaje de error:

Principe.java:7: error: miTitulo() in Rey cannot override miTitulo() in Emperador
	public final void miTitulo() {
	                  ^
  overridden method is final
1 error

Variables finales

El mo­di­fi­ca­dor final también se utiliza para crear variables de tal forma que su valor no pueda ser mo­di­fi­ca­do po­s­te­rio­r­me­n­te. Esto es muy im­po­r­ta­n­te si ciertas variables deben pe­r­ma­ne­cer siempre contantes dentro del código. En el siguiente ejemplo, creamos una variable x que tiene el valor 5. A co­n­ti­nua­ción, in­te­n­ta­mos in­co­r­po­rar esta variable y asignarle un nuevo valor. El código se verá así:

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

Si ahora uti­li­za­mos el comando Java System.out.println para mostrar el resultado, recibimos el siguiente mensaje de error:

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

Crear variables finales vacías

En Java, las variables deben ini­cia­li­zar­se siempre. Sin embargo, si declaras una variable final vacía, puedes ini­cia­li­zar­la con un co­n­s­tru­c­tor de clase. Se verá así en el código:

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

Si ejecutas este código, recibirás la siguiente sentencia como resultado:

Este es tu mensaje.