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 suspender. 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í:

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

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

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

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: cannt 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.